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 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 #ifdef __GNUG__
  21     #pragma implementation "listctrl.h"
  22     #pragma implementation "listctrlbase.h"
  23 #endif
  24
  25 // For compilers that support precompilation, includes "wx.h".
  26 #include "wx/wxprec.h"
  27
  28 #ifdef __BORLANDC__
  29     #pragma hdrstop
  30 #endif
  31
  32 #if wxUSE_LISTCTRL && defined(__WIN95__)
  33
  34 #ifndef WX_PRECOMP
  35     #include "wx/app.h"
  36     #include "wx/intl.h"
  37     #include "wx/log.h"
  38     #include "wx/settings.h"
  39 #endif
  40
  41 #include "wx/textctrl.h"
  42 #include "wx/imaglist.h"
  43 #include "wx/listctrl.h"
  44 #include "wx/dcclient.h"
  45
  46 #include "wx/msw/private.h"
  47
  48 #if ((defined(__GNUWIN32_OLD__) || defined(__TWIN32__)) && !defined(__CYGWIN10__))
  49     #include "wx/msw/gnuwin32/extra.h"
  50 #else
  51     #include <commctrl.h>
  52 #endif
  53
  54 #ifndef LVHT_ONITEM
  55     #define LVHT_ONITEM \
  56                 (LVHT_ONITEMICON | LVHT_ONITEMLABEL | LVHT_ONITEMSTATEICON)
  57 #endif
  58
  59 #ifndef LVM_SETEXTENDEDLISTVIEWSTYLE
  60     #define LVM_SETEXTENDEDLISTVIEWSTYLE (0x1000 + 54)
  61 #endif
  62
  63 #ifndef LVS_EX_FULLROWSELECT
  64     #define LVS_EX_FULLROWSELECT 0x00000020
  65 #endif
  66
  67 // ----------------------------------------------------------------------------
  68 // private functions
  69 // ----------------------------------------------------------------------------
  70
  71 static void wxConvertToMSWListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& tvItem);
  72 static void wxConvertFromMSWListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& tvItem, HWND getFullInfo = 0);
  73
  74 // ----------------------------------------------------------------------------
  75 // events
  76 // ----------------------------------------------------------------------------
  77
  78 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_DRAG)
  79 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_RDRAG)
  80 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT)
  81 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_END_LABEL_EDIT)
  82 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_DELETE_ITEM)
  83 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS)
  84 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_GET_INFO)
  85 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_SET_INFO)
  86 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_SELECTED)
  87 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_DESELECTED)
  88 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_KEY_DOWN)
  89 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_INSERT_ITEM)
  90 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_CLICK)
  91 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK)
  92 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK)
  93 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_ACTIVATED)
  94
  95 IMPLEMENT_DYNAMIC_CLASS(wxListCtrl, wxControl)
  96 IMPLEMENT_DYNAMIC_CLASS(wxListItem, wxObject)
  97
  98 BEGIN_EVENT_TABLE(wxListCtrl, wxControl)
  99     EVT_PAINT(wxListCtrl::OnPaint)
 100 END_EVENT_TABLE()
 101
 102 // ============================================================================
 103 // implementation
 104 // ============================================================================
 105
 106 // ----------------------------------------------------------------------------
 107 // wxListEvent
 108 // ----------------------------------------------------------------------------
 109
 110 void wxListEvent::CopyObject(wxObject& object_dest) const
 111 {
 112     wxListEvent *obj = (wxListEvent *)&object_dest;
 113
 114     wxNotifyEvent::CopyObject(object_dest);
 115
 116     obj->m_code = m_code;
 117     obj->m_itemIndex = m_itemIndex;
 118     obj->m_oldItemIndex = m_oldItemIndex;
 119     obj->m_col = m_col;
 120     obj->m_cancelled = m_cancelled;
 121     obj->m_pointDrag = m_pointDrag;
 122     obj->m_item.m_mask = m_item.m_mask;
 123     obj->m_item.m_itemId = m_item.m_itemId;
 124     obj->m_item.m_col = m_item.m_col;
 125     obj->m_item.m_state = m_item.m_state;
 126     obj->m_item.m_stateMask = m_item.m_stateMask;
 127     obj->m_item.m_text = m_item.m_text;
 128     obj->m_item.m_image = m_item.m_image;
 129     obj->m_item.m_data = m_item.m_data;
 130     obj->m_item.m_format = m_item.m_format;
 131     obj->m_item.m_width = m_item.m_width;
 132
 133     if ( m_item.HasAttributes() )
 134     {
 135         obj->m_item.SetTextColour(m_item.GetTextColour());
 136         obj->m_item.SetBackgroundColour(m_item.GetBackgroundColour());
 137         obj->m_item.SetFont(m_item.GetFont());
 138     }
 139 }
 140
 141 // ----------------------------------------------------------------------------
 142 // wxListCtrl construction
 143 // ----------------------------------------------------------------------------
 144
 145 void wxListCtrl::Init()
 146 {
 147     m_imageListNormal = NULL;
 148     m_imageListSmall = NULL;
 149     m_imageListState = NULL;
 150     m_ownsImageListNormal = m_ownsImageListSmall = m_ownsImageListState = FALSE;
 151     m_baseStyle = 0;
 152     m_colCount = 0;
 153     m_textCtrl = NULL;
 154     m_hasAnyAttr = FALSE;
 155 }
 156
 157 bool wxListCtrl::Create(wxWindow *parent,
 158                         wxWindowID id,
 159                         const wxPoint& pos,
 160                         const wxSize& size,
 161                         long style,
 162                         const wxValidator& validator,
 163                         const wxString& name)
 164 {
 165 #if wxUSE_VALIDATORS
 166     SetValidator(validator);
 167 #endif // wxUSE_VALIDATORS
 168
 169     SetName(name);
 170
 171     int x = pos.x;
 172     int y = pos.y;
 173     int width = size.x;
 174     int height = size.y;
 175
 176     m_windowStyle = style;
 177
 178     SetParent(parent);
 179
 180     if (width <= 0)
 181         width = 100;
 182     if (height <= 0)
 183         height = 30;
 184     if (x < 0)
 185         x = 0;
 186     if (y < 0)
 187         y = 0;
 188
 189     m_windowId = (id == -1) ? NewControlId() : id;
 190
 191     DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP |
 192                    LVS_SHAREIMAGELISTS | LVS_SHOWSELALWAYS;
 193
 194     if ( m_windowStyle & wxCLIP_SIBLINGS )
 195         wstyle |= WS_CLIPSIBLINGS;
 196
 197     if ( wxStyleHasBorder(m_windowStyle) )
 198         wstyle |= WS_BORDER;
 199     m_baseStyle = wstyle;
 200
 201     if ( !DoCreateControl(x, y, width, height) )
 202         return FALSE;
 203
 204     if (parent)
 205         parent->AddChild(this);
 206
 207     return TRUE;
 208 }
 209
 210 bool wxListCtrl::DoCreateControl(int x, int y, int w, int h)
 211 {
 212     DWORD wstyle = m_baseStyle;
 213
 214     bool want3D;
 215     WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D);
 216
 217     // Even with extended styles, need to combine with WS_BORDER
 218     // for them to look right.
 219     if ( want3D )
 220         wstyle |= WS_BORDER;
 221
 222     long oldStyle = 0; // Dummy
 223     wstyle |= ConvertToMSWStyle(oldStyle, m_windowStyle);
 224
 225     // Create the ListView control.
 226     m_hWnd = (WXHWND)CreateWindowEx(exStyle,
 227                                     WC_LISTVIEW,
 228                                     wxT(""),
 229                                     wstyle,
 230                                     x, y, w, h,
 231                                     GetWinHwnd(GetParent()),
 232                                     (HMENU)m_windowId,
 233                                     wxGetInstance(),
 234                                     NULL);
 235
 236     if ( !m_hWnd )
 237     {
 238         wxLogError(_("Can't create list control window, check that comctl32.dll is installed."));
 239
 240         return FALSE;
 241     }
 242
 243     // for comctl32.dll v 4.70+ we want to have this attribute because it's
 244     // prettier (and also because wxGTK does it like this)
 245     if ( (wstyle & LVS_REPORT) && wxTheApp->GetComCtl32Version() >= 470 )
 246     {
 247         ::SendMessage(GetHwnd(), LVM_SETEXTENDEDLISTVIEWSTYLE,
 248                       0, LVS_EX_FULLROWSELECT);
 249     }
 250
 251     SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
 252     SetForegroundColour(GetParent()->GetForegroundColour());
 253
 254     SubclassWin(m_hWnd);
 255
 256     return TRUE;
 257 }
 258
 259 void wxListCtrl::UpdateStyle()
 260 {
 261     if ( GetHWND() )
 262     {
 263         // The new window view style
 264         long dummy;
 265         DWORD dwStyleNew = ConvertToMSWStyle(dummy, m_windowStyle);
 266         dwStyleNew |= m_baseStyle;
 267
 268         // Get the current window style.
 269         DWORD dwStyleOld = ::GetWindowLong(GetHwnd(), GWL_STYLE);
 270
 271         // Only set the window style if the view bits have changed.
 272         if ( dwStyleOld != dwStyleNew )
 273         {
 274             ::SetWindowLong(GetHwnd(), GWL_STYLE, dwStyleNew);
 275         }
 276     }
 277 }
 278
 279 void wxListCtrl::FreeAllAttrs(bool dontRecreate)
 280 {
 281     if ( m_hasAnyAttr )
 282     {
 283         for ( wxNode *node = m_attrs.Next(); node; node = m_attrs.Next() )
 284         {
 285             delete (wxListItemAttr *)node->Data();
 286         }
 287
 288         m_attrs.Destroy();
 289         if ( !dontRecreate )
 290         {
 291             m_attrs.Create(wxKEY_INTEGER, 1000);        // just as def ctor
 292         }
 293
 294         m_hasAnyAttr = FALSE;
 295     }
 296 }
 297
 298 wxListCtrl::~wxListCtrl()
 299 {
 300     FreeAllAttrs(TRUE /* no need to recreate hash any more */);
 301
 302     if ( m_textCtrl )
 303     {
 304         m_textCtrl->UnsubclassWin();
 305         m_textCtrl->SetHWND(0);
 306         delete m_textCtrl;
 307         m_textCtrl = NULL;
 308     }
 309
 310     if (m_ownsImageListNormal) delete m_imageListNormal;
 311     if (m_ownsImageListSmall) delete m_imageListSmall;
 312     if (m_ownsImageListState) delete m_imageListState;
 313 }
 314
 315 // ----------------------------------------------------------------------------
 316 // set/get/change style
 317 // ----------------------------------------------------------------------------
 318
 319 // Add or remove a single window style
 320 void wxListCtrl::SetSingleStyle(long style, bool add)
 321 {
 322     long flag = GetWindowStyleFlag();
 323
 324     // Get rid of conflicting styles
 325     if ( add )
 326     {
 327         if ( style & wxLC_MASK_TYPE)
 328             flag = flag & ~wxLC_MASK_TYPE;
 329         if ( style & wxLC_MASK_ALIGN )
 330             flag = flag & ~wxLC_MASK_ALIGN;
 331         if ( style & wxLC_MASK_SORT )
 332             flag = flag & ~wxLC_MASK_SORT;
 333     }
 334
 335     if ( flag & style )
 336     {
 337         if ( !add )
 338             flag -= style;
 339     }
 340     else
 341     {
 342         if ( add )
 343         {
 344             flag |= style;
 345         }
 346     }
 347
 348     m_windowStyle = flag;
 349
 350     UpdateStyle();
 351 }
 352
 353 // Set the whole window style
 354 void wxListCtrl::SetWindowStyleFlag(long flag)
 355 {
 356     m_windowStyle = flag;
 357
 358     UpdateStyle();
 359 }
 360
 361 // Can be just a single style, or a bitlist
 362 long wxListCtrl::ConvertToMSWStyle(long& oldStyle, long style) const
 363 {
 364     long wstyle = 0;
 365     if ( style & wxLC_ICON )
 366     {
 367         if ( (oldStyle & LVS_TYPEMASK) == LVS_SMALLICON )
 368             oldStyle -= LVS_SMALLICON;
 369         if ( (oldStyle & LVS_TYPEMASK) == LVS_REPORT )
 370             oldStyle -= LVS_REPORT;
 371         if ( (oldStyle & LVS_TYPEMASK) == LVS_LIST )
 372             oldStyle -= LVS_LIST;
 373         wstyle |= LVS_ICON;
 374     }
 375
 376     if ( style & wxLC_SMALL_ICON )
 377     {
 378         if ( (oldStyle & LVS_TYPEMASK) == LVS_ICON )
 379             oldStyle -= LVS_ICON;
 380         if ( (oldStyle & LVS_TYPEMASK) == LVS_REPORT )
 381             oldStyle -= LVS_REPORT;
 382         if ( (oldStyle & LVS_TYPEMASK) == LVS_LIST )
 383             oldStyle -= LVS_LIST;
 384         wstyle |= LVS_SMALLICON;
 385     }
 386
 387     if ( style & wxLC_LIST )
 388     {
 389         if ( (oldStyle & LVS_TYPEMASK) == LVS_ICON )
 390             oldStyle -= LVS_ICON;
 391         if ( (oldStyle & LVS_TYPEMASK) == LVS_REPORT )
 392             oldStyle -= LVS_REPORT;
 393         if ( (oldStyle & LVS_TYPEMASK) == LVS_SMALLICON )
 394             oldStyle -= LVS_SMALLICON;
 395         wstyle |= LVS_LIST;
 396     }
 397
 398     if ( style & wxLC_REPORT )
 399     {
 400         if ( (oldStyle & LVS_TYPEMASK) == LVS_ICON )
 401             oldStyle -= LVS_ICON;
 402         if ( (oldStyle & LVS_TYPEMASK) == LVS_LIST )
 403             oldStyle -= LVS_LIST;
 404         if ( (oldStyle & LVS_TYPEMASK) == LVS_SMALLICON )
 405             oldStyle -= LVS_SMALLICON;
 406
 407         wstyle |= LVS_REPORT;
 408     }
 409
 410     if ( style & wxLC_ALIGN_LEFT )
 411     {
 412         if ( oldStyle & LVS_ALIGNTOP )
 413             oldStyle -= LVS_ALIGNTOP;
 414         wstyle |= LVS_ALIGNLEFT;
 415     }
 416
 417     if ( style & wxLC_ALIGN_TOP )
 418     {
 419         if ( oldStyle & LVS_ALIGNLEFT )
 420             oldStyle -= LVS_ALIGNLEFT;
 421         wstyle |= LVS_ALIGNTOP;
 422     }
 423
 424     if ( style & wxLC_AUTOARRANGE )
 425         wstyle |= LVS_AUTOARRANGE;
 426
 427     if ( style & wxLC_NO_SORT_HEADER )
 428         wstyle |= LVS_NOSORTHEADER;
 429
 430     if ( style & wxLC_NO_HEADER )
 431         wstyle |= LVS_NOCOLUMNHEADER;
 432
 433     if ( style & wxLC_EDIT_LABELS )
 434         wstyle |= LVS_EDITLABELS;
 435
 436     if ( style & wxLC_SINGLE_SEL )
 437         wstyle |= LVS_SINGLESEL;
 438
 439     if ( style & wxLC_SORT_ASCENDING )
 440     {
 441         if ( oldStyle & LVS_SORTDESCENDING )
 442             oldStyle -= LVS_SORTDESCENDING;
 443         wstyle |= LVS_SORTASCENDING;
 444     }
 445
 446     if ( style & wxLC_SORT_DESCENDING )
 447     {
 448         if ( oldStyle & LVS_SORTASCENDING )
 449             oldStyle -= LVS_SORTASCENDING;
 450         wstyle |= LVS_SORTDESCENDING;
 451     }
 452
 453     if ( style & wxLC_VIRTUAL )
 454     {
 455         wstyle |= LVS_OWNERDATA;
 456     }
 457
 458     return wstyle;
 459 }
 460
 461 // ----------------------------------------------------------------------------
 462 // accessors
 463 // ----------------------------------------------------------------------------
 464
 465 // Sets the foreground, i.e. text, colour
 466 bool wxListCtrl::SetForegroundColour(const wxColour& col)
 467 {
 468     if ( !wxWindow::SetForegroundColour(col) )
 469         return FALSE;
 470
 471     ListView_SetTextColor(GetHwnd(), wxColourToRGB(col));
 472
 473     return TRUE;
 474 }
 475
 476 // Sets the background colour
 477 bool wxListCtrl::SetBackgroundColour(const wxColour& col)
 478 {
 479     if ( !wxWindow::SetBackgroundColour(col) )
 480         return FALSE;
 481
 482     // we set the same colour for both the "empty" background and the items
 483     // background
 484     COLORREF color = wxColourToRGB(col);
 485     ListView_SetBkColor(GetHwnd(), color);
 486     ListView_SetTextBkColor(GetHwnd(), color);
 487
 488     return TRUE;
 489 }
 490
 491 // Gets information about this column
 492 bool wxListCtrl::GetColumn(int col, wxListItem& item) const
 493 {
 494     LV_COLUMN lvCol;
 495     lvCol.mask = 0;
 496     lvCol.fmt = 0;
 497     lvCol.pszText = NULL;
 498
 499     if ( item.m_mask & wxLIST_MASK_TEXT )
 500     {
 501         lvCol.mask |= LVCF_TEXT;
 502         lvCol.pszText = new wxChar[513];
 503         lvCol.cchTextMax = 512;
 504     }
 505
 506     bool success = (ListView_GetColumn(GetHwnd(), col, & lvCol) != 0);
 507
 508     //  item.m_subItem = lvCol.iSubItem;
 509     item.m_width = lvCol.cx;
 510
 511     if ( (item.m_mask & wxLIST_MASK_TEXT) && lvCol.pszText )
 512     {
 513         item.m_text = lvCol.pszText;
 514         delete[] lvCol.pszText;
 515     }
 516
 517     if ( item.m_mask & wxLIST_MASK_FORMAT )
 518     {
 519         if (lvCol.fmt == LVCFMT_LEFT)
 520             item.m_format = wxLIST_FORMAT_LEFT;
 521         else if (lvCol.fmt == LVCFMT_RIGHT)
 522             item.m_format = wxLIST_FORMAT_RIGHT;
 523         else if (lvCol.fmt == LVCFMT_CENTER)
 524             item.m_format = wxLIST_FORMAT_CENTRE;
 525     }
 526
 527     return success;
 528 }
 529
 530 // Sets information about this column
 531 bool wxListCtrl::SetColumn(int col, wxListItem& item)
 532 {
 533     LV_COLUMN lvCol;
 534     lvCol.mask = 0;
 535     lvCol.fmt = 0;
 536     lvCol.pszText = NULL;
 537
 538     if ( item.m_mask & wxLIST_MASK_TEXT )
 539     {
 540         lvCol.mask |= LVCF_TEXT;
 541         lvCol.pszText = WXSTRINGCAST item.m_text;
 542         lvCol.cchTextMax = 0; // Ignored
 543     }
 544     if ( item.m_mask & wxLIST_MASK_FORMAT )
 545     {
 546         lvCol.mask |= LVCF_FMT;
 547
 548         if ( item.m_format == wxLIST_FORMAT_LEFT )
 549             lvCol.fmt = LVCFMT_LEFT;
 550         if ( item.m_format == wxLIST_FORMAT_RIGHT )
 551             lvCol.fmt = LVCFMT_RIGHT;
 552         if ( item.m_format == wxLIST_FORMAT_CENTRE )
 553             lvCol.fmt = LVCFMT_CENTER;
 554     }
 555
 556     if ( item.m_mask & wxLIST_MASK_WIDTH )
 557     {
 558         lvCol.mask |= LVCF_WIDTH;
 559         lvCol.cx = item.m_width;
 560
 561         if ( lvCol.cx == wxLIST_AUTOSIZE)
 562             lvCol.cx = LVSCW_AUTOSIZE;
 563         else if ( lvCol.cx == wxLIST_AUTOSIZE_USEHEADER)
 564             lvCol.cx = LVSCW_AUTOSIZE_USEHEADER;
 565     }
 566     lvCol.mask |= LVCF_SUBITEM;
 567     lvCol.iSubItem = col;
 568     return (ListView_SetColumn(GetHwnd(), col, & lvCol) != 0);
 569 }
 570
 571 // Gets the column width
 572 int wxListCtrl::GetColumnWidth(int col) const
 573 {
 574     return ListView_GetColumnWidth(GetHwnd(), col);
 575 }
 576
 577 // Sets the column width
 578 bool wxListCtrl::SetColumnWidth(int col, int width)
 579 {
 580     int col2 = col;
 581     if ( m_windowStyle & wxLC_LIST )
 582         col2 = -1;
 583
 584     int width2 = width;
 585     if ( width2 == wxLIST_AUTOSIZE)
 586         width2 = LVSCW_AUTOSIZE;
 587     else if ( width2 == wxLIST_AUTOSIZE_USEHEADER)
 588         width2 = LVSCW_AUTOSIZE_USEHEADER;
 589
 590     return (ListView_SetColumnWidth(GetHwnd(), col2, width2) != 0);
 591 }
 592
 593 // Gets the number of items that can fit vertically in the
 594 // visible area of the list control (list or report view)
 595 // or the total number of items in the list control (icon
 596 // or small icon view)
 597 int wxListCtrl::GetCountPerPage() const
 598 {
 599     return ListView_GetCountPerPage(GetHwnd());
 600 }
 601
 602 // Gets the edit control for editing labels.
 603 wxTextCtrl* wxListCtrl::GetEditControl() const
 604 {
 605     return m_textCtrl;
 606 }
 607
 608 // Gets information about the item
 609 bool wxListCtrl::GetItem(wxListItem& info) const
 610 {
 611     LV_ITEM lvItem;
 612     wxZeroMemory(lvItem);
 613
 614     lvItem.iItem = info.m_itemId;
 615     lvItem.iSubItem = info.m_col;
 616
 617     if ( info.m_mask & wxLIST_MASK_TEXT )
 618     {
 619         lvItem.mask |= LVIF_TEXT;
 620         lvItem.pszText = new wxChar[513];
 621         lvItem.cchTextMax = 512;
 622     }
 623     else
 624     {
 625         lvItem.pszText = NULL;
 626     }
 627
 628     if (info.m_mask & wxLIST_MASK_DATA)
 629         lvItem.mask |= LVIF_PARAM;
 630
 631     if (info.m_mask & wxLIST_MASK_IMAGE)
 632         lvItem.mask |= LVIF_IMAGE;
 633
 634     if ( info.m_mask & wxLIST_MASK_STATE )
 635     {
 636         lvItem.mask |= LVIF_STATE;
 637         // the other bits are hardly interesting anyhow
 638         lvItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
 639     }
 640
 641     bool success = ListView_GetItem((HWND)GetHWND(), &lvItem) != 0;
 642     if ( !success )
 643     {
 644         wxLogError(_("Couldn't retrieve information about list control item %d."),
 645                 lvItem.iItem);
 646     }
 647     else
 648     {
 649         wxConvertFromMSWListItem(this, info, lvItem);
 650     }
 651
 652     if (lvItem.pszText)
 653         delete[] lvItem.pszText;
 654
 655     return success;
 656 }
 657
 658 // Sets information about the item
 659 bool wxListCtrl::SetItem(wxListItem& info)
 660 {
 661     LV_ITEM item;
 662     wxConvertToMSWListItem(this, info, item);
 663
 664     item.cchTextMax = 0;
 665     if ( !ListView_SetItem(GetHwnd(), &item) )
 666     {
 667         wxLogDebug(_T("ListView_SetItem() failed"));
 668
 669         return FALSE;
 670     }
 671
 672     // we need to update the item immediately to show the new image
 673     bool updateNow = (info.m_mask & wxLIST_MASK_IMAGE) != 0;
 674
 675     // check whether it has any custom attributes
 676     if ( info.HasAttributes() )
 677     {
 678         wxListItemAttr *attr = (wxListItemAttr *)m_attrs.Get(item.iItem);
 679
 680         if ( attr == NULL )
 681             m_attrs.Put(item.iItem, (wxObject *)new wxListItemAttr(*info.GetAttributes()));
 682         else
 683             *attr = *info.GetAttributes();
 684
 685         m_hasAnyAttr = TRUE;
 686
 687         // if the colour has changed, we must redraw the item
 688         updateNow = TRUE;
 689     }
 690
 691     if ( updateNow )
 692     {
 693         // we need this to make the change visible right now
 694         ListView_Update(GetHwnd(), item.iItem);
 695     }
 696
 697     return TRUE;
 698 }
 699
 700 long wxListCtrl::SetItem(long index, int col, const wxString& label, int imageId)
 701 {
 702     wxListItem info;
 703     info.m_text = label;
 704     info.m_mask = wxLIST_MASK_TEXT;
 705     info.m_itemId = index;
 706     info.m_col = col;
 707     if ( imageId > -1 )
 708     {
 709         info.m_image = imageId;
 710         info.m_mask |= wxLIST_MASK_IMAGE;
 711     }
 712     return SetItem(info);
 713 }
 714
 715
 716 // Gets the item state
 717 int wxListCtrl::GetItemState(long item, long stateMask) const
 718 {
 719     wxListItem info;
 720
 721     info.m_mask = wxLIST_MASK_STATE;
 722     info.m_stateMask = stateMask;
 723     info.m_itemId = item;
 724
 725     if (!GetItem(info))
 726         return 0;
 727
 728     return info.m_state;
 729 }
 730
 731 // Sets the item state
 732 bool wxListCtrl::SetItemState(long item, long state, long stateMask)
 733 {
 734     wxListItem info;
 735
 736     info.m_mask = wxLIST_MASK_STATE;
 737     info.m_state = state;
 738     info.m_stateMask = stateMask;
 739     info.m_itemId = item;
 740
 741     return SetItem(info);
 742 }
 743
 744 // Sets the item image
 745 bool wxListCtrl::SetItemImage(long item, int image, int WXUNUSED(selImage))
 746 {
 747     wxListItem info;
 748
 749     info.m_mask = wxLIST_MASK_IMAGE;
 750     info.m_image = image;
 751     info.m_itemId = item;
 752
 753     return SetItem(info);
 754 }
 755
 756 // Gets the item text
 757 wxString wxListCtrl::GetItemText(long item) const
 758 {
 759     wxListItem info;
 760
 761     info.m_mask = wxLIST_MASK_TEXT;
 762     info.m_itemId = item;
 763
 764     if (!GetItem(info))
 765         return wxString("");
 766     return info.m_text;
 767 }
 768
 769 // Sets the item text
 770 void wxListCtrl::SetItemText(long item, const wxString& str)
 771 {
 772     wxListItem info;
 773
 774     info.m_mask = wxLIST_MASK_TEXT;
 775     info.m_itemId = item;
 776     info.m_text = str;
 777
 778     SetItem(info);
 779 }
 780
 781 // Gets the item data
 782 long wxListCtrl::GetItemData(long item) const
 783 {
 784     wxListItem info;
 785
 786     info.m_mask = wxLIST_MASK_DATA;
 787     info.m_itemId = item;
 788
 789     if (!GetItem(info))
 790         return 0;
 791     return info.m_data;
 792 }
 793
 794 // Sets the item data
 795 bool wxListCtrl::SetItemData(long item, long data)
 796 {
 797     wxListItem info;
 798
 799     info.m_mask = wxLIST_MASK_DATA;
 800     info.m_itemId = item;
 801     info.m_data = data;
 802
 803     return SetItem(info);
 804 }
 805
 806 // Gets the item rectangle
 807 bool wxListCtrl::GetItemRect(long item, wxRect& rect, int code) const
 808 {
 809     RECT rect2;
 810
 811     int code2 = LVIR_BOUNDS;
 812     if ( code == wxLIST_RECT_BOUNDS )
 813         code2 = LVIR_BOUNDS;
 814     else if ( code == wxLIST_RECT_ICON )
 815         code2 = LVIR_ICON;
 816     else if ( code == wxLIST_RECT_LABEL )
 817         code2 = LVIR_LABEL;
 818
 819 #ifdef __WXWINE__
 820     bool success = (ListView_GetItemRect(GetHwnd(), (int) item, &rect2 ) != 0);
 821 #else
 822     bool success = (ListView_GetItemRect(GetHwnd(), (int) item, &rect2, code2) != 0);
 823 #endif
 824
 825     rect.x = rect2.left;
 826     rect.y = rect2.top;
 827     rect.width = rect2.right - rect2.left;
 828     rect.height = rect2.bottom - rect2.top;
 829     return success;
 830 }
 831
 832 // Gets the item position
 833 bool wxListCtrl::GetItemPosition(long item, wxPoint& pos) const
 834 {
 835     POINT pt;
 836
 837     bool success = (ListView_GetItemPosition(GetHwnd(), (int) item, &pt) != 0);
 838
 839     pos.x = pt.x; pos.y = pt.y;
 840     return success;
 841 }
 842
 843 // Sets the item position.
 844 bool wxListCtrl::SetItemPosition(long item, const wxPoint& pos)
 845 {
 846     return (ListView_SetItemPosition(GetHwnd(), (int) item, pos.x, pos.y) != 0);
 847 }
 848
 849 // Gets the number of items in the list control
 850 int wxListCtrl::GetItemCount() const
 851 {
 852     return ListView_GetItemCount(GetHwnd());
 853 }
 854
 855 // Retrieves the spacing between icons in pixels.
 856 // If small is TRUE, gets the spacing for the small icon
 857 // view, otherwise the large icon view.
 858 int wxListCtrl::GetItemSpacing(bool isSmall) const
 859 {
 860     return ListView_GetItemSpacing(GetHwnd(), (BOOL) isSmall);
 861 }
 862
 863 // Gets the number of selected items in the list control
 864 int wxListCtrl::GetSelectedItemCount() const
 865 {
 866     return ListView_GetSelectedCount(GetHwnd());
 867 }
 868
 869 // Gets the text colour of the listview
 870 wxColour wxListCtrl::GetTextColour() const
 871 {
 872     COLORREF ref = ListView_GetTextColor(GetHwnd());
 873     wxColour col(GetRValue(ref), GetGValue(ref), GetBValue(ref));
 874     return col;
 875 }
 876
 877 // Sets the text colour of the listview
 878 void wxListCtrl::SetTextColour(const wxColour& col)
 879 {
 880     ListView_SetTextColor(GetHwnd(), PALETTERGB(col.Red(), col.Green(), col.Blue()));
 881 }
 882
 883 // Gets the index of the topmost visible item when in
 884 // list or report view
 885 long wxListCtrl::GetTopItem() const
 886 {
 887     return (long) ListView_GetTopIndex(GetHwnd());
 888 }
 889
 890 // Searches for an item, starting from 'item'.
 891 // 'geometry' is one of
 892 // wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT.
 893 // 'state' is a state bit flag, one or more of
 894 // wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT.
 895 // item can be -1 to find the first item that matches the
 896 // specified flags.
 897 // Returns the item or -1 if unsuccessful.
 898 long wxListCtrl::GetNextItem(long item, int geom, int state) const
 899 {
 900     long flags = 0;
 901
 902     if ( geom == wxLIST_NEXT_ABOVE )
 903         flags |= LVNI_ABOVE;
 904     if ( geom == wxLIST_NEXT_ALL )
 905         flags |= LVNI_ALL;
 906     if ( geom == wxLIST_NEXT_BELOW )
 907         flags |= LVNI_BELOW;
 908     if ( geom == wxLIST_NEXT_LEFT )
 909         flags |= LVNI_TOLEFT;
 910     if ( geom == wxLIST_NEXT_RIGHT )
 911         flags |= LVNI_TORIGHT;
 912
 913     if ( state & wxLIST_STATE_CUT )
 914         flags |= LVNI_CUT;
 915     if ( state & wxLIST_STATE_DROPHILITED )
 916         flags |= LVNI_DROPHILITED;
 917     if ( state & wxLIST_STATE_FOCUSED )
 918         flags |= LVNI_FOCUSED;
 919     if ( state & wxLIST_STATE_SELECTED )
 920         flags |= LVNI_SELECTED;
 921
 922     return (long) ListView_GetNextItem(GetHwnd(), item, flags);
 923 }
 924
 925
 926 wxImageList *wxListCtrl::GetImageList(int which) const
 927 {
 928     if ( which == wxIMAGE_LIST_NORMAL )
 929     {
 930         return m_imageListNormal;
 931     }
 932     else if ( which == wxIMAGE_LIST_SMALL )
 933     {
 934         return m_imageListSmall;
 935     }
 936     else if ( which == wxIMAGE_LIST_STATE )
 937     {
 938         return m_imageListState;
 939     }
 940     return NULL;
 941 }
 942
 943 void wxListCtrl::SetImageList(wxImageList *imageList, int which)
 944 {
 945     int flags = 0;
 946     if ( which == wxIMAGE_LIST_NORMAL )
 947     {
 948         flags = LVSIL_NORMAL;
 949         if (m_ownsImageListNormal) delete m_imageListNormal;
 950         m_imageListNormal = imageList;
 951         m_ownsImageListNormal = FALSE;
 952     }
 953     else if ( which == wxIMAGE_LIST_SMALL )
 954     {
 955         flags = LVSIL_SMALL;
 956         if (m_ownsImageListSmall) delete m_imageListSmall;
 957         m_imageListSmall = imageList;
 958         m_ownsImageListSmall = FALSE;
 959     }
 960     else if ( which == wxIMAGE_LIST_STATE )
 961     {
 962         flags = LVSIL_STATE;
 963         if (m_ownsImageListState) delete m_imageListState;
 964         m_imageListState = imageList;
 965         m_ownsImageListState = FALSE;
 966     }
 967     ListView_SetImageList(GetHwnd(), (HIMAGELIST) imageList ? imageList->GetHIMAGELIST() : 0, flags);
 968 }
 969
 970 void wxListCtrl::AssignImageList(wxImageList *imageList, int which)
 971 {
 972     SetImageList(imageList, which);
 973     if ( which == wxIMAGE_LIST_NORMAL )
 974         m_ownsImageListNormal = TRUE;
 975     else if ( which == wxIMAGE_LIST_SMALL )
 976         m_ownsImageListSmall = TRUE;
 977     else if ( which == wxIMAGE_LIST_STATE )
 978         m_ownsImageListState = TRUE;
 979 }
 980
 981 // ----------------------------------------------------------------------------
 982 // Operations
 983 // ----------------------------------------------------------------------------
 984
 985 // Arranges the items
 986 bool wxListCtrl::Arrange(int flag)
 987 {
 988     UINT code = 0;
 989     if ( flag == wxLIST_ALIGN_LEFT )
 990         code = LVA_ALIGNLEFT;
 991     else if ( flag == wxLIST_ALIGN_TOP )
 992         code = LVA_ALIGNTOP;
 993     else if ( flag == wxLIST_ALIGN_DEFAULT )
 994         code = LVA_DEFAULT;
 995     else if ( flag == wxLIST_ALIGN_SNAP_TO_GRID )
 996         code = LVA_SNAPTOGRID;
 997
 998     return (ListView_Arrange(GetHwnd(), code) != 0);
 999 }
