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 bool wxListCtrl::SetBackgroundColour(const wxColour& col)
 364 {
 365     if ( !wxWindow::SetBackgroundColour(col) )
 366         return FALSE;
 367
 368     ListView_SetBkColor((HWND) GetHWND(), PALETTERGB(col.Red(), col.Green(), col.Blue()));
 369
 370     return TRUE;
 371 }
 372
 373 // Gets information about this column
 374 bool wxListCtrl::GetColumn(int col, wxListItem& item) const
 375 {
 376     LV_COLUMN lvCol;
 377     lvCol.mask = 0;
 378     lvCol.fmt = 0;
 379     lvCol.pszText = NULL;
 380
 381     if ( item.m_mask & wxLIST_MASK_TEXT )
 382     {
 383         lvCol.mask |= LVCF_TEXT;
 384         lvCol.pszText = new char[513];
 385         lvCol.cchTextMax = 512;
 386     }
 387
 388     bool success = (ListView_GetColumn((HWND) GetHWND(), col, & lvCol) != 0);
 389
 390     //  item.m_subItem = lvCol.iSubItem;
 391     item.m_width = lvCol.cx;
 392
 393     if ( (item.m_mask & wxLIST_MASK_TEXT) && lvCol.pszText )
 394     {
 395         item.m_text = lvCol.pszText;
 396         delete[] lvCol.pszText;
 397     }
 398
 399     if ( item.m_mask & wxLIST_MASK_FORMAT )
 400     {
 401         if (lvCol.fmt == LVCFMT_LEFT)
 402             item.m_format = wxLIST_FORMAT_LEFT;
 403         else if (lvCol.fmt == LVCFMT_RIGHT)
 404             item.m_format = wxLIST_FORMAT_RIGHT;
 405         else if (lvCol.fmt == LVCFMT_CENTER)
 406             item.m_format = wxLIST_FORMAT_CENTRE;
 407     }
 408
 409     return success;
 410 }
 411
 412 // Sets information about this column
 413 bool wxListCtrl::SetColumn(int col, wxListItem& item)
 414 {
 415     LV_COLUMN lvCol;
 416     lvCol.mask = 0;
 417     lvCol.fmt = 0;
 418     lvCol.pszText = NULL;
 419
 420     if ( item.m_mask & wxLIST_MASK_TEXT )
 421     {
 422         lvCol.mask |= LVCF_TEXT;
 423         lvCol.pszText = WXSTRINGCAST item.m_text;
 424         lvCol.cchTextMax = 0; // Ignored
 425     }
 426     if ( item.m_mask & wxLIST_MASK_FORMAT )
 427     {
 428         lvCol.mask |= LVCF_FMT;
 429
 430         if ( item.m_format == wxLIST_FORMAT_LEFT )
 431             lvCol.fmt = LVCFMT_LEFT;
 432         if ( item.m_format == wxLIST_FORMAT_RIGHT )
 433             lvCol.fmt = LVCFMT_RIGHT;
 434         if ( item.m_format == wxLIST_FORMAT_CENTRE )
 435             lvCol.fmt = LVCFMT_CENTER;
 436     }
 437
 438     if ( item.m_mask & wxLIST_MASK_WIDTH )
 439     {
 440         lvCol.mask |= LVCF_WIDTH;
 441         lvCol.cx = item.m_width;
 442
 443         if ( lvCol.cx == wxLIST_AUTOSIZE)
 444             lvCol.cx = LVSCW_AUTOSIZE;
 445         else if ( lvCol.cx == wxLIST_AUTOSIZE_USEHEADER)
 446             lvCol.cx = LVSCW_AUTOSIZE_USEHEADER;
 447     }
 448     lvCol.mask |= LVCF_SUBITEM;
 449     lvCol.iSubItem = col;
 450     return (ListView_SetColumn((HWND) GetHWND(), col, & lvCol) != 0);
 451 }
 452
 453 // Gets the column width
 454 int wxListCtrl::GetColumnWidth(int col) const
 455 {
 456     return ListView_GetColumnWidth((HWND) GetHWND(), col);
 457 }
 458
 459 // Sets the column width
 460 bool wxListCtrl::SetColumnWidth(int col, int width)
 461 {
 462     int col2 = col;
 463     if ( m_windowStyle & wxLC_LIST )
 464         col2 = -1;
 465
 466     int width2 = width;
 467     if ( width2 == wxLIST_AUTOSIZE)
 468         width2 = LVSCW_AUTOSIZE;
 469     else if ( width2 == wxLIST_AUTOSIZE_USEHEADER)
 470         width2 = LVSCW_AUTOSIZE_USEHEADER;
 471
 472     return (ListView_SetColumnWidth((HWND) GetHWND(), col2, width2) != 0);
 473 }
 474
 475 // Gets the number of items that can fit vertically in the
 476 // visible area of the list control (list or report view)
 477 // or the total number of items in the list control (icon
 478 // or small icon view)
 479 int wxListCtrl::GetCountPerPage(void) const
 480 {
 481     return ListView_GetCountPerPage((HWND) GetHWND());
 482 }
 483
 484 // Gets the edit control for editing labels.
 485 wxTextCtrl* wxListCtrl::GetEditControl(void) const
 486 {
 487     return m_textCtrl;
 488 }
 489
 490 // Gets information about the item
 491 bool wxListCtrl::GetItem(wxListItem& info) const
 492 {
 493     LV_ITEM lvItem;
 494 #ifdef __GNUWIN32__
 495     memset(&lvItem, 0, sizeof(lvItem));
 496 #else
 497     ZeroMemory(&lvItem, sizeof(lvItem)); // must set all fields to 0
 498 #endif
 499
 500     lvItem.iItem = info.m_itemId;
 501
 502     if ( info.m_mask & wxLIST_MASK_TEXT )
 503     {
 504         lvItem.mask |= LVIF_TEXT;
 505         lvItem.pszText = new char[513];
 506         lvItem.cchTextMax = 512;
 507     }
 508     else
 509     {
 510         lvItem.pszText = NULL;
 511     }
 512
 513     if (info.m_mask & wxLIST_MASK_DATA)
 514         lvItem.mask |= LVIF_PARAM ;
 515
 516     if ( info.m_mask & wxLIST_MASK_STATE )
 517     {
 518         lvItem.mask |= LVIF_STATE;
 519         // the other bits are hardly interesting anyhow
 520         lvItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
 521     }
 522
 523     bool success = ListView_GetItem((HWND)GetHWND(), &lvItem) != 0;
 524     if ( !success )
 525     {
 526         wxLogError(_("Couldn't retrieve information about list control item %d."),
 527                 lvItem.iItem);
 528     }
 529     else
 530     {
 531         wxConvertFromMSWListItem(this, info, lvItem);
 532     }
 533
 534     if (lvItem.pszText)
 535         delete[] lvItem.pszText;
 536
 537     return success;
 538 }
 539
 540 // Sets information about the item
 541 bool wxListCtrl::SetItem(wxListItem& info)
 542 {
 543     LV_ITEM item;
 544     wxConvertToMSWListItem(this, info, item);
 545     item.cchTextMax = 0;
 546     return (ListView_SetItem((HWND) GetHWND(), &item) != 0);
 547 }
 548
 549 long wxListCtrl::SetItem(long index, int col, const wxString& label, int imageId)
 550 {
 551     wxListItem info;
 552     info.m_text = label;
 553     info.m_mask = wxLIST_MASK_TEXT;
 554     info.m_itemId = index;
 555     info.m_col = col;
 556     if ( imageId > -1 )
 557     {
 558         info.m_image = imageId;
 559         info.m_mask |= wxLIST_MASK_IMAGE;
 560     }
 561     return SetItem(info);
 562 }
 563
 564
 565 // Gets the item state
 566 int wxListCtrl::GetItemState(long item, long stateMask) const
 567 {
 568     wxListItem info;
 569
 570     info.m_mask = wxLIST_MASK_STATE ;
 571     info.m_stateMask = stateMask;
 572     info.m_itemId = item;
 573
 574     if (!GetItem(info))
 575         return 0;
 576
 577     return info.m_state;
 578 }
 579
 580 // Sets the item state
 581 bool wxListCtrl::SetItemState(long item, long state, long stateMask)
 582 {
 583     wxListItem info;
 584
 585     info.m_mask = wxLIST_MASK_STATE ;
 586     info.m_state = state;
 587     info.m_stateMask = stateMask;
 588     info.m_itemId = item;
 589
 590     return SetItem(info);
 591 }
 592
 593 // Sets the item image
 594 bool wxListCtrl::SetItemImage(long item, int image, int selImage)
 595 {
 596     wxListItem info;
 597
 598     info.m_mask = wxLIST_MASK_IMAGE ;
 599     info.m_image = image;
 600     info.m_itemId = item;
 601
 602     return SetItem(info);
 603 }
 604
 605 // Gets the item text
 606 wxString wxListCtrl::GetItemText(long item) const
 607 {
 608     wxListItem info;
 609
 610     info.m_mask = wxLIST_MASK_TEXT ;
 611     info.m_itemId = item;
 612
 613     if (!GetItem(info))
 614         return wxString("");
 615     return info.m_text;
 616 }
 617
 618 // Sets the item text
 619 void wxListCtrl::SetItemText(long item, const wxString& str)
 620 {
 621     wxListItem info;
 622
 623     info.m_mask = wxLIST_MASK_TEXT ;
 624     info.m_itemId = item;
 625     info.m_text = str;
 626
 627     SetItem(info);
 628 }
 629
 630 // Gets the item data
 631 long wxListCtrl::GetItemData(long item) const
 632 {
 633     wxListItem info;
 634
 635     info.m_mask = wxLIST_MASK_DATA ;
 636     info.m_itemId = item;
 637
 638     if (!GetItem(info))
 639         return 0;
 640     return info.m_data;
 641 }
 642
 643 // Sets the item data
 644 bool wxListCtrl::SetItemData(long item, long data)
 645 {
 646     wxListItem info;
 647
 648     info.m_mask = wxLIST_MASK_DATA ;
 649     info.m_itemId = item;
 650     info.m_data = data;
 651
 652     return SetItem(info);
 653 }
 654
 655 // Gets the item rectangle
 656 bool wxListCtrl::GetItemRect(long item, wxRect& rect, int code) const
 657 {
 658     RECT rect2;
 659
 660     int code2 = LVIR_BOUNDS;
 661     if ( code == wxLIST_RECT_BOUNDS )
 662         code2 = LVIR_BOUNDS;
 663     else if ( code == wxLIST_RECT_ICON )
 664         code2 = LVIR_ICON;
 665     else if ( code == wxLIST_RECT_LABEL )
 666         code2 = LVIR_LABEL;
 667
 668     bool success = (ListView_GetItemRect((HWND) GetHWND(), (int) item, &rect2, code2) != 0);
 669
 670     rect.x = rect2.left;
 671     rect.y = rect2.top;
 672     rect.width = rect2.right - rect2.left;
 673     rect.height = rect2.bottom - rect2.left;
 674     return success;
 675 }
 676
 677 // Gets the item position
 678 bool wxListCtrl::GetItemPosition(long item, wxPoint& pos) const
 679 {
 680     POINT pt;
 681
 682     bool success = (ListView_GetItemPosition((HWND) GetHWND(), (int) item, &pt) != 0);
 683
 684     pos.x = pt.x; pos.y = pt.y;
 685     return success;
 686 }
 687
 688 // Sets the item position.
 689 bool wxListCtrl::SetItemPosition(long item, const wxPoint& pos)
 690 {
 691     return (ListView_SetItemPosition((HWND) GetHWND(), (int) item, pos.x, pos.y) != 0);
 692 }
 693
 694 // Gets the number of items in the list control
 695 int wxListCtrl::GetItemCount(void) const
 696 {
 697     return ListView_GetItemCount((HWND) GetHWND());
 698 }
 699
 700 // Retrieves the spacing between icons in pixels.
 701 // If small is TRUE, gets the spacing for the small icon
 702 // view, otherwise the large icon view.
 703 int wxListCtrl::GetItemSpacing(bool isSmall) const
 704 {
 705     return ListView_GetItemSpacing((HWND) GetHWND(), (BOOL) isSmall);
 706 }
 707
 708 // Gets the number of selected items in the list control
 709 int wxListCtrl::GetSelectedItemCount(void) const
 710 {
 711     return ListView_GetSelectedCount((HWND) GetHWND());
 712 }
 713
 714 // Gets the text colour of the listview
 715 wxColour wxListCtrl::GetTextColour(void) const
 716 {
 717     COLORREF ref = ListView_GetTextColor((HWND) GetHWND());
 718     wxColour col(GetRValue(ref), GetGValue(ref), GetBValue(ref));
 719     return col;
 720 }
 721
 722 // Sets the text colour of the listview
 723 void wxListCtrl::SetTextColour(const wxColour& col)
 724 {
 725     ListView_SetTextColor((HWND) GetHWND(), PALETTERGB(col.Red(), col.Blue(), col.Green()));
 726 }
 727
 728 // Gets the index of the topmost visible item when in
 729 // list or report view
 730 long wxListCtrl::GetTopItem(void) const
 731 {
 732     return (long) ListView_GetTopIndex((HWND) GetHWND());
 733 }
 734
 735 // Searches for an item, starting from 'item'.
 736 // 'geometry' is one of
 737 // wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT.
 738 // 'state' is a state bit flag, one or more of
 739 // wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT.
 740 // item can be -1 to find the first item that matches the
 741 // specified flags.
 742 // Returns the item or -1 if unsuccessful.
 743 long wxListCtrl::GetNextItem(long item, int geom, int state) const
 744 {
 745     long flags = 0;
 746
 747     if ( geom == wxLIST_NEXT_ABOVE )
 748         flags |= LVNI_ABOVE;
 749     if ( geom == wxLIST_NEXT_ALL )
 750         flags |= LVNI_ALL;
 751     if ( geom == wxLIST_NEXT_BELOW )
 752         flags |= LVNI_BELOW;
 753     if ( geom == wxLIST_NEXT_LEFT )
 754         flags |= LVNI_TOLEFT;
 755     if ( geom == wxLIST_NEXT_RIGHT )
 756         flags |= LVNI_TORIGHT;
 757
 758     if ( state & wxLIST_STATE_CUT )
 759         flags |= LVNI_CUT;
 760     if ( state & wxLIST_STATE_DROPHILITED )
 761         flags |= LVNI_DROPHILITED;
 762     if ( state & wxLIST_STATE_FOCUSED )
 763         flags |= LVNI_FOCUSED;
 764     if ( state & wxLIST_STATE_SELECTED )
 765         flags |= LVNI_SELECTED;
 766
 767     return (long) ListView_GetNextItem((HWND) GetHWND(), item, flags);
 768 }
 769
 770
 771 wxImageList *wxListCtrl::GetImageList(int which) const
 772 {
 773     if ( which == wxIMAGE_LIST_NORMAL )
 774     {
 775         return m_imageListNormal;
 776     }
 777     else if ( which == wxIMAGE_LIST_SMALL )
 778     {
 779         return m_imageListSmall;
 780     }
 781     else if ( which == wxIMAGE_LIST_STATE )
 782     {
 783         return m_imageListState;
 784     }
 785     return NULL;
 786 }
 787
 788 void wxListCtrl::SetImageList(wxImageList *imageList, int which)
 789 {
 790     int flags = 0;
 791     if ( which == wxIMAGE_LIST_NORMAL )
 792     {
 793         flags = LVSIL_NORMAL;
 794         m_imageListNormal = imageList;
 795     }
 796     else if ( which == wxIMAGE_LIST_SMALL )
 797     {
 798         flags = LVSIL_SMALL;
 799         m_imageListSmall = imageList;
 800     }
 801     else if ( which == wxIMAGE_LIST_STATE )
 802     {
 803         flags = LVSIL_STATE;
 804         m_imageListState = imageList;
 805     }
 806     ListView_SetImageList((HWND) GetHWND(), (HIMAGELIST) imageList ? imageList->GetHIMAGELIST() : 0, flags);
 807 }
 808
 809 // Operations
 810 ////////////////////////////////////////////////////////////////////////////
 811
 812 // Arranges the items
 813 bool wxListCtrl::Arrange(int flag)
 814 {
 815     UINT code = 0;
 816     if ( flag == wxLIST_ALIGN_LEFT )
 817         code = LVA_ALIGNLEFT;
 818     else if ( flag == wxLIST_ALIGN_TOP )
 819         code = LVA_ALIGNTOP;
 820     else if ( flag == wxLIST_ALIGN_DEFAULT )
 821         code = LVA_DEFAULT;
 822     else if ( flag == wxLIST_ALIGN_SNAP_TO_GRID )
 823         code = LVA_SNAPTOGRID;
 824
 825     return (ListView_Arrange((HWND) GetHWND(), code) != 0);
 826 }
 827
 828 // Deletes an item
 829 bool wxListCtrl::DeleteItem(long item)
 830 {
 831     return (ListView_DeleteItem((HWND) GetHWND(), (int) item) != 0);
 832 }
 833
 834 // Deletes all items
 835 bool wxListCtrl::DeleteAllItems()
 836 {
 837     return (ListView_DeleteAllItems((HWND) GetHWND()) != 0);
 838 }
 839
 840 // Deletes all items
 841 bool wxListCtrl::DeleteAllColumns()
 842 {
 843     int i;
 844     for ( i = 0; i < m_colCount; i++)
 845     {
 846         if (ListView_DeleteColumn((HWND) GetHWND(), 0) != 0)
 847             m_colCount --;
 848     }
 849     return (m_colCount == 0);
 850 }
 851
 852 // Deletes a column
 853 bool wxListCtrl::DeleteColumn(int col)
 854 {
 855     bool success = (ListView_DeleteColumn((HWND) GetHWND(), col) != 0);
 856
 857     if ( success && (m_colCount > 0) )
 858         m_colCount --;
 859     return success;
 860 }
 861
 862 // Clears items, and columns if there are any.
 863 void wxListCtrl::ClearAll()
 864 {
 865     DeleteAllItems();
 866     if ( m_colCount > 0 )
 867         DeleteAllColumns();
 868 }
 869
 870 wxTextCtrl* wxListCtrl::EditLabel(long item, wxClassInfo* textControlClass)
 871 {
 872     wxASSERT( (textControlClass->IsKindOf(CLASSINFO(wxTextCtrl))) );
 873
 874     HWND hWnd = (HWND) ListView_EditLabel((HWND) GetHWND(), item);
 875
 876     if (m_textCtrl)
 877     {
 878         m_textCtrl->UnsubclassWin();
 879         m_textCtrl->SetHWND(0);
 880         delete m_textCtrl;
 881         m_textCtrl = NULL;
 882     }
 883
 884     m_textCtrl = (wxTextCtrl*) textControlClass->CreateObject();
 885     m_textCtrl->SetHWND((WXHWND) hWnd);
 886     m_textCtrl->SubclassWin((WXHWND) hWnd);
 887
 888     return m_textCtrl;
 889 }
 890
 891 // End label editing, optionally cancelling the edit
 892 bool wxListCtrl::EndEditLabel(bool cancel)
 893 {
 894     wxFAIL;
 895
 896     /* I don't know how to implement this: there's no such macro as ListView_EndEditLabelNow.
 897      * ???
 898      bool success = (ListView_EndEditLabelNow((HWND) GetHWND(), cancel) != 0);
 899
 900      if (m_textCtrl)
 901      {
 902      m_textCtrl->UnsubclassWin();
 903      m_textCtrl->SetHWND(0);
 904      delete m_textCtrl;
 905      m_textCtrl = NULL;
 906      }
 907      return success;
 908      */
 909     return FALSE;
 910 }
 911
 912
 913 // Ensures this item is visible
 914 bool wxListCtrl::EnsureVisible(long item)
 915 {
 916     return (ListView_EnsureVisible((HWND) GetHWND(), (int) item, FALSE) != 0);
 917 }
 918
 919 // Find an item whose label matches this string, starting from the item after 'start'
 920 // or the beginning if 'start' is -1.
 921 long wxListCtrl::FindItem(long start, const wxString& str, bool partial)
 922 {
 923     LV_FINDINFO findInfo;
 924
 925     findInfo.flags = LVFI_STRING;
 926     if ( partial )
 927         findInfo.flags |= LVFI_STRING;
 928     findInfo.psz = WXSTRINGCAST str;
 929
 930     return ListView_FindItem((HWND) GetHWND(), (int) start, & findInfo);
 931 }
 932
 933 // Find an item whose data matches this data, starting from the item after 'start'
 934 // or the beginning if 'start' is -1.
 935 long wxListCtrl::FindItem(long start, long data)
 936 {
 937     LV_FINDINFO findInfo;
 938
 939     findInfo.flags = LVFI_PARAM;
 940     findInfo.lParam = data;
 941
 942     return ListView_FindItem((HWND) GetHWND(), (int) start, & findInfo);
 943 }
 944
 945 // Find an item nearest this position in the specified direction, starting from
 946 // the item after 'start' or the beginning if 'start' is -1.
 947 long wxListCtrl::FindItem(long start, const wxPoint& pt, int direction)
 948 {
 949     LV_FINDINFO findInfo;
 950
 951     findInfo.flags = LVFI_NEARESTXY;
 952     findInfo.pt.x = pt.x;
 953     findInfo.pt.y = pt.y;
 954     findInfo.vkDirection = VK_RIGHT;
 955
 956     if ( direction == wxLIST_FIND_UP )
 957         findInfo.vkDirection = VK_UP;
 958     else if ( direction == wxLIST_FIND_DOWN )
 959         findInfo.vkDirection = VK_DOWN;
 960     else if ( direction == wxLIST_FIND_LEFT )
 961         findInfo.vkDirection = VK_LEFT;
 962     else if ( direction == wxLIST_FIND_RIGHT )
 963         findInfo.vkDirection = VK_RIGHT;
 964
 965     return ListView_FindItem((HWND) GetHWND(), (int) start, & findInfo);
 966 }
 967
 968 // Determines which item (if any) is at the specified point,
 969 // giving details in 'flags' (see wxLIST_HITTEST_... flags above)
 970 long wxListCtrl::HitTest(const wxPoint& point, int& flags)
 971 {
 972     LV_HITTESTINFO hitTestInfo;
 973     hitTestInfo.pt.x = (int) point.x;
 974     hitTestInfo.pt.y = (int) point.y;
 975
 976     ListView_HitTest((HWND) GetHWND(), & hitTestInfo);
 977
 978     flags = 0;
 979     if ( hitTestInfo.flags & LVHT_ABOVE )
 980         flags |= wxLIST_HITTEST_ABOVE;
 981     if ( hitTestInfo.flags & LVHT_BELOW )
 982         flags |= wxLIST_HITTEST_BELOW;
 983     if ( hitTestInfo.flags & LVHT_NOWHERE )
 984         flags |= wxLIST_HITTEST_NOWHERE;
 985     if ( hitTestInfo.flags & LVHT_ONITEMICON )
 986         flags |= wxLIST_HITTEST_ONITEMICON;
 987     if ( hitTestInfo.flags & LVHT_ONITEMLABEL )
 988         flags |= wxLIST_HITTEST_ONITEMLABEL;
 989     if ( hitTestInfo.flags & LVHT_ONITEMSTATEICON )
 990         flags |= wxLIST_HITTEST_ONITEMSTATEICON;
 991     if ( hitTestInfo.flags & LVHT_TOLEFT )
 992         flags |= wxLIST_HITTEST_TOLEFT;
 993     if ( hitTestInfo.flags & LVHT_TORIGHT )
 994         flags |= wxLIST_HITTEST_TORIGHT;
 995
 996     return (long) hitTestInfo.iItem ;
 997 }
 998
 999 // Inserts an item, returning the index of the new item if successful,
