src/msw/listctrl.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        listctrl.cpp
   3 // Purpose:     wxListCtrl
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart and Markus Holzem
   9 // Licence:     wxWindows license
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13     #pragma implementation "listctrl.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20     #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/wx.h"
  25 #endif
  26
  27 #if defined(__WIN95__)
  28
  29 #include "wx/listctrl.h"
  30 #include "wx/log.h"
  31
  32 #include "wx/msw/private.h"
  33
  34 #if (defined(__WIN95__) && !defined(__GNUWIN32__)) || defined(__TWIN32__)
  35     #include <commctrl.h>
  36 #endif
  37
  38 #ifndef __TWIN32__
  39     #ifdef __GNUWIN32__
  40         #include "wx/msw/gnuwin32/extra.h"
  41     #endif
  42 #endif
  43
  44 static void wxConvertToMSWListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& tvItem);
  45 static void wxConvertFromMSWListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& tvItem, HWND getFullInfo = 0);
  46
  47 #if !USE_SHARED_LIBRARY
  48     IMPLEMENT_DYNAMIC_CLASS(wxListCtrl, wxControl)
  49     IMPLEMENT_DYNAMIC_CLASS(wxListItem, wxObject)
  50 #endif // USE_SHARED_LIBRARY
  51
  52 wxListCtrl::wxListCtrl()
  53 {
  54     m_imageListNormal = NULL;
  55     m_imageListSmall = NULL;
  56     m_imageListState = NULL;
  57     m_baseStyle = 0;
  58     m_colCount = 0;
  59     m_textCtrl = NULL;
  60 }
  61
  62 bool wxListCtrl::Create(wxWindow *parent,
  63                         wxWindowID id,
  64                         const wxPoint& pos,
  65                         const wxSize& size,
  66                         long style,
  67                         const wxValidator& validator,
  68                         const wxString& name)
  69 {
  70     m_imageListNormal = NULL;
  71     m_imageListSmall = NULL;
  72     m_imageListState = NULL;
  73     m_textCtrl = NULL;
  74     m_colCount = 0;
  75
  76     SetValidator(validator);
  77     SetName(name);
  78
  79     int x = pos.x;
  80     int y = pos.y;
  81     int width = size.x;
  82     int height = size.y;
  83
  84     m_windowStyle = style;
  85
  86     SetParent(parent);
  87
  88     if (width <= 0)
  89         width = 100;
  90     if (height <= 0)
  91         height = 30;
  92     if (x < 0)
  93         x = 0;
  94     if (y < 0)
  95         y = 0;
  96
  97     m_windowId = (id == -1) ? NewControlId() : id;
  98
  99     DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP;
 100
 101     bool want3D;
 102     WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D) ;
 103
 104     // Even with extended styles, need to combine with WS_BORDER
 105     // for them to look right.
 106     if ( want3D || wxStyleHasBorder(m_windowStyle) )
 107         wstyle |= WS_BORDER;
 108
 109     wstyle |= LVS_SHAREIMAGELISTS | LVS_SHOWSELALWAYS   ;
 110     m_baseStyle = wstyle;
 111
 112     long oldStyle = 0; // Dummy
 113     wstyle |= ConvertToMSWStyle(oldStyle, m_windowStyle);
 114
 115     // Create the ListView control.
 116     m_hWnd = (WXHWND)CreateWindowEx(exStyle,
 117                                     WC_LISTVIEW,
 118                                     "",
 119                                     wstyle,
 120                                     x, y, width, height,
 121                                     (HWND) parent->GetHWND(),
 122                                     (HMENU)m_windowId,
 123                                     wxGetInstance(),
 124                                     NULL);
 125
 126     if ( !m_hWnd ) {
 127         wxLogError("Can't create list control window.");
 128
 129         return FALSE;
 130     }
 131
 132     // for comctl32.dll v 4.70+ we want to have this attribute because it's
 133     // prettier (and also because wxGTK does it like this)
 134 #ifdef ListView_SetExtendedListViewStyle
 135     if ( wstyle & LVS_REPORT )
 136     {
 137         ListView_SetExtendedListViewStyle((HWND)GetHWND(),
 138                                            LVS_EX_FULLROWSELECT);
 139     }
 140 #endif // ListView_SetExtendedListViewStyle
 141
 142     wxSystemSettings settings;
 143     SetBackgroundColour(settings.GetSystemColour(wxSYS_COLOUR_WINDOW));
 144     SetForegroundColour(parent->GetForegroundColour());
 145
 146     if (parent) parent->AddChild(this);
 147
 148     SubclassWin((WXHWND) m_hWnd);
 149
 150     return TRUE;
 151 }
 152
 153 wxListCtrl::~wxListCtrl()
 154 {
 155     if (m_textCtrl)
 156     {
 157         m_textCtrl->UnsubclassWin();
 158         m_textCtrl->SetHWND(0);
 159         delete m_textCtrl;
 160         m_textCtrl = NULL;
 161     }
 162 }
 163
 164 // Add or remove a single window style
 165 void wxListCtrl::SetSingleStyle(long style, bool add)
 166 {
 167     long flag = GetWindowStyleFlag();
 168
 169     // Get rid of conflicting styles
 170     if ( add )
 171     {
 172         if ( style & wxLC_MASK_TYPE)
 173             flag = flag & ~wxLC_MASK_TYPE ;
 174         if ( style & wxLC_MASK_ALIGN )
 175             flag = flag & ~wxLC_MASK_ALIGN ;
 176         if ( style & wxLC_MASK_SORT )
 177             flag = flag & ~wxLC_MASK_SORT ;
 178     }
 179
 180     if ( flag & style )
 181     {
 182         if ( !add )
 183             flag -= style;
 184     }
 185     else
 186     {
 187         if ( add )
 188         {
 189             flag |= style;
 190         }
 191     }
 192
 193     m_windowStyle = flag;
 194
 195     RecreateWindow();
 196 }
 197
 198 // Set the whole window style
 199 void wxListCtrl::SetWindowStyleFlag(long flag)
 200 {
 201     m_windowStyle = flag;
 202
 203     RecreateWindow();
 204 }
 205
 206 void wxListCtrl::RecreateWindow()
 207 {
 208     if ( GetHWND() )
 209     {
 210         long oldStyle = 0;
 211         long style = ConvertToMSWStyle(oldStyle, m_windowStyle);
 212         style |= m_baseStyle;
 213         //      ::SetWindowLong((HWND) GetHWND(), GWL_STYLE, style);
 214
 215         // The following recreation of the window appears to be necessary
 216         // because SetWindowLong doesn't seem to do it.
 217
 218         int x, y, width, height;
 219         GetPosition(&x, &y);
 220         GetSize(&width, &height);
 221
 222         UnsubclassWin();
 223         ::DestroyWindow((HWND) GetHWND());
 224
 225         // Experimental
 226         // Recreate the ListView control: unfortunately I can't
 227         // make it work by using SetWindowLong.
 228         bool want3D;
 229         WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D) ;
 230         HWND hWndListControl = CreateWindowEx(exStyle,
 231                 WC_LISTVIEW,
 232                 "",
 233                 style,
 234                 x, y, width, height,
 235                 (HWND) GetParent()->GetHWND(),
 236                 (HMENU)m_windowId,
 237                 wxGetInstance(),
 238                 NULL );
 239
 240         m_hWnd = (WXHWND) hWndListControl;
 241         SubclassWin((WXHWND) m_hWnd);
 242
 243 #ifdef ListView_SetExtendedListViewStyle
 244         if ( style & LVS_REPORT )
 245         {
 246             ListView_SetExtendedListViewStyle((HWND)GetHWND(),
 247                                               LVS_EX_FULLROWSELECT);
 248         }
 249 #endif // ListView_SetExtendedListViewStyle
 250
 251         if ( m_imageListNormal )
 252             SetImageList(m_imageListNormal, wxIMAGE_LIST_NORMAL);
 253         if ( m_imageListSmall )
 254             SetImageList(m_imageListSmall, wxIMAGE_LIST_SMALL);
 255         if ( m_imageListState )
 256             SetImageList(m_imageListState, wxIMAGE_LIST_STATE);
 257     }
 258 }
 259
 260 // Can be just a single style, or a bitlist
 261 long wxListCtrl::ConvertToMSWStyle(long& oldStyle, long style) const
 262 {
 263     long wstyle = 0;
 264     if ( style & wxLC_ICON )
 265     {
 266         if ( (oldStyle & LVS_TYPEMASK) == LVS_SMALLICON )
 267             oldStyle -= LVS_SMALLICON;
 268         if ( (oldStyle & LVS_TYPEMASK) == LVS_REPORT )
 269             oldStyle -= LVS_REPORT;
 270         if ( (oldStyle & LVS_TYPEMASK) == LVS_LIST )
 271             oldStyle -= LVS_LIST;
 272         wstyle |= LVS_ICON;
 273     }
 274
 275     if ( style & wxLC_SMALL_ICON )
 276     {
 277         if ( (oldStyle & LVS_TYPEMASK) == LVS_ICON )
 278             oldStyle -= LVS_ICON;
 279         if ( (oldStyle & LVS_TYPEMASK) == LVS_REPORT )
 280             oldStyle -= LVS_REPORT;
 281         if ( (oldStyle & LVS_TYPEMASK) == LVS_LIST )
 282             oldStyle -= LVS_LIST;
 283         wstyle |= LVS_SMALLICON;
 284     }
 285
 286     if ( style & wxLC_LIST )
 287     {
 288         if ( (oldStyle & LVS_TYPEMASK) == LVS_ICON )
 289             oldStyle -= LVS_ICON;
 290         if ( (oldStyle & LVS_TYPEMASK) == LVS_REPORT )
 291             oldStyle -= LVS_REPORT;
 292         if ( (oldStyle & LVS_TYPEMASK) == LVS_SMALLICON )
 293             oldStyle -= LVS_SMALLICON;
 294         wstyle |= LVS_LIST;
 295     }
 296
 297     if ( style & wxLC_REPORT )
 298     {
 299         if ( (oldStyle & LVS_TYPEMASK) == LVS_ICON )
 300             oldStyle -= LVS_ICON;
 301         if ( (oldStyle & LVS_TYPEMASK) == LVS_LIST )
 302             oldStyle -= LVS_LIST;
 303         if ( (oldStyle & LVS_TYPEMASK) == LVS_SMALLICON )
 304             oldStyle -= LVS_SMALLICON;
 305
 306         wstyle |= LVS_REPORT;
 307     }
 308
 309     if ( style & wxLC_ALIGN_LEFT )
 310     {
 311         if ( oldStyle & LVS_ALIGNTOP )
 312             oldStyle -= LVS_ALIGNTOP;
 313         wstyle |= LVS_ALIGNLEFT;
 314     }
 315
 316     if ( style & wxLC_ALIGN_TOP )
 317     {
 318         if ( oldStyle & LVS_ALIGNLEFT )
 319             oldStyle -= LVS_ALIGNLEFT;
 320         wstyle |= LVS_ALIGNTOP;
 321     }
 322
 323     if ( style & wxLC_AUTOARRANGE )
 324         wstyle |= LVS_AUTOARRANGE;
 325
 326     // Apparently, no such style (documentation wrong?)
 327     /*
 328        if ( style & wxLC_BUTTON )
 329        wstyle |= LVS_BUTTON;
 330      */
 331
 332     if ( style & wxLC_NO_SORT_HEADER )
 333         wstyle |= LVS_NOSORTHEADER;
 334
 335     if ( style & wxLC_NO_HEADER )
 336         wstyle |= LVS_NOCOLUMNHEADER;
 337
 338     if ( style & wxLC_EDIT_LABELS )
 339         wstyle |= LVS_EDITLABELS;
 340
 341     if ( style & wxLC_SINGLE_SEL )
 342         wstyle |= LVS_SINGLESEL;
 343
 344     if ( style & wxLC_SORT_ASCENDING )
 345     {
 346         if ( oldStyle & LVS_SORTDESCENDING )
 347             oldStyle -= LVS_SORTDESCENDING;
 348         wstyle |= LVS_SORTASCENDING;
 349     }
 350
 351     if ( style & wxLC_SORT_DESCENDING )
 352     {
 353         if ( oldStyle & LVS_SORTASCENDING )
 354             oldStyle -= LVS_SORTASCENDING;
 355         wstyle |= LVS_SORTDESCENDING;
 356     }
 357
 358     return wstyle;
 359 }
 360
 361 // Sets the background colour (GetBackgroundColour already implicit in
 362 // wxWindow class)
 363 void wxListCtrl::SetBackgroundColour(const wxColour& col)
 364 {
 365     wxWindow::SetBackgroundColour(col);
 366
 367     ListView_SetBkColor((HWND) GetHWND(), PALETTERGB(col.Red(), col.Green(), col.Blue()));
 368 }
 369
 370 // Gets information about this column
 371 bool wxListCtrl::GetColumn(int col, wxListItem& item) const
 372 {
 373     LV_COLUMN lvCol;
 374     lvCol.mask = 0;
 375     lvCol.fmt = 0;
 376     lvCol.pszText = NULL;
 377
 378     if ( item.m_mask & wxLIST_MASK_TEXT )
 379     {
 380         lvCol.mask |= LVCF_TEXT;
 381         lvCol.pszText = new char[513];
 382         lvCol.cchTextMax = 512;
 383     }
 384
 385     bool success = (ListView_GetColumn((HWND) GetHWND(), col, & lvCol) != 0);
 386
 387     //  item.m_subItem = lvCol.iSubItem;
 388     item.m_width = lvCol.cx;
 389
 390     if ( (item.m_mask & wxLIST_MASK_TEXT) && lvCol.pszText )
 391     {
 392         item.m_text = lvCol.pszText;
 393         delete[] lvCol.pszText;
 394     }
 395
 396     if ( item.m_mask & wxLIST_MASK_FORMAT )
 397     {
 398         if (lvCol.fmt == LVCFMT_LEFT)
 399             item.m_format = wxLIST_FORMAT_LEFT;
 400         else if (lvCol.fmt == LVCFMT_RIGHT)
 401             item.m_format = wxLIST_FORMAT_RIGHT;
 402         else if (lvCol.fmt == LVCFMT_CENTER)
 403             item.m_format = wxLIST_FORMAT_CENTRE;
 404     }
 405
 406     return success;
 407 }
 408
 409 // Sets information about this column
 410 bool wxListCtrl::SetColumn(int col, wxListItem& item)
 411 {
 412     LV_COLUMN lvCol;
 413     lvCol.mask = 0;
 414     lvCol.fmt = 0;
 415     lvCol.pszText = NULL;
 416
 417     if ( item.m_mask & wxLIST_MASK_TEXT )
 418     {
 419         lvCol.mask |= LVCF_TEXT;
 420         lvCol.pszText = WXSTRINGCAST item.m_text;
 421         lvCol.cchTextMax = 0; // Ignored
 422     }
 423     if ( item.m_mask & wxLIST_MASK_FORMAT )
 424     {
 425         lvCol.mask |= LVCF_FMT;
 426
 427         if ( item.m_format == wxLIST_FORMAT_LEFT )
 428             lvCol.fmt = LVCFMT_LEFT;
 429         if ( item.m_format == wxLIST_FORMAT_RIGHT )
 430             lvCol.fmt = LVCFMT_RIGHT;
 431         if ( item.m_format == wxLIST_FORMAT_CENTRE )
 432             lvCol.fmt = LVCFMT_CENTER;
 433     }
 434
 435     if ( item.m_mask & wxLIST_MASK_WIDTH )
 436     {
 437         lvCol.mask |= LVCF_WIDTH;
 438         lvCol.cx = item.m_width;
 439
 440         if ( lvCol.cx == wxLIST_AUTOSIZE)
 441             lvCol.cx = LVSCW_AUTOSIZE;
 442         else if ( lvCol.cx == wxLIST_AUTOSIZE_USEHEADER)
 443             lvCol.cx = LVSCW_AUTOSIZE_USEHEADER;
 444     }
 445     lvCol.mask |= LVCF_SUBITEM;
 446     lvCol.iSubItem = col;
 447     return (ListView_SetColumn((HWND) GetHWND(), col, & lvCol) != 0);
 448 }
 449
 450 // Gets the column width
 451 int wxListCtrl::GetColumnWidth(int col) const
 452 {
 453     return ListView_GetColumnWidth((HWND) GetHWND(), col);
 454 }
 455
 456 // Sets the column width
 457 bool wxListCtrl::SetColumnWidth(int col, int width)
 458 {
 459     int col2 = col;
 460     if ( m_windowStyle & wxLC_LIST )
 461         col2 = -1;
 462
 463     int width2 = width;
 464     if ( width2 == wxLIST_AUTOSIZE)
 465         width2 = LVSCW_AUTOSIZE;
 466     else if ( width2 == wxLIST_AUTOSIZE_USEHEADER)
 467         width2 = LVSCW_AUTOSIZE_USEHEADER;
 468
 469     return (ListView_SetColumnWidth((HWND) GetHWND(), col2, width2) != 0);
 470 }
 471
 472 // Gets the number of items that can fit vertically in the
 473 // visible area of the list control (list or report view)
 474 // or the total number of items in the list control (icon
 475 // or small icon view)
 476 int wxListCtrl::GetCountPerPage(void) const
 477 {
 478     return ListView_GetCountPerPage((HWND) GetHWND());
 479 }
 480
 481 // Gets the edit control for editing labels.
 482 wxTextCtrl* wxListCtrl::GetEditControl(void) const
 483 {
 484     return m_textCtrl;
 485 }
 486
 487 // Gets information about the item
 488 bool wxListCtrl::GetItem(wxListItem& info) const
 489 {
 490     LV_ITEM lvItem;
 491 #ifdef __GNUWIN32__
 492     memset(&lvItem, 0, sizeof(lvItem));
 493 #else
 494     ZeroMemory(&lvItem, sizeof(lvItem)); // must set all fields to 0
 495 #endif
 496
 497     lvItem.iItem = info.m_itemId;
 498
 499     if ( info.m_mask & wxLIST_MASK_TEXT )
 500     {
 501         lvItem.mask |= LVIF_TEXT;
 502         lvItem.pszText = new char[513];
 503         lvItem.cchTextMax = 512;
 504     }
 505     else
 506     {
 507         lvItem.pszText = NULL;
 508     }
 509
 510     if (info.m_mask & wxLIST_MASK_DATA)
 511         lvItem.mask |= LVIF_PARAM ;
 512
 513     if ( info.m_mask & wxLIST_MASK_STATE )
 514     {
 515         lvItem.mask |= LVIF_STATE;
 516         // the other bits are hardly interesting anyhow
 517         lvItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
 518     }
 519
 520     bool success = ListView_GetItem((HWND)GetHWND(), &lvItem) != 0;
 521     if ( !success )
 522     {
 523         wxLogError(_("Couldn't retrieve information about list control item %d."),
 524                 lvItem.iItem);
 525     }
 526     else
 527     {
 528         wxConvertFromMSWListItem(this, info, lvItem);
 529     }
 530
 531     if (lvItem.pszText)
 532         delete[] lvItem.pszText;
 533
 534     return success;
 535 }
 536
 537 // Sets information about the item
 538 bool wxListCtrl::SetItem(wxListItem& info)
 539 {
 540     LV_ITEM item;
 541     wxConvertToMSWListItem(this, info, item);
 542     item.cchTextMax = 0;
 543     return (ListView_SetItem((HWND) GetHWND(), &item) != 0);
 544 }
 545
 546 long wxListCtrl::SetItem(long index, int col, const wxString& label, int imageId)
 547 {
 548     wxListItem info;
 549     info.m_text = label;
 550     info.m_mask = wxLIST_MASK_TEXT;
 551     info.m_itemId = index;
 552     info.m_col = col;
 553     if ( imageId > -1 )
 554     {
 555         info.m_image = imageId;
 556         info.m_mask |= wxLIST_MASK_IMAGE;
 557     }
 558     return SetItem(info);
 559 }
 560
 561
 562 // Gets the item state
 563 int wxListCtrl::GetItemState(long item, long stateMask) const
 564 {
 565     wxListItem info;
 566
 567     info.m_mask = wxLIST_MASK_STATE ;
 568     info.m_stateMask = stateMask;
 569     info.m_itemId = item;
 570
 571     if (!GetItem(info))
 572         return 0;
 573
 574     return info.m_state;
 575 }
 576
 577 // Sets the item state
 578 bool wxListCtrl::SetItemState(long item, long state, long stateMask)
 579 {
 580     wxListItem info;
 581
 582     info.m_mask = wxLIST_MASK_STATE ;
 583     info.m_state = state;
 584     info.m_stateMask = stateMask;
 585     info.m_itemId = item;
 586
 587     return SetItem(info);
 588 }
 589
 590 // Sets the item image
 591 bool wxListCtrl::SetItemImage(long item, int image, int selImage)
 592 {
 593     wxListItem info;
 594
 595     info.m_mask = wxLIST_MASK_IMAGE ;
 596     info.m_image = image;
 597     info.m_itemId = item;
 598
 599     return SetItem(info);
 600 }
 601
 602 // Gets the item text
 603 wxString wxListCtrl::GetItemText(long item) const
 604 {
 605     wxListItem info;
 606
 607     info.m_mask = wxLIST_MASK_TEXT ;
 608     info.m_itemId = item;
 609
 610     if (!GetItem(info))
 611         return wxString("");
 612     return info.m_text;
 613 }
 614
 615 // Sets the item text
 616 void wxListCtrl::SetItemText(long item, const wxString& str)
 617 {
 618     wxListItem info;
 619
 620     info.m_mask = wxLIST_MASK_TEXT ;
 621     info.m_itemId = item;
 622     info.m_text = str;
 623
 624     SetItem(info);
 625 }
 626
 627 // Gets the item data
 628 long wxListCtrl::GetItemData(long item) const
 629 {
 630     wxListItem info;
 631
 632     info.m_mask = wxLIST_MASK_DATA ;
 633     info.m_itemId = item;
 634
 635     if (!GetItem(info))
 636         return 0;
 637     return info.m_data;
 638 }
 639
 640 // Sets the item data
 641 bool wxListCtrl::SetItemData(long item, long data)
 642 {
 643     wxListItem info;
 644
 645     info.m_mask = wxLIST_MASK_DATA ;
 646     info.m_itemId = item;
 647     info.m_data = data;
 648
 649     return SetItem(info);
 650 }
 651
 652 // Gets the item rectangle
 653 bool wxListCtrl::GetItemRect(long item, wxRect& rect, int code) const
 654 {
 655     RECT rect2;
 656
 657     int code2 = LVIR_BOUNDS;
 658     if ( code == wxLIST_RECT_BOUNDS )
 659         code2 = LVIR_BOUNDS;
 660     else if ( code == wxLIST_RECT_ICON )
 661         code2 = LVIR_ICON;
 662     else if ( code == wxLIST_RECT_LABEL )
 663         code2 = LVIR_LABEL;
 664
 665     bool success = (ListView_GetItemRect((HWND) GetHWND(), (int) item, &rect2, code2) != 0);
 666
 667     rect.x = rect2.left;
 668     rect.y = rect2.top;
 669     rect.width = rect2.right - rect2.left;
 670     rect.height = rect2.bottom - rect2.left;
 671     return success;
 672 }
 673
 674 // Gets the item position
 675 bool wxListCtrl::GetItemPosition(long item, wxPoint& pos) const
 676 {
 677     POINT pt;
 678
 679     bool success = (ListView_GetItemPosition((HWND) GetHWND(), (int) item, &pt) != 0);
 680
 681     pos.x = pt.x; pos.y = pt.y;
 682     return success;
 683 }
 684
 685 // Sets the item position.
 686 bool wxListCtrl::SetItemPosition(long item, const wxPoint& pos)
 687 {
 688     return (ListView_SetItemPosition((HWND) GetHWND(), (int) item, pos.x, pos.y) != 0);
 689 }
 690
 691 // Gets the number of items in the list control
 692 int wxListCtrl::GetItemCount(void) const
 693 {
 694     return ListView_GetItemCount((HWND) GetHWND());
 695 }
 696
 697 // Retrieves the spacing between icons in pixels.
 698 // If small is TRUE, gets the spacing for the small icon
 699 // view, otherwise the large icon view.
 700 int wxListCtrl::GetItemSpacing(bool isSmall) const
 701 {
 702     return ListView_GetItemSpacing((HWND) GetHWND(), (BOOL) isSmall);
 703 }
 704
 705 // Gets the number of selected items in the list control
 706 int wxListCtrl::GetSelectedItemCount(void) const
 707 {
 708     return ListView_GetSelectedCount((HWND) GetHWND());
 709 }
 710
 711 // Gets the text colour of the listview
 712 wxColour wxListCtrl::GetTextColour(void) const
 713 {
 714     COLORREF ref = ListView_GetTextColor((HWND) GetHWND());
 715     wxColour col(GetRValue(ref), GetGValue(ref), GetBValue(ref));
 716     return col;
 717 }
 718
 719 // Sets the text colour of the listview
 720 void wxListCtrl::SetTextColour(const wxColour& col)
 721 {
 722     ListView_SetTextColor((HWND) GetHWND(), PALETTERGB(col.Red(), col.Blue(), col.Green()));
 723 }
 724
 725 // Gets the index of the topmost visible item when in
 726 // list or report view
 727 long wxListCtrl::GetTopItem(void) const
 728 {
 729     return (long) ListView_GetTopIndex((HWND) GetHWND());
 730 }
 731
 732 // Searches for an item, starting from 'item'.
 733 // 'geometry' is one of
 734 // wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT.
 735 // 'state' is a state bit flag, one or more of
 736 // wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT.
 737 // item can be -1 to find the first item that matches the
 738 // specified flags.
 739 // Returns the item or -1 if unsuccessful.
 740 long wxListCtrl::GetNextItem(long item, int geom, int state) const
 741 {
 742     long flags = 0;
 743
 744     if ( geom == wxLIST_NEXT_ABOVE )
 745         flags |= LVNI_ABOVE;
 746     if ( geom == wxLIST_NEXT_ALL )
 747         flags |= LVNI_ALL;
 748     if ( geom == wxLIST_NEXT_BELOW )
 749         flags |= LVNI_BELOW;
 750     if ( geom == wxLIST_NEXT_LEFT )
 751         flags |= LVNI_TOLEFT;
 752     if ( geom == wxLIST_NEXT_RIGHT )
 753         flags |= LVNI_TORIGHT;
 754
 755     if ( state & wxLIST_STATE_CUT )
 756         flags |= LVNI_CUT;
 757     if ( state & wxLIST_STATE_DROPHILITED )
 758         flags |= LVNI_DROPHILITED;
 759     if ( state & wxLIST_STATE_FOCUSED )
 760         flags |= LVNI_FOCUSED;
 761     if ( state & wxLIST_STATE_SELECTED )
 762         flags |= LVNI_SELECTED;
 763
 764     return (long) ListView_GetNextItem((HWND) GetHWND(), item, flags);
 765 }
 766
 767
 768 wxImageList *wxListCtrl::GetImageList(int which) const
 769 {
 770     if ( which == wxIMAGE_LIST_NORMAL )
 771     {
 772         return m_imageListNormal;
 773     }
 774     else if ( which == wxIMAGE_LIST_SMALL )
 775     {
 776         return m_imageListSmall;
 777     }
 778     else if ( which == wxIMAGE_LIST_STATE )
 779     {
 780         return m_imageListState;
 781     }
 782     return NULL;
 783 }
 784
 785 void wxListCtrl::SetImageList(wxImageList *imageList, int which)
 786 {
 787     int flags = 0;
 788     if ( which == wxIMAGE_LIST_NORMAL )
 789     {
 790         flags = LVSIL_NORMAL;
 791         m_imageListNormal = imageList;
 792     }
 793     else if ( which == wxIMAGE_LIST_SMALL )
 794     {
 795         flags = LVSIL_SMALL;
 796         m_imageListSmall = imageList;
 797     }
 798     else if ( which == wxIMAGE_LIST_STATE )
 799     {
 800         flags = LVSIL_STATE;
 801         m_imageListState = imageList;
 802     }
 803     ListView_SetImageList((HWND) GetHWND(), (HIMAGELIST) imageList ? imageList->GetHIMAGELIST() : 0, flags);
 804 }
 805
 806 // Operations
 807 ////////////////////////////////////////////////////////////////////////////
 808
 809 // Arranges the items
 810 bool wxListCtrl::Arrange(int flag)
 811 {
 812     UINT code = 0;
 813     if ( flag == wxLIST_ALIGN_LEFT )
 814         code = LVA_ALIGNLEFT;
 815     else if ( flag == wxLIST_ALIGN_TOP )
 816         code = LVA_ALIGNTOP;
 817     else if ( flag == wxLIST_ALIGN_DEFAULT )
 818         code = LVA_DEFAULT;
 819     else if ( flag == wxLIST_ALIGN_SNAP_TO_GRID )
 820         code = LVA_SNAPTOGRID;
 821
 822     return (ListView_Arrange((HWND) GetHWND(), code) != 0);
 823 }
 824
 825 // Deletes an item
 826 bool wxListCtrl::DeleteItem(long item)
 827 {
 828     return (ListView_DeleteItem((HWND) GetHWND(), (int) item) != 0);
 829 }
 830
 831 // Deletes all items
 832 bool wxListCtrl::DeleteAllItems()
 833 {
 834     return (ListView_DeleteAllItems((HWND) GetHWND()) != 0);
 835 }
 836
 837 // Deletes all items
 838 bool wxListCtrl::DeleteAllColumns()
 839 {
 840     int i;
 841     for ( i = 0; i < m_colCount; i++)
 842     {
 843         if (ListView_DeleteColumn((HWND) GetHWND(), 0) != 0)
 844             m_colCount --;
 845     }
 846     return (m_colCount == 0);
 847 }
 848
 849 // Deletes a column
 850 bool wxListCtrl::DeleteColumn(int col)
 851 {
 852     bool success = (ListView_DeleteColumn((HWND) GetHWND(), col) != 0);
 853
 854     if ( success && (m_colCount > 0) )
 855         m_colCount --;
 856     return success;
 857 }
 858
 859 // Clears items, and columns if there are any.
 860 void wxListCtrl::ClearAll()
 861 {
 862     DeleteAllItems();
 863     if ( m_colCount > 0 )
 864         DeleteAllColumns();
 865 }
 866
 867 wxTextCtrl* wxListCtrl::EditLabel(long item, wxClassInfo* textControlClass)
 868 {
 869     wxASSERT( (textControlClass->IsKindOf(CLASSINFO(wxTextCtrl))) );
 870
 871     HWND hWnd = (HWND) ListView_EditLabel((HWND) GetHWND(), item);
 872
 873     if (m_textCtrl)
 874     {
 875         m_textCtrl->UnsubclassWin();
 876         m_textCtrl->SetHWND(0);
 877         delete m_textCtrl;
 878         m_textCtrl = NULL;
 879     }
 880
 881     m_textCtrl = (wxTextCtrl*) textControlClass->CreateObject();
 882     m_textCtrl->SetHWND((WXHWND) hWnd);
 883     m_textCtrl->SubclassWin((WXHWND) hWnd);
 884
 885     return m_textCtrl;
 886 }
 887
 888 // End label editing, optionally cancelling the edit
 889 bool wxListCtrl::EndEditLabel(bool cancel)
 890 {
 891     wxFAIL;
 892
 893     /* I don't know how to implement this: there's no such macro as ListView_EndEditLabelNow.
 894      * ???
 895      bool success = (ListView_EndEditLabelNow((HWND) GetHWND(), cancel) != 0);
 896
 897      if (m_textCtrl)
 898      {
 899      m_textCtrl->UnsubclassWin();
 900      m_textCtrl->SetHWND(0);
 901      delete m_textCtrl;
 902      m_textCtrl = NULL;
 903      }
 904      return success;
 905      */
 906     return FALSE;
 907 }
 908
 909
 910 // Ensures this item is visible
 911 bool wxListCtrl::EnsureVisible(long item)
 912 {
 913     return (ListView_EnsureVisible((HWND) GetHWND(), (int) item, FALSE) != 0);
 914 }
 915
 916 // Find an item whose label matches this string, starting from the item after 'start'
 917 // or the beginning if 'start' is -1.
 918 long wxListCtrl::FindItem(long start, const wxString& str, bool partial)
 919 {
 920     LV_FINDINFO findInfo;
 921
 922     findInfo.flags = LVFI_STRING;
 923     if ( partial )
 924         findInfo.flags |= LVFI_STRING;
 925     findInfo.psz = WXSTRINGCAST str;
 926
 927     return ListView_FindItem((HWND) GetHWND(), (int) start, & findInfo);
 928 }
 929
 930 // Find an item whose data matches this data, starting from the item after 'start'
 931 // or the beginning if 'start' is -1.
 932 long wxListCtrl::FindItem(long start, long data)
 933 {
 934     LV_FINDINFO findInfo;
 935
 936     findInfo.flags = LVFI_PARAM;
 937     findInfo.lParam = data;
 938
 939     return ListView_FindItem((HWND) GetHWND(), (int) start, & findInfo);
 940 }
 941
 942 // Find an item nearest this position in the specified direction, starting from
 943 // the item after 'start' or the beginning if 'start' is -1.
 944 long wxListCtrl::FindItem(long start, const wxPoint& pt, int direction)
 945 {
 946     LV_FINDINFO findInfo;
 947
 948     findInfo.flags = LVFI_NEARESTXY;
 949     findInfo.pt.x = pt.x;
 950     findInfo.pt.y = pt.y;
 951     findInfo.vkDirection = VK_RIGHT;
 952
 953     if ( direction == wxLIST_FIND_UP )
 954         findInfo.vkDirection = VK_UP;
 955     else if ( direction == wxLIST_FIND_DOWN )
 956         findInfo.vkDirection = VK_DOWN;
 957     else if ( direction == wxLIST_FIND_LEFT )
 958         findInfo.vkDirection = VK_LEFT;
 959     else if ( direction == wxLIST_FIND_RIGHT )
 960         findInfo.vkDirection = VK_RIGHT;
 961
 962     return ListView_FindItem((HWND) GetHWND(), (int) start, & findInfo);
 963 }
 964
 965 // Determines which item (if any) is at the specified point,
 966 // giving details in 'flags' (see wxLIST_HITTEST_... flags above)
 967 long wxListCtrl::HitTest(const wxPoint& point, int& flags)
 968 {
 969     LV_HITTESTINFO hitTestInfo;
 970     hitTestInfo.pt.x = (int) point.x;
 971     hitTestInfo.pt.y = (int) point.y;
 972
 973     ListView_HitTest((HWND) GetHWND(), & hitTestInfo);
 974
 975     flags = 0;
 976     if ( hitTestInfo.flags & LVHT_ABOVE )
 977         flags |= wxLIST_HITTEST_ABOVE;
 978     if ( hitTestInfo.flags & LVHT_BELOW )
 979         flags |= wxLIST_HITTEST_BELOW;
 980     if ( hitTestInfo.flags & LVHT_NOWHERE )
 981         flags |= wxLIST_HITTEST_NOWHERE;
 982     if ( hitTestInfo.flags & LVHT_ONITEMICON )
 983         flags |= wxLIST_HITTEST_ONITEMICON;
 984     if ( hitTestInfo.flags & LVHT_ONITEMLABEL )
 985         flags |= wxLIST_HITTEST_ONITEMLABEL;
 986     if ( hitTestInfo.flags & LVHT_ONITEMSTATEICON )
 987         flags |= wxLIST_HITTEST_ONITEMSTATEICON;
 988     if ( hitTestInfo.flags & LVHT_TOLEFT )
 989         flags |= wxLIST_HITTEST_TOLEFT;
 990     if ( hitTestInfo.flags & LVHT_TORIGHT )
 991         flags |= wxLIST_HITTEST_TORIGHT;
 992
 993     return (long) hitTestInfo.iItem ;
 994 }
 995
 996 // Inserts an item, returning the index of the new item if successful,
 997 // -1 otherwise.
 998 long wxListCtrl::InsertItem(wxListItem& info)
 999 {
1000     LV_ITEM item;
1001     wxConvertToMSWListItem(this, info, item);
1002
1003     return (long) ListView_InsertItem((HWND) GetHWND(), & item);
1004 }
1005
1006 long wxListCtrl::InsertItem(long index, const wxString& label)
1007 {
1008     wxListItem info;
1009     info.m_text = label;
1010     info.m_mask = wxLIST_MASK_TEXT;
1011     info.m_itemId = index;
1012     return InsertItem(info);
1013 }
1014
1015 // Inserts an image item
1016 long wxListCtrl::InsertItem(long index, int imageIndex)
1017 {
1018     wxListItem info;
1019     info.m_image = imageIndex;
1020     info.m_mask = wxLIST_MASK_IMAGE;
1021     info.m_itemId = index;
1022     return InsertItem(info);
1023 }
1024
1025 // Inserts an image/string item
1026 long wxListCtrl::InsertItem(long index, const wxString& label, int imageIndex)
1027 {
1028     wxListItem info;
1029     info.m_image = imageIndex;
1030     info.m_text = label;
1031     info.m_mask = wxLIST_MASK_IMAGE | wxLIST_MASK_TEXT;
1032     info.m_itemId = index;
1033     return InsertItem(info);
1034 }
1035
1036 // For list view mode (only), inserts a column.
1037 long wxListCtrl::InsertColumn(long col, wxListItem& item)
1038 {
1039     LV_COLUMN lvCol;
1040     lvCol.mask = 0;
1041     lvCol.fmt = 0;
1042     lvCol.pszText = NULL;
1043
1044     if ( item.m_mask & wxLIST_MASK_TEXT )
1045     {
1046         lvCol.mask |= LVCF_TEXT;
1047         lvCol.pszText = WXSTRINGCAST item.m_text;
1048         lvCol.cchTextMax = 0; // Ignored
1049     }
1050     if ( item.m_mask & wxLIST_MASK_FORMAT )
1051     {
1052         lvCol.mask |= LVCF_FMT;
1053
1054         if ( item.m_format == wxLIST_FORMAT_LEFT )
1055             lvCol.fmt = LVCFMT_LEFT;
1056         if ( item.m_format == wxLIST_FORMAT_RIGHT )
1057             lvCol.fmt = LVCFMT_RIGHT;
1058         if ( item.m_format == wxLIST_FORMAT_CENTRE )
1059             lvCol.fmt = LVCFMT_CENTER;
1060     }
1061
1062     lvCol.mask |= LVCF_WIDTH;
1063     if ( item.m_mask & wxLIST_MASK_WIDTH )
1064     {
1065         if ( item.m_width == wxLIST_AUTOSIZE)
1066             lvCol.cx = LVSCW_AUTOSIZE;
1067         else if ( item.m_width == wxLIST_AUTOSIZE_USEHEADER)
1068             lvCol.cx = LVSCW_AUTOSIZE_USEHEADER;
1069         else
1070             lvCol.cx = item.m_width;
1071     }
1072     else
1073     {
1074         // always give some width to the new column: this one is compatible
1075         // with wxGTK
1076         lvCol.cx = 80;
1077     }
1078
1079     lvCol.mask |= LVCF_SUBITEM;
1080     lvCol.iSubItem = col;
1081
1082     bool success = ListView_InsertColumn((HWND) GetHWND(), col, & lvCol) != -1;
1083     if ( success )
1084     {
1085         m_colCount++;
1086     }
1087     else
1088     {
1089         wxLogDebug("Failed to insert the column '%s' into listview!",
1090                    lvCol.pszText);
1091     }
1092
1093     return success;
1094 }
1095
1096 long wxListCtrl::InsertColumn(long col, const wxString& heading, int format,
1097         int width)
1098 {
1099     wxListItem item;
1100     item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT;
1101     item.m_text = heading;
1102     if ( width > -1 )
1103     {
1104         item.m_mask |= wxLIST_MASK_WIDTH;
1105         item.m_width = width;
1106     }
1107     item.m_format = format;
1108
1109     return InsertColumn(col, item);
1110 }
1111
1112 // Scrolls the list control. If in icon, small icon or report view mode,
1113 // x specifies the number of pixels to scroll. If in list view mode, x
1114 // specifies the number of columns to scroll.
1115 // If in icon, small icon or list view mode, y specifies the number of pixels
1116 // to scroll. If in report view mode, y specifies the number of lines to scroll.
1117 bool wxListCtrl::ScrollList(int dx, int dy)
1118 {
1119     return (ListView_Scroll((HWND) GetHWND(), dx, dy) != 0);
1120 }
1121
1122 // Sort items.
1123
1124 // fn is a function which takes 3 long arguments: item1, item2, data.
1125 // item1 is the long data associated with a first item (NOT the index).
1126 // item2 is the long data associated with a second item (NOT the index).
1127 // data is the same value as passed to SortItems.
1128 // The return value is a negative number if the first item should precede the second
1129 // item, a positive number of the second item should precede the first,
1130 // or zero if the two items are equivalent.
1131
1132 // data is arbitrary data to be passed to the sort function.
1133 bool wxListCtrl::SortItems(wxListCtrlCompare fn, long data)
1134 {
1135     return (ListView_SortItems((HWND) GetHWND(), (PFNLVCOMPARE) fn, data) != 0);
1136 }
1137
1138 bool wxListCtrl::MSWCommand(WXUINT cmd, WXWORD id)
1139 {
1140     if (cmd == EN_UPDATE)
1141     {
1142         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
1143         event.SetEventObject( this );
1144         ProcessCommand(event);
1145         return TRUE;
1146     }
1147     else if (cmd == EN_KILLFOCUS)
1148     {
1149         wxCommandEvent event(wxEVT_KILL_FOCUS, id);
1150         event.SetEventObject( this );
1151         ProcessCommand(event);
1152         return TRUE;
1153     }
1154     else return FALSE;
1155 }
1156
1157 bool wxListCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam, WXLPARAM *result)
1158 {
1159     wxListEvent event(wxEVT_NULL, m_windowId);
1160     wxEventType eventType = wxEVT_NULL;
1161     NMHDR *hdr1 = (NMHDR *) lParam;
1162     switch ( hdr1->code )
1163     {
1164         case LVN_BEGINRDRAG:
1165             eventType = wxEVT_COMMAND_LIST_BEGIN_RDRAG;
1166             // fall through
1167
1168         case LVN_BEGINDRAG:
1169             if ( eventType == wxEVT_NULL )
1170             {
1171                 eventType = wxEVT_COMMAND_LIST_BEGIN_DRAG;
1172             }
1173
1174             {
1175                 NM_LISTVIEW *hdr = (NM_LISTVIEW *)lParam;
1176                 event.m_itemIndex = hdr->iItem;
1177                 event.m_pointDrag.x = hdr->ptAction.x;
1178                 event.m_pointDrag.y = hdr->ptAction.y;
1179             }
1180             break;
1181
1182         case LVN_BEGINLABELEDIT:
1183             {
1184                 eventType = wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT;
1185                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1186                 wxConvertFromMSWListItem(this, event.m_item, info->item, (HWND) GetHWND());
1187                 break;
1188             }
1189
1190         case LVN_COLUMNCLICK:
1191             {
1192                 eventType = wxEVT_COMMAND_LIST_COL_CLICK;
1193                 NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam;
1194                 event.m_itemIndex = -1;
1195                 event.m_col = hdr->iSubItem;
1196                 break;
1197             }
1198         case LVN_DELETEALLITEMS:
1199             {
1200                 eventType = wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS;
1201                 //      NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam;
1202                 event.m_itemIndex = -1;
1203                 break;
1204             }
1205         case LVN_DELETEITEM:
1206             {
1207                 eventType = wxEVT_COMMAND_LIST_DELETE_ITEM;
1208                 NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam;
1209                 event.m_itemIndex = hdr->iItem;
1210                 break;
1211             }
1212         case LVN_ENDLABELEDIT:
1213             {
1214                 eventType = wxEVT_COMMAND_LIST_END_LABEL_EDIT;
1215                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1216                 wxConvertFromMSWListItem(this, event.m_item, info->item, (HWND) GetHWND());
1217                 if ( info->item.pszText == NULL || info->item.iItem == -1 )
1218                     event.m_cancelled = TRUE;
1219                 break;
1220             }
1221         case LVN_GETDISPINFO:
1222             {
1223                 //      return FALSE;
1224                 // TODO: some text buffering here, I think
1225                 // TODO: API for getting Windows to retrieve values
1226                 // on demand.
1227                 eventType = wxEVT_COMMAND_LIST_GET_INFO;
1228                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1229                 wxConvertFromMSWListItem(this, event.m_item, info->item, (HWND) GetHWND());
1230                 break;
1231             }
1232         case LVN_INSERTITEM:
1233             {
1234                 eventType = wxEVT_COMMAND_LIST_INSERT_ITEM;
1235                 NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam;
1236                 event.m_itemIndex = hdr->iItem;
1237                 break;
1238             }
1239         case LVN_ITEMCHANGED:
1240             {
1241                 // This needs to be sent to wxListCtrl as a rather more
1242                 // concrete event. For now, just detect a selection
1243                 // or deselection.
1244                 NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam;
1245                 if ( (hdr->uNewState & LVIS_SELECTED) && !(hdr->uOldState & LVIS_SELECTED) )
1246                 {
1247                     eventType = wxEVT_COMMAND_LIST_ITEM_SELECTED;
1248                     event.m_itemIndex = hdr->iItem;
1249                 }
1250                 else if ( !(hdr->uNewState & LVIS_SELECTED) && (hdr->uOldState & LVIS_SELECTED) )
1251                 {
1252                     eventType = wxEVT_COMMAND_LIST_ITEM_DESELECTED;
1253                     event.m_itemIndex = hdr->iItem;
1254                 }
1255                 else
1256                     return FALSE;
1257                 break;
1258             }
1259         case LVN_KEYDOWN:
1260             {
1261                 eventType = wxEVT_COMMAND_LIST_KEY_DOWN;
1262                 LV_KEYDOWN *info = (LV_KEYDOWN *)lParam;
1263                 event.m_code = wxCharCodeMSWToWX(info->wVKey);
1264                 break;
1265             }
1266         case LVN_SETDISPINFO:
1267             {
1268                 eventType = wxEVT_COMMAND_LIST_SET_INFO;
1269                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1270                 wxConvertFromMSWListItem(this, event.m_item, info->item, (HWND) GetHWND());
1271                 break;
1272             }
1273
1274         default :
1275             return wxControl::MSWNotify(wParam, lParam, result);
1276     }
1277
1278     event.SetEventObject( this );
1279     event.SetEventType(eventType);
1280
1281     if ( !GetEventHandler()->ProcessEvent(event) )
1282         return FALSE;
1283
1284     if (hdr1->code == LVN_GETDISPINFO)
1285     {
1286         LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1287         if ( info->item.mask & LVIF_TEXT )
1288         {
1289             if ( !event.m_item.m_text.IsNull() )
1290             {
1291                 info->item.pszText = AddPool(event.m_item.m_text);
1292                 info->item.cchTextMax = strlen(info->item.pszText) + 1;
1293             }
1294         }
1295         //    wxConvertToMSWListItem(this, event.m_item, info->item);
1296     }
1297
1298     *result = !event.IsAllowed();
1299
1300     return TRUE;
1301 }
1302
1303 char *wxListCtrl::AddPool(const wxString& str)
1304 {
1305     // Remove the first element if 3 strings exist
1306     if ( m_stringPool.Number() == 3 )
1307     {
1308         wxNode *node = m_stringPool.First();
1309         delete[] (char *)node->Data();
1310         delete node;
1311     }
1312     wxNode *node = m_stringPool.Add((char *) (const char *)str);
1313     return (char *)node->Data();
1314 }
1315
1316 // List item structure
1317 wxListItem::wxListItem()
1318 {
1319     m_mask = 0;
1320     m_itemId = 0;
1321     m_col = 0;
1322     m_state = 0;
1323     m_stateMask = 0;
1324     m_image = 0;
1325     m_data = 0;
1326
1327     m_format = wxLIST_FORMAT_CENTRE;
1328     m_width = 0;
1329 }
1330
1331 static void wxConvertFromMSWListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& lvItem, HWND getFullInfo)
1332 {
1333     info.m_data = lvItem.lParam;
1334     info.m_mask = 0;
1335     info.m_state = 0;
1336     info.m_stateMask = 0;
1337     info.m_itemId = lvItem.iItem;
1338
1339     long oldMask = lvItem.mask;
1340
1341     bool needText = FALSE;
1342     if (getFullInfo != 0)
1343     {
1344         if ( lvItem.mask & LVIF_TEXT )
1345             needText = FALSE;
1346         else
1347             needText = TRUE;
1348
1349         if ( needText )
1350         {
1351             lvItem.pszText = new char[513];
1352             lvItem.cchTextMax = 512;
1353         }
1354         //    lvItem.mask |= TVIF_HANDLE | TVIF_STATE | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN | TVIF_PARAM ;
1355         lvItem.mask |= LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM ;
1356         ::SendMessage(getFullInfo, LVM_GETITEM, 0, (LPARAM)& lvItem) ;
1357     }
1358
1359     if ( lvItem.mask & LVIF_STATE )
1360     {
1361         info.m_mask |= wxLIST_MASK_STATE;
1362
1363         if ( lvItem.stateMask & LVIS_CUT)
1364         {
1365             info.m_stateMask |= wxLIST_STATE_CUT ;
1366             if ( lvItem.state & LVIS_CUT )
1367                 info.m_state |= wxLIST_STATE_CUT ;
1368         }
1369         if ( lvItem.stateMask & LVIS_DROPHILITED)
1370         {
1371             info.m_stateMask |= wxLIST_STATE_DROPHILITED ;
1372             if ( lvItem.state & LVIS_DROPHILITED )
1373                 info.m_state |= wxLIST_STATE_DROPHILITED ;
1374         }
1375         if ( lvItem.stateMask & LVIS_FOCUSED)
1376         {
1377             info.m_stateMask |= wxLIST_STATE_FOCUSED ;
1378             if ( lvItem.state & LVIS_FOCUSED )
1379                 info.m_state |= wxLIST_STATE_FOCUSED ;
1380         }
1381         if ( lvItem.stateMask & LVIS_SELECTED)
1382         {
1383             info.m_stateMask |= wxLIST_STATE_SELECTED ;
1384             if ( lvItem.state & LVIS_SELECTED )
1385                 info.m_state |= wxLIST_STATE_SELECTED ;
1386         }
1387     }
1388
1389     if ( lvItem.mask & LVIF_TEXT )
1390     {
1391         info.m_mask |= wxLIST_MASK_TEXT;
1392         info.m_text = lvItem.pszText;
1393     }
1394     if ( lvItem.mask & LVIF_IMAGE )
1395     {
1396         info.m_mask |= wxLIST_MASK_IMAGE;
1397         info.m_image = lvItem.iImage;
1398     }
1399     if ( lvItem.mask & LVIF_PARAM )
1400         info.m_mask |= wxLIST_MASK_DATA;
1401     if ( lvItem.mask & LVIF_DI_SETITEM )
1402         info.m_mask |= wxLIST_SET_ITEM;
1403     info.m_col = lvItem.iSubItem;
1404
1405     if (needText)
1406     {
1407         if (lvItem.pszText)
1408             delete[] lvItem.pszText;
1409     }
1410     lvItem.mask = oldMask ;
1411 }
1412
1413 static void wxConvertToMSWListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& lvItem)
1414 {
1415     lvItem.iItem = (int) info.m_itemId ;
1416
1417     lvItem.iImage = info.m_image ;
1418     lvItem.lParam = info.m_data;
1419     lvItem.stateMask = 0;
1420     lvItem.state = 0;
1421     lvItem.mask = 0;
1422     lvItem.iSubItem = info.m_col;
1423
1424     if (info.m_mask & wxLIST_MASK_STATE)
1425     {
1426         lvItem.mask |= LVIF_STATE ;
1427         if (info.m_stateMask & wxLIST_STATE_CUT)
1428         {
1429             lvItem.stateMask |= LVIS_CUT ;
1430             if (info.m_state & wxLIST_STATE_CUT)
1431                 lvItem.state |= LVIS_CUT;
1432         }
1433         if (info.m_stateMask & wxLIST_STATE_DROPHILITED)
1434         {
1435             lvItem.stateMask |= LVIS_DROPHILITED;
1436             if (info.m_state & wxLIST_STATE_DROPHILITED)
1437                 lvItem.state |= LVIS_DROPHILITED;
1438         }
1439         if (info.m_stateMask & wxLIST_STATE_FOCUSED)
1440         {
1441             lvItem.stateMask |= LVIS_FOCUSED;
1442             if (info.m_state & wxLIST_STATE_FOCUSED)
1443                 lvItem.state |= LVIS_FOCUSED;
1444         }
1445         if (info.m_stateMask & wxLIST_STATE_SELECTED)
1446         {
1447             lvItem.stateMask |= LVIS_SELECTED;
1448             if (info.m_state & wxLIST_STATE_SELECTED)
1449                 lvItem.state |= LVIS_SELECTED;
1450         }
1451     }
1452
1453     if (info.m_mask & wxLIST_MASK_TEXT)
1454     {
1455         lvItem.mask |= LVIF_TEXT ;
1456         if ( ctrl->GetWindowStyleFlag() & wxLC_USER_TEXT )
1457         {
1458             lvItem.pszText = LPSTR_TEXTCALLBACK;
1459         }
1460         else
1461         {
1462             lvItem.pszText = (char *) (const char *)info.m_text ;
1463             if ( lvItem.pszText )
1464                 lvItem.cchTextMax = info.m_text.Length();
1465             else
1466                 lvItem.cchTextMax = 0;
1467         }
1468     }
1469     if (info.m_mask & wxLIST_MASK_IMAGE)
1470         lvItem.mask |= LVIF_IMAGE ;
1471     if (info.m_mask & wxLIST_MASK_DATA)
1472         lvItem.mask |= LVIF_PARAM ;
1473 }
1474
1475 // List event
1476 IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxNotifyEvent)
1477
1478 wxListEvent::wxListEvent(wxEventType commandType, int id)
1479 : wxNotifyEvent(commandType, id)
1480 {
1481     m_code = 0;
1482     m_itemIndex = 0;
1483     m_col = 0;
1484     m_cancelled = FALSE;
1485 }
1486
1487 #endif
1488