1000
1001 // Deletes an item
1002 bool wxListCtrl::DeleteItem(long item)
1003 {
1004     return (ListView_DeleteItem(GetHwnd(), (int) item) != 0);
1005 }
1006
1007 // Deletes all items
1008 bool wxListCtrl::DeleteAllItems()
1009 {
1010     return (ListView_DeleteAllItems(GetHwnd()) != 0);
1011 }
1012
1013 // Deletes all items
1014 bool wxListCtrl::DeleteAllColumns()
1015 {
1016     while ( m_colCount > 0 )
1017     {
1018         if ( ListView_DeleteColumn(GetHwnd(), 0) == 0 )
1019         {
1020             wxLogLastError(wxT("ListView_DeleteColumn"));
1021
1022             return FALSE;
1023         }
1024
1025         m_colCount--;
1026     }
1027
1028     wxASSERT_MSG( m_colCount == 0, wxT("no columns should be left") );
1029
1030     return TRUE;
1031 }
1032
1033 // Deletes a column
1034 bool wxListCtrl::DeleteColumn(int col)
1035 {
1036     bool success = (ListView_DeleteColumn(GetHwnd(), col) != 0);
1037
1038     if ( success && (m_colCount > 0) )
1039         m_colCount --;
1040     return success;
1041 }
1042
1043 // Clears items, and columns if there are any.
1044 void wxListCtrl::ClearAll()
1045 {
1046     DeleteAllItems();
1047     if ( m_colCount > 0 )
1048         DeleteAllColumns();
1049 }
1050
1051 wxTextCtrl* wxListCtrl::EditLabel(long item, wxClassInfo* textControlClass)
1052 {
1053     wxASSERT( (textControlClass->IsKindOf(CLASSINFO(wxTextCtrl))) );
1054
1055     // VS: ListView_EditLabel requires that the list has focus.
1056     SetFocus();
1057     HWND hWnd = (HWND) ListView_EditLabel(GetHwnd(), item);
1058
1059     if (m_textCtrl)
1060     {
1061         m_textCtrl->UnsubclassWin();
1062         m_textCtrl->SetHWND(0);
1063         delete m_textCtrl;
1064         m_textCtrl = NULL;
1065     }
1066
1067     m_textCtrl = (wxTextCtrl*) textControlClass->CreateObject();
1068     m_textCtrl->SetHWND((WXHWND) hWnd);
1069     m_textCtrl->SubclassWin((WXHWND) hWnd);
1070
1071     return m_textCtrl;
1072 }
1073
1074 // End label editing, optionally cancelling the edit
1075 bool wxListCtrl::EndEditLabel(bool WXUNUSED(cancel))
1076 {
1077     wxFAIL;
1078
1079     /* I don't know how to implement this: there's no such macro as ListView_EndEditLabelNow.
1080      * ???
1081      bool success = (ListView_EndEditLabelNow(GetHwnd(), cancel) != 0);
1082
1083      if (m_textCtrl)
1084      {
1085      m_textCtrl->UnsubclassWin();
1086      m_textCtrl->SetHWND(0);
1087      delete m_textCtrl;
1088      m_textCtrl = NULL;
1089      }
1090      return success;
1091      */
1092     return FALSE;
1093 }
1094
1095
1096 // Ensures this item is visible
1097 bool wxListCtrl::EnsureVisible(long item)
1098 {
1099     return (ListView_EnsureVisible(GetHwnd(), (int) item, FALSE) != 0);
1100 }
1101
1102 // Find an item whose label matches this string, starting from the item after 'start'
1103 // or the beginning if 'start' is -1.
1104 long wxListCtrl::FindItem(long start, const wxString& str, bool partial)
1105 {
1106     LV_FINDINFO findInfo;
1107
1108     findInfo.flags = LVFI_STRING;
1109     if ( partial )
1110         findInfo.flags |= LVFI_PARTIAL;
1111     findInfo.psz = str;
1112
1113     // ListView_FindItem() excludes the first item from search and to look
1114     // through all the items you need to start from -1 which is unnatural and
1115     // inconsistent with the generic version - so we adjust the index
1116     if (start != -1)
1117         start --;
1118     return ListView_FindItem(GetHwnd(), (int) start, &findInfo);
1119 }
1120
1121 // Find an item whose data matches this data, starting from the item after 'start'
1122 // or the beginning if 'start' is -1.
1123 long wxListCtrl::FindItem(long start, long data)
1124 {
1125     LV_FINDINFO findInfo;
1126
1127     findInfo.flags = LVFI_PARAM;
1128     findInfo.lParam = data;
1129
1130     return ListView_FindItem(GetHwnd(), (int) start, & findInfo);
1131 }
1132
1133 // Find an item nearest this position in the specified direction, starting from
1134 // the item after 'start' or the beginning if 'start' is -1.
1135 long wxListCtrl::FindItem(long start, const wxPoint& pt, int direction)
1136 {
1137     LV_FINDINFO findInfo;
1138
1139     findInfo.flags = LVFI_NEARESTXY;
1140     findInfo.pt.x = pt.x;
1141     findInfo.pt.y = pt.y;
1142     findInfo.vkDirection = VK_RIGHT;
1143
1144     if ( direction == wxLIST_FIND_UP )
1145         findInfo.vkDirection = VK_UP;
1146     else if ( direction == wxLIST_FIND_DOWN )
1147         findInfo.vkDirection = VK_DOWN;
1148     else if ( direction == wxLIST_FIND_LEFT )
1149         findInfo.vkDirection = VK_LEFT;
1150     else if ( direction == wxLIST_FIND_RIGHT )
1151         findInfo.vkDirection = VK_RIGHT;
1152
1153     return ListView_FindItem(GetHwnd(), (int) start, & findInfo);
1154 }
1155
1156 // Determines which item (if any) is at the specified point,
1157 // giving details in 'flags' (see wxLIST_HITTEST_... flags above)
1158 long wxListCtrl::HitTest(const wxPoint& point, int& flags)
1159 {
1160     LV_HITTESTINFO hitTestInfo;
1161     hitTestInfo.pt.x = (int) point.x;
1162     hitTestInfo.pt.y = (int) point.y;
1163
1164     ListView_HitTest(GetHwnd(), & hitTestInfo);
1165
1166     flags = 0;
1167     if ( hitTestInfo.flags & LVHT_ABOVE )
1168         flags |= wxLIST_HITTEST_ABOVE;
1169     if ( hitTestInfo.flags & LVHT_BELOW )
1170         flags |= wxLIST_HITTEST_BELOW;
1171     if ( hitTestInfo.flags & LVHT_NOWHERE )
1172         flags |= wxLIST_HITTEST_NOWHERE;
1173     if ( hitTestInfo.flags & LVHT_ONITEMICON )
1174         flags |= wxLIST_HITTEST_ONITEMICON;
1175     if ( hitTestInfo.flags & LVHT_ONITEMLABEL )
1176         flags |= wxLIST_HITTEST_ONITEMLABEL;
1177     if ( hitTestInfo.flags & LVHT_ONITEMSTATEICON )
1178         flags |= wxLIST_HITTEST_ONITEMSTATEICON;
1179     if ( hitTestInfo.flags & LVHT_TOLEFT )
1180         flags |= wxLIST_HITTEST_TOLEFT;
1181     if ( hitTestInfo.flags & LVHT_TORIGHT )
1182         flags |= wxLIST_HITTEST_TORIGHT;
1183
1184     return (long) hitTestInfo.iItem;
1185 }
1186
1187 // Inserts an item, returning the index of the new item if successful,
1188 // -1 otherwise.
1189 long wxListCtrl::InsertItem(wxListItem& info)
1190 {
1191     wxASSERT_MSG( !IsVirtual(), _T("can't be used with virtual controls") );
1192
1193     LV_ITEM item;
1194     wxConvertToMSWListItem(this, info, item);
1195
1196     // check whether it has any custom attributes
1197     if ( info.HasAttributes() )
1198     {
1199
1200         wxListItemAttr *attr;
1201         attr = (wxListItemAttr*) m_attrs.Get(item.iItem);
1202
1203         if (attr == NULL)
1204
1205             m_attrs.Put(item.iItem, (wxObject *)new wxListItemAttr(*info.GetAttributes()));
1206
1207         else *attr = *info.GetAttributes();
1208
1209         m_hasAnyAttr = TRUE;
1210     }
1211
1212     return (long) ListView_InsertItem(GetHwnd(), & item);
1213 }
1214
1215 long wxListCtrl::InsertItem(long index, const wxString& label)
1216 {
1217     wxListItem info;
1218     info.m_text = label;
1219     info.m_mask = wxLIST_MASK_TEXT;
1220     info.m_itemId = index;
1221     return InsertItem(info);
1222 }
1223
1224 // Inserts an image item
1225 long wxListCtrl::InsertItem(long index, int imageIndex)
1226 {
1227     wxListItem info;
1228     info.m_image = imageIndex;
1229     info.m_mask = wxLIST_MASK_IMAGE;
1230     info.m_itemId = index;
1231     return InsertItem(info);
1232 }
1233
1234 // Inserts an image/string item
1235 long wxListCtrl::InsertItem(long index, const wxString& label, int imageIndex)
1236 {
1237     wxListItem info;
1238     info.m_image = imageIndex;
1239     info.m_text = label;
1240     info.m_mask = wxLIST_MASK_IMAGE | wxLIST_MASK_TEXT;
1241     info.m_itemId = index;
1242     return InsertItem(info);
1243 }
1244
1245 // For list view mode (only), inserts a column.
1246 long wxListCtrl::InsertColumn(long col, wxListItem& item)
1247 {
1248     LV_COLUMN lvCol;
1249     lvCol.mask = 0;
1250     lvCol.fmt = 0;
1251     lvCol.pszText = NULL;
1252
1253     if ( item.m_mask & wxLIST_MASK_TEXT )
1254     {
1255         lvCol.mask |= LVCF_TEXT;
1256         lvCol.pszText = WXSTRINGCAST item.m_text;
1257         lvCol.cchTextMax = 0; // Ignored
1258     }
1259     if ( item.m_mask & wxLIST_MASK_FORMAT )
1260     {
1261         lvCol.mask |= LVCF_FMT;
1262
1263         if ( item.m_format == wxLIST_FORMAT_LEFT )
1264             lvCol.fmt = LVCFMT_LEFT;
1265         if ( item.m_format == wxLIST_FORMAT_RIGHT )
1266             lvCol.fmt = LVCFMT_RIGHT;
1267         if ( item.m_format == wxLIST_FORMAT_CENTRE )
1268             lvCol.fmt = LVCFMT_CENTER;
1269     }
1270
1271     lvCol.mask |= LVCF_WIDTH;
1272     if ( item.m_mask & wxLIST_MASK_WIDTH )
1273     {
1274         if ( item.m_width == wxLIST_AUTOSIZE)
1275             lvCol.cx = LVSCW_AUTOSIZE;
1276         else if ( item.m_width == wxLIST_AUTOSIZE_USEHEADER)
1277             lvCol.cx = LVSCW_AUTOSIZE_USEHEADER;
1278         else
1279             lvCol.cx = item.m_width;
1280     }
1281     else
1282     {
1283         // always give some width to the new column: this one is compatible
1284         // with wxGTK
1285         lvCol.cx = 80;
1286     }
1287
1288     lvCol.mask |= LVCF_SUBITEM;
1289     lvCol.iSubItem = col;
1290
1291     bool success = ListView_InsertColumn(GetHwnd(), col, & lvCol) != -1;
1292     if ( success )
1293     {
1294         m_colCount++;
1295     }
1296     else
1297     {
1298         wxLogDebug(wxT("Failed to insert the column '%s' into listview!"),
1299                    lvCol.pszText);
1300     }
1301
1302     return success;
1303 }
1304
1305 long wxListCtrl::InsertColumn(long col,
1306                               const wxString& heading,
1307                               int format,
1308                               int width)
1309 {
1310     wxListItem item;
1311     item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT;
1312     item.m_text = heading;
1313     if ( width > -1 )
1314     {
1315         item.m_mask |= wxLIST_MASK_WIDTH;
1316         item.m_width = width;
1317     }
1318     item.m_format = format;
1319
1320     return InsertColumn(col, item);
1321 }
1322
1323 // Scrolls the list control. If in icon, small icon or report view mode,
1324 // x specifies the number of pixels to scroll. If in list view mode, x
1325 // specifies the number of columns to scroll.
1326 // If in icon, small icon or list view mode, y specifies the number of pixels
1327 // to scroll. If in report view mode, y specifies the number of lines to scroll.
1328 bool wxListCtrl::ScrollList(int dx, int dy)
1329 {
1330     return (ListView_Scroll(GetHwnd(), dx, dy) != 0);
1331 }
1332
1333 // Sort items.
1334
1335 // fn is a function which takes 3 long arguments: item1, item2, data.
1336 // item1 is the long data associated with a first item (NOT the index).
1337 // item2 is the long data associated with a second item (NOT the index).
1338 // data is the same value as passed to SortItems.
1339 // The return value is a negative number if the first item should precede the second
1340 // item, a positive number of the second item should precede the first,
1341 // or zero if the two items are equivalent.
1342
1343 // data is arbitrary data to be passed to the sort function.
1344 bool wxListCtrl::SortItems(wxListCtrlCompare fn, long data)
1345 {
1346     return (ListView_SortItems(GetHwnd(), (PFNLVCOMPARE) fn, data) != 0);
1347 }
1348
1349 // ----------------------------------------------------------------------------
1350 // message processing
1351 // ----------------------------------------------------------------------------
1352
1353 bool wxListCtrl::MSWCommand(WXUINT cmd, WXWORD id)
1354 {
1355     if (cmd == EN_UPDATE)
1356     {
1357         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
1358         event.SetEventObject( this );
1359         ProcessCommand(event);
1360         return TRUE;
1361     }
1362     else if (cmd == EN_KILLFOCUS)
1363     {
1364         wxCommandEvent event(wxEVT_KILL_FOCUS, id);
1365         event.SetEventObject( this );
1366         ProcessCommand(event);
1367         return TRUE;
1368     }
1369     else
1370         return FALSE;
1371 }
1372
1373 bool wxListCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
1374 {
1375     // prepare the event
1376     // -----------------
1377
1378     wxListEvent event(wxEVT_NULL, m_windowId);
1379     wxEventType eventType = wxEVT_NULL;
1380
1381     NMHDR *nmhdr = (NMHDR *)lParam;
1382
1383     // almost all messages use NM_LISTVIEW
1384     NM_LISTVIEW *nmLV = (NM_LISTVIEW *)nmhdr;
1385
1386     // this is true for almost all events
1387     event.m_item.m_data = nmLV->lParam;
1388
1389     switch ( nmhdr->code )
1390     {
1391         case LVN_BEGINRDRAG:
1392             eventType = wxEVT_COMMAND_LIST_BEGIN_RDRAG;
1393             // fall through
1394
1395         case LVN_BEGINDRAG:
1396             if ( eventType == wxEVT_NULL )
1397             {
1398                 eventType = wxEVT_COMMAND_LIST_BEGIN_DRAG;
1399             }
1400
1401             event.m_itemIndex = nmLV->iItem;
1402             event.m_pointDrag.x = nmLV->ptAction.x;
1403             event.m_pointDrag.y = nmLV->ptAction.y;
1404             break;
1405
1406         case LVN_BEGINLABELEDIT:
1407             {
1408                 eventType = wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT;
1409                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1410                 wxConvertFromMSWListItem(this, event.m_item, info->item, GetHwnd());
1411             }
1412             break;
1413
1414         case LVN_COLUMNCLICK:
1415             eventType = wxEVT_COMMAND_LIST_COL_CLICK;
1416             event.m_itemIndex = -1;
1417             event.m_col = nmLV->iSubItem;
1418             break;
1419
1420         case LVN_DELETEALLITEMS:
1421             eventType = wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS;
1422             event.m_itemIndex = -1;
1423
1424             FreeAllAttrs();
1425
1426             break;
1427
1428         case LVN_DELETEITEM:
1429             eventType = wxEVT_COMMAND_LIST_DELETE_ITEM;
1430             event.m_itemIndex = nmLV->iItem;
1431
1432             if ( m_hasAnyAttr )
1433             {
1434                 delete (wxListItemAttr *)m_attrs.Delete(nmLV->iItem);
1435             }
1436             break;
1437
1438         case LVN_ENDLABELEDIT:
1439             {
1440                 eventType = wxEVT_COMMAND_LIST_END_LABEL_EDIT;
1441                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1442                 wxConvertFromMSWListItem(this, event.m_item, info->item);
1443                 if ( info->item.pszText == NULL || info->item.iItem == -1 )
1444                     return FALSE;
1445             }
1446             break;
1447
1448         case LVN_SETDISPINFO:
1449             {
1450                 eventType = wxEVT_COMMAND_LIST_SET_INFO;
1451                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1452                 wxConvertFromMSWListItem(this, event.m_item, info->item, GetHwnd());
1453             }
1454             break;
1455
1456         case LVN_INSERTITEM:
1457             eventType = wxEVT_COMMAND_LIST_INSERT_ITEM;
1458             event.m_itemIndex = nmLV->iItem;
1459             break;
1460
1461         case LVN_ITEMCHANGED:
1462             // This needs to be sent to wxListCtrl as a rather more concrete
1463             // event. For now, just detect a selection or deselection.
1464             if ( (nmLV->uNewState & LVIS_SELECTED) && !(nmLV->uOldState & LVIS_SELECTED) )
1465             {
1466                 eventType = wxEVT_COMMAND_LIST_ITEM_SELECTED;
1467                 event.m_itemIndex = nmLV->iItem;
1468             }
1469             else if ( !(nmLV->uNewState & LVIS_SELECTED) && (nmLV->uOldState & LVIS_SELECTED) )
1470             {
1471                 eventType = wxEVT_COMMAND_LIST_ITEM_DESELECTED;
1472                 event.m_itemIndex = nmLV->iItem;
1473             }
1474             else
1475             {
1476                 return FALSE;
1477             }
1478             break;
1479
1480         case LVN_KEYDOWN:
1481             {
1482                 LV_KEYDOWN *info = (LV_KEYDOWN *)lParam;
1483                 WORD wVKey = info->wVKey;
1484
1485                 // get the current selection
1486                 long lItem = GetNextItem(-1,
1487                                          wxLIST_NEXT_ALL,
1488                                          wxLIST_STATE_SELECTED);
1489
1490                 // <Enter> or <Space> activate the selected item if any (but
1491                 // not with Shift and/or Ctrl as then they have a predefined
1492                 // meaning for the list view)
1493                 if ( lItem != -1 &&
1494                      (wVKey == VK_RETURN || wVKey == VK_SPACE) &&
1495                      !(wxIsShiftDown() || wxIsCtrlDown()) )
1496                 {
1497                     eventType = wxEVT_COMMAND_LIST_ITEM_ACTIVATED;
1498                     event.m_itemIndex = lItem;
1499                 }
1500                 else
1501                 {
1502                     eventType = wxEVT_COMMAND_LIST_KEY_DOWN;
1503                     event.m_code = wxCharCodeMSWToWX(wVKey);
1504                 }
1505
1506                 if ( lItem != -1 )
1507                 {
1508                     // fill the other fields too
1509                     event.m_item.m_text = GetItemText(lItem);
1510                     event.m_item.m_data = GetItemData(lItem);
1511                 }
1512             }
1513             break;
1514
1515         case NM_DBLCLK:
1516             // if the user processes it in wxEVT_COMMAND_LEFT_CLICK(), don't do
1517             // anything else
1518             if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
1519             {
1520                 return TRUE;
1521             }
1522
1523             // else translate it into wxEVT_COMMAND_LIST_ITEM_ACTIVATED event
1524             // if it happened on an item (and not on empty place)
1525             if ( nmLV->iItem == -1 )
1526             {
1527                 // not on item
1528                 return FALSE;
1529             }
1530
1531             eventType = wxEVT_COMMAND_LIST_ITEM_ACTIVATED;
1532             event.m_itemIndex = nmLV->iItem;
1533             event.m_item.m_text = GetItemText(nmLV->iItem);
1534             event.m_item.m_data = GetItemData(nmLV->iItem);
1535             break;
1536
1537         case NM_RCLICK:
1538             /* TECH NOTE: NM_RCLICK isn't really good enough here. We want to
1539                subclass and check for the actual WM_RBUTTONDOWN message,
1540                because NM_RCLICK waits for the WM_RBUTTONUP message as well
1541                before firing off. We want to have notify events for both down
1542                -and- up. */
1543             {
1544                 // if the user processes it in wxEVT_COMMAND_RIGHT_CLICK(),
1545                 // don't do anything else
1546                 if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
1547                 {
1548                     return TRUE;
1549                 }
1550
1551                 // else translate it into wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK event
1552                 LV_HITTESTINFO lvhti;
1553                 wxZeroMemory(lvhti);
1554
1555                 ::GetCursorPos(&(lvhti.pt));
1556                 ::ScreenToClient(GetHwnd(),&(lvhti.pt));
1557                 if ( ListView_HitTest(GetHwnd(),&lvhti) != -1 )
1558                 {
1559                     if ( lvhti.flags & LVHT_ONITEM )
1560                     {
1561                         eventType = wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK;
1562                         event.m_itemIndex = lvhti.iItem;
1563                         event.m_pointDrag.x = lvhti.pt.x;
1564                         event.m_pointDrag.y = lvhti.pt.y;
1565                     }
1566                 }
1567             }
1568             break;
1569
1570 #if 0
1571         case NM_MCLICK: // ***** THERE IS NO NM_MCLICK. Subclass anyone? ******
1572             {
1573                 // if the user processes it in wxEVT_COMMAND_MIDDLE_CLICK(), don't do
1574                 // anything else
1575                 if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
1576                 {
1577                     return TRUE;
1578                 }
1579
1580                 // else translate it into wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK event
1581                 eventType = wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK;
1582                 NMITEMACTIVATE* hdr = (NMITEMACTIVATE*)lParam;
1583                 event.m_itemIndex = hdr->iItem;
1584             }
1585             break;
1586 #endif // 0
1587
1588 #if defined(_WIN32_IE) && _WIN32_IE >= 0x300
1589         case NM_CUSTOMDRAW:
1590             {
1591                 LPNMLVCUSTOMDRAW lplvcd = (LPNMLVCUSTOMDRAW)lParam;
1592                 NMCUSTOMDRAW& nmcd = lplvcd->nmcd;
1593                 switch( nmcd.dwDrawStage )
1594                 {
1595                     case CDDS_PREPAINT:
1596                         // if we've got any items with non standard attributes,
1597                         // notify us before painting each item
1598                         *result = m_hasAnyAttr ? CDRF_NOTIFYITEMDRAW
1599                                                : CDRF_DODEFAULT;
1600                         return TRUE;
1601
1602                     case CDDS_ITEMPREPAINT:
1603                         {
1604                             wxListItemAttr *attr =
1605                                 (wxListItemAttr *)m_attrs.Get(nmcd.dwItemSpec);
1606
1607                             if ( !attr )
1608                             {
1609                                 // nothing to do for this item
1610                                 return CDRF_DODEFAULT;
1611                             }
1612
1613                             HFONT hFont;
1614                             wxColour colText, colBack;
1615                             if ( attr->HasFont() )
1616                             {
1617                                 wxFont font = attr->GetFont();
1618                                 hFont = (HFONT)font.GetResourceHandle();
1619                             }
1620                             else
1621                             {
1622                                 hFont = 0;
1623                             }
1624
1625                             if ( attr->HasTextColour() )
1626                             {
1627                                 colText = attr->GetTextColour();
1628                             }
1629                             else
1630                             {
1631                                 colText = GetTextColour();
1632                             }
1633
1634                             if ( attr->HasBackgroundColour() )
1635                             {
1636                                 colBack = attr->GetBackgroundColour();
1637                             }
1638                             else
1639                             {
1640                                 colBack = GetBackgroundColour();
1641                             }
1642
1643                             // note that if we wanted to set colours for
1644                             // individual columns (subitems), we would have
1645                             // returned CDRF_NOTIFYSUBITEMREDRAW from here
1646                             if ( hFont )
1647                             {
1648                                 ::SelectObject(nmcd.hdc, hFont);
1649
1650                                 *result = CDRF_NEWFONT;
1651                             }
1652                             else
1653                             {
1654                                 *result = CDRF_DODEFAULT;
1655                             }
1656
1657                             lplvcd->clrText = wxColourToRGB(colText);
1658                             lplvcd->clrTextBk = wxColourToRGB(colBack);
1659
1660                             return TRUE;
1661                         }
1662
1663                     default:
1664                         *result = CDRF_DODEFAULT;
1665                         return TRUE;
1666                 }
1667             }
1668 //            break; // can never be reached
1669 #endif // _WIN32_IE >= 0x300
1670
1671         case LVN_GETDISPINFO:
1672             if ( IsVirtual() )
1673             {
1674                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1675
1676                 LV_ITEM& lvi = info->item;
1677                 long item = lvi.iItem;
1678
1679                 if ( lvi.mask & LVIF_TEXT )
1680                 {
1681                     wxString text = OnGetItemText(item, lvi.iSubItem);
1682                     wxStrncpy(lvi.pszText, text, lvi.cchTextMax);
1683                 }
1684
1685                 if ( lvi.mask & LVIF_IMAGE )
1686                 {
1687                     lvi.iImage = OnGetItemImage(item);
1688                 }
1689
1690                 // a little dose of healthy paranoia: as we never use
1691                 // LVM_SETCALLBACKMASK we're not supposed to get these ones
1692                 wxASSERT_MSG( !(lvi.mask & LVIF_STATE),
1693                               _T("we don't support state callbacks yet!") );
1694
1695                 return TRUE;
1696             }
1697             // fall through
1698
1699         default:
1700             return wxControl::MSWOnNotify(idCtrl, lParam, result);
1701     }
1702
1703     // process the event
1704     // -----------------
1705
1706     event.SetEventObject( this );
1707     event.SetEventType(eventType);
1708
1709     if ( !GetEventHandler()->ProcessEvent(event) )
1710         return FALSE;
1711
1712     // post processing
1713     // ---------------
1714
1715     switch ( nmhdr->code )
1716     {
1717         case LVN_DELETEALLITEMS:
1718             // always return TRUE to suppress all additional LVN_DELETEITEM
1719             // notifications - this makes deleting all items from a list ctrl
1720             // much faster
1721             *result = TRUE;
1722
1723             return TRUE;
1724
1725         case LVN_ENDLABELEDIT:
1726             {
1727                 *result = event.IsAllowed();
1728                 return TRUE;
1729             }
1730     }
1731
1732     *result = !event.IsAllowed();
1733
1734     return TRUE;
1735 }
1736
1737 // Necessary for drawing hrules and vrules, if specified
1738 void wxListCtrl::OnPaint(wxPaintEvent& event)
1739 {
1740     wxPaintDC dc(this);
1741
1742     wxControl::OnPaint(event);
1743
1744     // Reset the device origin since it may have been set
1745     dc.SetDeviceOrigin(0, 0);
1746
1747     bool drawHRules = ((GetWindowStyle() & wxLC_HRULES) != 0);
1748     bool drawVRules = ((GetWindowStyle() & wxLC_VRULES) != 0);
1749
1750     if (!drawHRules && !drawVRules)
1751         return;
1752     if ((GetWindowStyle() & wxLC_REPORT) == 0)
1753         return;
1754
1755     wxPen pen(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DLIGHT), 1, wxSOLID);
1756     dc.SetPen(pen);
1757     dc.SetBrush(* wxTRANSPARENT_BRUSH);
1758
1759     wxSize clientSize = GetClientSize();
1760     wxRect itemRect;
1761     int cy=0;
1762
1763     int itemCount = GetItemCount();
1764     int i;
1765     for (i = 0; i < itemCount; i++)
1766     {
1767         if (GetItemRect(i, itemRect))
1768         {
1769             cy = itemRect.GetTop();
1770             if (i != 0) // Don't draw the first one
1771             {
1772                 dc.DrawLine(0, cy, clientSize.x, cy);
1773             }
1774             // Draw last line
1775             if (i == (GetItemCount() - 1))
1776             {
1777                 cy = itemRect.GetBottom();
1778                 dc.DrawLine(0, cy, clientSize.x, cy);
1779             }
1780         }
1781     }
1782     i = (GetItemCount() - 1);
1783     if (drawVRules && (i > -1))
1784     {
1785         wxRect firstItemRect;
1786         GetItemRect(0, firstItemRect);
1787
1788         if (GetItemRect(i, itemRect))
1789         {
1790             int col;
1791             int x = itemRect.GetX();
1792             for (col = 0; col < GetColumnCount(); col++)
1793             {
1794                 int colWidth = GetColumnWidth(col);
1795                 x += colWidth ;
1796                 dc.DrawLine(x, firstItemRect.GetY() - 2, x, itemRect.GetBottom());
1797             }
1798         }
1799     }
1800 }
1801
1802 // ----------------------------------------------------------------------------
1803 // virtual list controls
1804 // ----------------------------------------------------------------------------
1805
1806 wxString wxListCtrl::OnGetItemText(long item, long col) const
1807 {
1808     // this is a pure virtual function, in fact - which is not really pure
1809     // because the controls which are not virtual don't need to implement it
1810     wxFAIL_MSG( _T("not supposed to be called") );
1811
1812     return wxEmptyString;
1813 }
1814
1815 int wxListCtrl::OnGetItemImage(long item) const
1816 {
1817     // same as above
1818     wxFAIL_MSG( _T("not supposed to be called") );
1819
1820     return -1;
1821 }
1822
1823 void wxListCtrl::SetItemCount(long count)
1824 {
1825     wxASSERT_MSG( IsVirtual(), _T("this is for virtual controls only") );
1826
1827     if ( !::SendMessage(GetHwnd(), LVM_SETITEMCOUNT, (WPARAM)count, 0) )
1828     {
1829         wxLogLastError(_T("ListView_SetItemCount"));
1830     }
1831 }
1832
1833 // ----------------------------------------------------------------------------
1834 // wxListItem
1835 // ----------------------------------------------------------------------------
1836
1837 // List item structure
1838 wxListItem::wxListItem()
1839 {
1840     m_mask = 0;
1841     m_itemId = 0;
1842     m_col = 0;
1843     m_state = 0;
1844     m_stateMask = 0;
1845     m_image = 0;
1846     m_data = 0;
1847
1848     m_format = wxLIST_FORMAT_CENTRE;
1849     m_width = 0;
1850
1851     m_attr = NULL;
1852 }
1853
1854 void wxListItem::Clear()
1855 {
1856     m_mask = 0;
1857     m_itemId = 0;
1858     m_col = 0;
1859     m_state = 0;
1860     m_stateMask = 0;
1861     m_image = 0;
1862     m_data = 0;
1863     m_format = wxLIST_FORMAT_CENTRE;
1864     m_width = 0;
1865     m_text = wxEmptyString;
1866
1867     if (m_attr) delete m_attr;
1868     m_attr = NULL;
1869 }
1870
1871 void wxListItem::ClearAttributes()
1872 {
1873     if (m_attr) delete m_attr;
1874     m_attr = NULL;
1875 }
1876
1877 static void wxConvertFromMSWListItem(const wxListCtrl *WXUNUSED(ctrl), wxListItem& info, LV_ITEM& lvItem, HWND getFullInfo)
1878 {
1879     info.m_data = lvItem.lParam;
1880     info.m_mask = 0;
1881     info.m_state = 0;
1882     info.m_stateMask = 0;
1883     info.m_itemId = lvItem.iItem;
1884
1885     long oldMask = lvItem.mask;
1886
1887     bool needText = FALSE;
1888     if (getFullInfo != 0)
1889     {
1890         if ( lvItem.mask & LVIF_TEXT )
1891             needText = FALSE;
1892         else
1893             needText = TRUE;
1894
1895         if ( needText )
1896         {
1897             lvItem.pszText = new wxChar[513];
1898             lvItem.cchTextMax = 512;
1899         }
1900         //    lvItem.mask |= TVIF_HANDLE | TVIF_STATE | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN | TVIF_PARAM;
1901         lvItem.mask |= LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
1902         ::SendMessage(getFullInfo, LVM_GETITEM, 0, (LPARAM)& lvItem);
1903     }
1904
1905     if ( lvItem.mask & LVIF_STATE )
1906     {
1907         info.m_mask |= wxLIST_MASK_STATE;
1908
1909         if ( lvItem.stateMask & LVIS_CUT)
1910         {
1911             info.m_stateMask |= wxLIST_STATE_CUT;
1912             if ( lvItem.state & LVIS_CUT )
1913                 info.m_state |= wxLIST_STATE_CUT;
1914         }
1915         if ( lvItem.stateMask & LVIS_DROPHILITED)
1916         {
1917             info.m_stateMask |= wxLIST_STATE_DROPHILITED;
1918             if ( lvItem.state & LVIS_DROPHILITED )
1919                 info.m_state |= wxLIST_STATE_DROPHILITED;
1920         }
1921         if ( lvItem.stateMask & LVIS_FOCUSED)
1922         {
1923             info.m_stateMask |= wxLIST_STATE_FOCUSED;
1924             if ( lvItem.state & LVIS_FOCUSED )
1925                 info.m_state |= wxLIST_STATE_FOCUSED;
1926         }
1927         if ( lvItem.stateMask & LVIS_SELECTED)
1928         {
1929             info.m_stateMask |= wxLIST_STATE_SELECTED;
1930             if ( lvItem.state & LVIS_SELECTED )
1931                 info.m_state |= wxLIST_STATE_SELECTED;
1932         }
1933     }
1934
1935     if ( lvItem.mask & LVIF_TEXT )
1936     {
1937         info.m_mask |= wxLIST_MASK_TEXT;
1938         info.m_text = lvItem.pszText;
1939     }
1940     if ( lvItem.mask & LVIF_IMAGE )
1941     {
1942         info.m_mask |= wxLIST_MASK_IMAGE;
1943         info.m_image = lvItem.iImage;
1944     }
1945     if ( lvItem.mask & LVIF_PARAM )
1946         info.m_mask |= wxLIST_MASK_DATA;
1947     if ( lvItem.mask & LVIF_DI_SETITEM )
1948         info.m_mask |= wxLIST_SET_ITEM;
1949     info.m_col = lvItem.iSubItem;
1950
1951     if (needText)
1952     {
1953         if (lvItem.pszText)
1954             delete[] lvItem.pszText;
1955     }
1956     lvItem.mask = oldMask;
1957 }
1958
1959 static void wxConvertToMSWListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& lvItem)
1960 {
1961     lvItem.iItem = (int) info.m_itemId;
1962
1963     lvItem.iImage = info.m_image;
1964     lvItem.lParam = info.m_data;
1965     lvItem.stateMask = 0;
1966     lvItem.state = 0;
1967     lvItem.mask = 0;
1968     lvItem.iSubItem = info.m_col;
1969
1970     if (info.m_mask & wxLIST_MASK_STATE)
1971     {
1972         lvItem.mask |= LVIF_STATE;
1973         if (info.m_stateMask & wxLIST_STATE_CUT)
1974         {
1975             lvItem.stateMask |= LVIS_CUT;
1976             if (info.m_state & wxLIST_STATE_CUT)
1977                 lvItem.state |= LVIS_CUT;
1978         }
1979         if (info.m_stateMask & wxLIST_STATE_DROPHILITED)
1980         {
1981             lvItem.stateMask |= LVIS_DROPHILITED;
1982             if (info.m_state & wxLIST_STATE_DROPHILITED)
1983                 lvItem.state |= LVIS_DROPHILITED;
1984         }
1985         if (info.m_stateMask & wxLIST_STATE_FOCUSED)
1986         {
1987             lvItem.stateMask |= LVIS_FOCUSED;
1988             if (info.m_state & wxLIST_STATE_FOCUSED)
1989                 lvItem.state |= LVIS_FOCUSED;
1990         }
1991         if (info.m_stateMask & wxLIST_STATE_SELECTED)
1992         {
1993             lvItem.stateMask |= LVIS_SELECTED;
1994             if (info.m_state & wxLIST_STATE_SELECTED)
1995                 lvItem.state |= LVIS_SELECTED;
1996         }
1997     }
1998
1999     if (info.m_mask & wxLIST_MASK_TEXT)
2000     {
2001         lvItem.mask |= LVIF_TEXT;
2002         if ( ctrl->GetWindowStyleFlag() & wxLC_USER_TEXT )
2003         {
2004             lvItem.pszText = LPSTR_TEXTCALLBACK;
2005         }
2006         else
2007         {
2008             // pszText is not const, hence the cast
2009             lvItem.pszText = (wxChar *)info.m_text.c_str();
2010             if ( lvItem.pszText )
2011                 lvItem.cchTextMax = info.m_text.Length();
2012             else
2013                 lvItem.cchTextMax = 0;
2014         }
2015     }
2016     if (info.m_mask & wxLIST_MASK_IMAGE)
2017         lvItem.mask |= LVIF_IMAGE;
2018     if (info.m_mask & wxLIST_MASK_DATA)
2019         lvItem.mask |= LVIF_PARAM;
2020 }
2021
2022 // ----------------------------------------------------------------------------
2023 // List event
2024 // ----------------------------------------------------------------------------
2025
2026 IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxNotifyEvent)
2027
2028 wxListEvent::wxListEvent(wxEventType commandType, int id)
2029            : wxNotifyEvent(commandType, id)
2030 {
2031     m_code = 0;
2032     m_itemIndex = 0;
2033     m_oldItemIndex = 0;
2034     m_col = 0;
2035     m_cancelled = FALSE;
2036 }
2037
2038 #endif // wxUSE_LISTCTRL