1000 // -1 otherwise.
1001 long wxListCtrl::InsertItem(wxListItem& info)
1002 {
1003     LV_ITEM item;
1004     wxConvertToMSWListItem(this, info, item);
1005
1006     return (long) ListView_InsertItem((HWND) GetHWND(), & item);
1007 }
1008
1009 long wxListCtrl::InsertItem(long index, const wxString& label)
1010 {
1011     wxListItem info;
1012     info.m_text = label;
1013     info.m_mask = wxLIST_MASK_TEXT;
1014     info.m_itemId = index;
1015     return InsertItem(info);
1016 }
1017
1018 // Inserts an image item
1019 long wxListCtrl::InsertItem(long index, int imageIndex)
1020 {
1021     wxListItem info;
1022     info.m_image = imageIndex;
1023     info.m_mask = wxLIST_MASK_IMAGE;
1024     info.m_itemId = index;
1025     return InsertItem(info);
1026 }
1027
1028 // Inserts an image/string item
1029 long wxListCtrl::InsertItem(long index, const wxString& label, int imageIndex)
1030 {
1031     wxListItem info;
1032     info.m_image = imageIndex;
1033     info.m_text = label;
1034     info.m_mask = wxLIST_MASK_IMAGE | wxLIST_MASK_TEXT;
1035     info.m_itemId = index;
1036     return InsertItem(info);
1037 }
1038
1039 // For list view mode (only), inserts a column.
1040 long wxListCtrl::InsertColumn(long col, wxListItem& item)
1041 {
1042     LV_COLUMN lvCol;
1043     lvCol.mask = 0;
1044     lvCol.fmt = 0;
1045     lvCol.pszText = NULL;
1046
1047     if ( item.m_mask & wxLIST_MASK_TEXT )
1048     {
1049         lvCol.mask |= LVCF_TEXT;
1050         lvCol.pszText = WXSTRINGCAST item.m_text;
1051         lvCol.cchTextMax = 0; // Ignored
1052     }
1053     if ( item.m_mask & wxLIST_MASK_FORMAT )
1054     {
1055         lvCol.mask |= LVCF_FMT;
1056
1057         if ( item.m_format == wxLIST_FORMAT_LEFT )
1058             lvCol.fmt = LVCFMT_LEFT;
1059         if ( item.m_format == wxLIST_FORMAT_RIGHT )
1060             lvCol.fmt = LVCFMT_RIGHT;
1061         if ( item.m_format == wxLIST_FORMAT_CENTRE )
1062             lvCol.fmt = LVCFMT_CENTER;
1063     }
1064
1065     lvCol.mask |= LVCF_WIDTH;
1066     if ( item.m_mask & wxLIST_MASK_WIDTH )
1067     {
1068         if ( item.m_width == wxLIST_AUTOSIZE)
1069             lvCol.cx = LVSCW_AUTOSIZE;
1070         else if ( item.m_width == wxLIST_AUTOSIZE_USEHEADER)
1071             lvCol.cx = LVSCW_AUTOSIZE_USEHEADER;
1072         else
1073             lvCol.cx = item.m_width;
1074     }
1075     else
1076     {
1077         // always give some width to the new column: this one is compatible
1078         // with wxGTK
1079         lvCol.cx = 80;
1080     }
1081
1082     lvCol.mask |= LVCF_SUBITEM;
1083     lvCol.iSubItem = col;
1084
1085     bool success = ListView_InsertColumn((HWND) GetHWND(), col, & lvCol) != -1;
1086     if ( success )
1087     {
1088         m_colCount++;
1089     }
1090     else
1091     {
1092         wxLogDebug("Failed to insert the column '%s' into listview!",
1093                    lvCol.pszText);
1094     }
1095
1096     return success;
1097 }
1098
1099 long wxListCtrl::InsertColumn(long col, const wxString& heading, int format,
1100         int width)
1101 {
1102     wxListItem item;
1103     item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT;
1104     item.m_text = heading;
1105     if ( width > -1 )
1106     {
1107         item.m_mask |= wxLIST_MASK_WIDTH;
1108         item.m_width = width;
1109     }
1110     item.m_format = format;
1111
1112     return InsertColumn(col, item);
1113 }
1114
1115 // Scrolls the list control. If in icon, small icon or report view mode,
1116 // x specifies the number of pixels to scroll. If in list view mode, x
1117 // specifies the number of columns to scroll.
1118 // If in icon, small icon or list view mode, y specifies the number of pixels
1119 // to scroll. If in report view mode, y specifies the number of lines to scroll.
1120 bool wxListCtrl::ScrollList(int dx, int dy)
1121 {
1122     return (ListView_Scroll((HWND) GetHWND(), dx, dy) != 0);
1123 }
1124
1125 // Sort items.
1126
1127 // fn is a function which takes 3 long arguments: item1, item2, data.
1128 // item1 is the long data associated with a first item (NOT the index).
1129 // item2 is the long data associated with a second item (NOT the index).
1130 // data is the same value as passed to SortItems.
1131 // The return value is a negative number if the first item should precede the second
1132 // item, a positive number of the second item should precede the first,
1133 // or zero if the two items are equivalent.
1134
1135 // data is arbitrary data to be passed to the sort function.
1136 bool wxListCtrl::SortItems(wxListCtrlCompare fn, long data)
1137 {
1138     return (ListView_SortItems((HWND) GetHWND(), (PFNLVCOMPARE) fn, data) != 0);
1139 }
1140
1141 bool wxListCtrl::MSWCommand(WXUINT cmd, WXWORD id)
1142 {
1143     if (cmd == EN_UPDATE)
1144     {
1145         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
1146         event.SetEventObject( this );
1147         ProcessCommand(event);
1148         return TRUE;
1149     }
1150     else if (cmd == EN_KILLFOCUS)
1151     {
1152         wxCommandEvent event(wxEVT_KILL_FOCUS, id);
1153         event.SetEventObject( this );
1154         ProcessCommand(event);
1155         return TRUE;
1156     }
1157     else return FALSE;
1158 }
1159
1160 bool wxListCtrl::MSWNotify(WXWPARAM wParam, WXLPARAM lParam, WXLPARAM *result)
1161 {
1162     wxListEvent event(wxEVT_NULL, m_windowId);
1163     wxEventType eventType = wxEVT_NULL;
1164     NMHDR *hdr1 = (NMHDR *) lParam;
1165     switch ( hdr1->code )
1166     {
1167         case LVN_BEGINRDRAG:
1168             eventType = wxEVT_COMMAND_LIST_BEGIN_RDRAG;
1169             // fall through
1170
1171         case LVN_BEGINDRAG:
1172             if ( eventType == wxEVT_NULL )
1173             {
1174                 eventType = wxEVT_COMMAND_LIST_BEGIN_DRAG;
1175             }
1176
1177             {
1178                 NM_LISTVIEW *hdr = (NM_LISTVIEW *)lParam;
1179                 event.m_itemIndex = hdr->iItem;
1180                 event.m_pointDrag.x = hdr->ptAction.x;
1181                 event.m_pointDrag.y = hdr->ptAction.y;
1182             }
1183             break;
1184
1185         case LVN_BEGINLABELEDIT:
1186             {
1187                 eventType = wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT;
1188                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1189                 wxConvertFromMSWListItem(this, event.m_item, info->item, (HWND) GetHWND());
1190                 break;
1191             }
1192
1193         case LVN_COLUMNCLICK:
1194             {
1195                 eventType = wxEVT_COMMAND_LIST_COL_CLICK;
1196                 NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam;
1197                 event.m_itemIndex = -1;
1198                 event.m_col = hdr->iSubItem;
1199                 break;
1200             }
1201         case LVN_DELETEALLITEMS:
1202             {
1203                 eventType = wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS;
1204                 //      NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam;
1205                 event.m_itemIndex = -1;
1206                 break;
1207             }
1208         case LVN_DELETEITEM:
1209             {
1210                 eventType = wxEVT_COMMAND_LIST_DELETE_ITEM;
1211                 NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam;
1212                 event.m_itemIndex = hdr->iItem;
1213                 break;
1214             }
1215         case LVN_ENDLABELEDIT:
1216             {
1217                 eventType = wxEVT_COMMAND_LIST_END_LABEL_EDIT;
1218                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1219                 wxConvertFromMSWListItem(this, event.m_item, info->item, (HWND) GetHWND());
1220                 if ( info->item.pszText == NULL || info->item.iItem == -1 )
1221                     event.m_cancelled = TRUE;
1222                 break;
1223             }
1224         case LVN_GETDISPINFO:
1225             {
1226                 //      return FALSE;
1227                 // TODO: some text buffering here, I think
1228                 // TODO: API for getting Windows to retrieve values
1229                 // on demand.
1230                 eventType = wxEVT_COMMAND_LIST_GET_INFO;
1231                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1232                 wxConvertFromMSWListItem(this, event.m_item, info->item, (HWND) GetHWND());
1233                 break;
1234             }
1235         case LVN_INSERTITEM:
1236             {
1237                 eventType = wxEVT_COMMAND_LIST_INSERT_ITEM;
1238                 NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam;
1239                 event.m_itemIndex = hdr->iItem;
1240                 break;
1241             }
1242         case LVN_ITEMCHANGED:
1243             {
1244                 // This needs to be sent to wxListCtrl as a rather more
1245                 // concrete event. For now, just detect a selection
1246                 // or deselection.
1247                 NM_LISTVIEW* hdr = (NM_LISTVIEW*)lParam;
1248                 if ( (hdr->uNewState & LVIS_SELECTED) && !(hdr->uOldState & LVIS_SELECTED) )
1249                 {
1250                     eventType = wxEVT_COMMAND_LIST_ITEM_SELECTED;
1251                     event.m_itemIndex = hdr->iItem;
1252                 }
1253                 else if ( !(hdr->uNewState & LVIS_SELECTED) && (hdr->uOldState & LVIS_SELECTED) )
1254                 {
1255                     eventType = wxEVT_COMMAND_LIST_ITEM_DESELECTED;
1256                     event.m_itemIndex = hdr->iItem;
1257                 }
1258                 else
1259                     return FALSE;
1260                 break;
1261             }
1262         case LVN_KEYDOWN:
1263             {
1264                 eventType = wxEVT_COMMAND_LIST_KEY_DOWN;
1265                 LV_KEYDOWN *info = (LV_KEYDOWN *)lParam;
1266                 event.m_code = wxCharCodeMSWToWX(info->wVKey);
1267                 break;
1268             }
1269         case LVN_SETDISPINFO:
1270             {
1271                 eventType = wxEVT_COMMAND_LIST_SET_INFO;
1272                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1273                 wxConvertFromMSWListItem(this, event.m_item, info->item, (HWND) GetHWND());
1274                 break;
1275             }
1276
1277         default :
1278             return wxControl::MSWNotify(wParam, lParam, result);
1279     }
1280
1281     event.SetEventObject( this );
1282     event.SetEventType(eventType);
1283
1284     if ( !GetEventHandler()->ProcessEvent(event) )
1285         return FALSE;
1286
1287     if (hdr1->code == LVN_GETDISPINFO)
1288     {
1289         LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1290         if ( info->item.mask & LVIF_TEXT )
1291         {
1292             if ( !event.m_item.m_text.IsNull() )
1293             {
1294                 info->item.pszText = AddPool(event.m_item.m_text);
1295                 info->item.cchTextMax = strlen(info->item.pszText) + 1;
1296             }
1297         }
1298         //    wxConvertToMSWListItem(this, event.m_item, info->item);
1299     }
1300
1301     *result = !event.IsAllowed();
1302
1303     return TRUE;
1304 }
1305
1306 char *wxListCtrl::AddPool(const wxString& str)
1307 {
1308     // Remove the first element if 3 strings exist
1309     if ( m_stringPool.Number() == 3 )
1310     {
1311         wxNode *node = m_stringPool.First();
1312         delete[] (char *)node->Data();
1313         delete node;
1314     }
1315     wxNode *node = m_stringPool.Add((char *) (const char *)str);
1316     return (char *)node->Data();
1317 }
1318
1319 // List item structure
1320 wxListItem::wxListItem()
1321 {
1322     m_mask = 0;
1323     m_itemId = 0;
1324     m_col = 0;
1325     m_state = 0;
1326     m_stateMask = 0;
1327     m_image = 0;
1328     m_data = 0;
1329
1330     m_format = wxLIST_FORMAT_CENTRE;
1331     m_width = 0;
1332 }
1333
1334 static void wxConvertFromMSWListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& lvItem, HWND getFullInfo)
1335 {
1336     info.m_data = lvItem.lParam;
1337     info.m_mask = 0;
1338     info.m_state = 0;
1339     info.m_stateMask = 0;
1340     info.m_itemId = lvItem.iItem;
1341
1342     long oldMask = lvItem.mask;
1343
1344     bool needText = FALSE;
1345     if (getFullInfo != 0)
1346     {
1347         if ( lvItem.mask & LVIF_TEXT )
1348             needText = FALSE;
1349         else
1350             needText = TRUE;
1351
1352         if ( needText )
1353         {
1354             lvItem.pszText = new char[513];
1355             lvItem.cchTextMax = 512;
1356         }
1357         //    lvItem.mask |= TVIF_HANDLE | TVIF_STATE | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN | TVIF_PARAM ;
1358         lvItem.mask |= LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM ;
1359         ::SendMessage(getFullInfo, LVM_GETITEM, 0, (LPARAM)& lvItem) ;
1360     }
1361
1362     if ( lvItem.mask & LVIF_STATE )
1363     {
1364         info.m_mask |= wxLIST_MASK_STATE;
1365
1366         if ( lvItem.stateMask & LVIS_CUT)
1367         {
1368             info.m_stateMask |= wxLIST_STATE_CUT ;
1369             if ( lvItem.state & LVIS_CUT )
1370                 info.m_state |= wxLIST_STATE_CUT ;
1371         }
1372         if ( lvItem.stateMask & LVIS_DROPHILITED)
1373         {
1374             info.m_stateMask |= wxLIST_STATE_DROPHILITED ;
1375             if ( lvItem.state & LVIS_DROPHILITED )
1376                 info.m_state |= wxLIST_STATE_DROPHILITED ;
1377         }
1378         if ( lvItem.stateMask & LVIS_FOCUSED)
1379         {
1380             info.m_stateMask |= wxLIST_STATE_FOCUSED ;
1381             if ( lvItem.state & LVIS_FOCUSED )
1382                 info.m_state |= wxLIST_STATE_FOCUSED ;
1383         }
1384         if ( lvItem.stateMask & LVIS_SELECTED)
1385         {
1386             info.m_stateMask |= wxLIST_STATE_SELECTED ;
1387             if ( lvItem.state & LVIS_SELECTED )
1388                 info.m_state |= wxLIST_STATE_SELECTED ;
1389         }
1390     }
1391
1392     if ( lvItem.mask & LVIF_TEXT )
1393     {
1394         info.m_mask |= wxLIST_MASK_TEXT;
1395         info.m_text = lvItem.pszText;
1396     }
1397     if ( lvItem.mask & LVIF_IMAGE )
1398     {
1399         info.m_mask |= wxLIST_MASK_IMAGE;
1400         info.m_image = lvItem.iImage;
1401     }
1402     if ( lvItem.mask & LVIF_PARAM )
1403         info.m_mask |= wxLIST_MASK_DATA;
1404     if ( lvItem.mask & LVIF_DI_SETITEM )
1405         info.m_mask |= wxLIST_SET_ITEM;
1406     info.m_col = lvItem.iSubItem;
1407
1408     if (needText)
1409     {
1410         if (lvItem.pszText)
1411             delete[] lvItem.pszText;
1412     }
1413     lvItem.mask = oldMask ;
1414 }
1415
1416 static void wxConvertToMSWListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& lvItem)
1417 {
1418     lvItem.iItem = (int) info.m_itemId ;
1419
1420     lvItem.iImage = info.m_image ;
1421     lvItem.lParam = info.m_data;
1422     lvItem.stateMask = 0;
1423     lvItem.state = 0;
1424     lvItem.mask = 0;
1425     lvItem.iSubItem = info.m_col;
1426
1427     if (info.m_mask & wxLIST_MASK_STATE)
1428     {
1429         lvItem.mask |= LVIF_STATE ;
1430         if (info.m_stateMask & wxLIST_STATE_CUT)
1431         {
1432             lvItem.stateMask |= LVIS_CUT ;
1433             if (info.m_state & wxLIST_STATE_CUT)
1434                 lvItem.state |= LVIS_CUT;
1435         }
1436         if (info.m_stateMask & wxLIST_STATE_DROPHILITED)
1437         {
1438             lvItem.stateMask |= LVIS_DROPHILITED;
1439             if (info.m_state & wxLIST_STATE_DROPHILITED)
1440                 lvItem.state |= LVIS_DROPHILITED;
1441         }
1442         if (info.m_stateMask & wxLIST_STATE_FOCUSED)
1443         {
1444             lvItem.stateMask |= LVIS_FOCUSED;
1445             if (info.m_state & wxLIST_STATE_FOCUSED)
1446                 lvItem.state |= LVIS_FOCUSED;
1447         }
1448         if (info.m_stateMask & wxLIST_STATE_SELECTED)
1449         {
1450             lvItem.stateMask |= LVIS_SELECTED;
1451             if (info.m_state & wxLIST_STATE_SELECTED)
1452                 lvItem.state |= LVIS_SELECTED;
1453         }
1454     }
1455
1456     if (info.m_mask & wxLIST_MASK_TEXT)
1457     {
1458         lvItem.mask |= LVIF_TEXT ;
1459         if ( ctrl->GetWindowStyleFlag() & wxLC_USER_TEXT )
1460         {
1461             lvItem.pszText = LPSTR_TEXTCALLBACK;
1462         }
1463         else
1464         {
1465             lvItem.pszText = (char *) (const char *)info.m_text ;
1466             if ( lvItem.pszText )
1467                 lvItem.cchTextMax = info.m_text.Length();
1468             else
1469                 lvItem.cchTextMax = 0;
1470         }
1471     }
1472     if (info.m_mask & wxLIST_MASK_IMAGE)
1473         lvItem.mask |= LVIF_IMAGE ;
1474     if (info.m_mask & wxLIST_MASK_DATA)
1475         lvItem.mask |= LVIF_PARAM ;
1476 }
1477
1478 // List event
1479 IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxNotifyEvent)
1480
1481 wxListEvent::wxListEvent(wxEventType commandType, int id)
1482 : wxNotifyEvent(commandType, id)
1483 {
1484     m_code = 0;
1485     m_itemIndex = 0;
1486     m_col = 0;
1487     m_cancelled = FALSE;
1488 }
1489
1490 #endif
1491