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 #ifdef __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     // Apparently, no such style (documentation wrong?)
 428     /*
 429        if ( style & wxLC_BUTTON )
 430        wstyle |= LVS_BUTTON;
 431      */
 432
 433     if ( style & wxLC_NO_SORT_HEADER )
 434         wstyle |= LVS_NOSORTHEADER;
 435
 436     if ( style & wxLC_NO_HEADER )
 437         wstyle |= LVS_NOCOLUMNHEADER;
 438
 439     if ( style & wxLC_EDIT_LABELS )
 440         wstyle |= LVS_EDITLABELS;
 441
 442     if ( style & wxLC_SINGLE_SEL )
 443         wstyle |= LVS_SINGLESEL;
 444
 445     if ( style & wxLC_SORT_ASCENDING )
 446     {
 447         if ( oldStyle & LVS_SORTDESCENDING )
 448             oldStyle -= LVS_SORTDESCENDING;
 449         wstyle |= LVS_SORTASCENDING;
 450     }
 451
 452     if ( style & wxLC_SORT_DESCENDING )
 453     {
 454         if ( oldStyle & LVS_SORTASCENDING )
 455             oldStyle -= LVS_SORTASCENDING;
 456         wstyle |= LVS_SORTDESCENDING;
 457     }
 458
 459     return wstyle;
 460 }
 461
 462 // ----------------------------------------------------------------------------
 463 // accessors
 464 // ----------------------------------------------------------------------------
 465
 466 // Sets the foreground, i.e. text, colour
 467 bool wxListCtrl::SetForegroundColour(const wxColour& col)
 468 {
 469     if ( !wxWindow::SetForegroundColour(col) )
 470         return FALSE;
 471
 472     ListView_SetTextColor(GetHwnd(), wxColourToRGB(col));
 473
 474     return TRUE;
 475 }
 476
 477 // Sets the background colour
 478 bool wxListCtrl::SetBackgroundColour(const wxColour& col)
 479 {
 480     if ( !wxWindow::SetBackgroundColour(col) )
 481         return FALSE;
 482
 483     // we set the same colour for both the "empty" background and the items
 484     // background
 485     COLORREF color = wxColourToRGB(col);
 486     ListView_SetBkColor(GetHwnd(), color);
 487     ListView_SetTextBkColor(GetHwnd(), color);
 488
 489     return TRUE;
 490 }
 491
 492 // Gets information about this column
 493 bool wxListCtrl::GetColumn(int col, wxListItem& item) const
 494 {
 495     LV_COLUMN lvCol;
 496     lvCol.mask = 0;
 497     lvCol.fmt = 0;
 498     lvCol.pszText = NULL;
 499
 500     if ( item.m_mask & wxLIST_MASK_TEXT )
 501     {
 502         lvCol.mask |= LVCF_TEXT;
 503         lvCol.pszText = new wxChar[513];
 504         lvCol.cchTextMax = 512;
 505     }
 506
 507     bool success = (ListView_GetColumn(GetHwnd(), col, & lvCol) != 0);
 508
 509     //  item.m_subItem = lvCol.iSubItem;
 510     item.m_width = lvCol.cx;
 511
 512     if ( (item.m_mask & wxLIST_MASK_TEXT) && lvCol.pszText )
 513     {
 514         item.m_text = lvCol.pszText;
 515         delete[] lvCol.pszText;
 516     }
 517
 518     if ( item.m_mask & wxLIST_MASK_FORMAT )
 519     {
 520         if (lvCol.fmt == LVCFMT_LEFT)
 521             item.m_format = wxLIST_FORMAT_LEFT;
 522         else if (lvCol.fmt == LVCFMT_RIGHT)
 523             item.m_format = wxLIST_FORMAT_RIGHT;
 524         else if (lvCol.fmt == LVCFMT_CENTER)
 525             item.m_format = wxLIST_FORMAT_CENTRE;
 526     }
 527
 528     return success;
 529 }
 530
 531 // Sets information about this column
 532 bool wxListCtrl::SetColumn(int col, wxListItem& item)
 533 {
 534     LV_COLUMN lvCol;
 535     lvCol.mask = 0;
 536     lvCol.fmt = 0;
 537     lvCol.pszText = NULL;
 538
 539     if ( item.m_mask & wxLIST_MASK_TEXT )
 540     {
 541         lvCol.mask |= LVCF_TEXT;
 542         lvCol.pszText = WXSTRINGCAST item.m_text;
 543         lvCol.cchTextMax = 0; // Ignored
 544     }
 545     if ( item.m_mask & wxLIST_MASK_FORMAT )
 546     {
 547         lvCol.mask |= LVCF_FMT;
 548
 549         if ( item.m_format == wxLIST_FORMAT_LEFT )
 550             lvCol.fmt = LVCFMT_LEFT;
 551         if ( item.m_format == wxLIST_FORMAT_RIGHT )
 552             lvCol.fmt = LVCFMT_RIGHT;
 553         if ( item.m_format == wxLIST_FORMAT_CENTRE )
 554             lvCol.fmt = LVCFMT_CENTER;
 555     }
 556
 557     if ( item.m_mask & wxLIST_MASK_WIDTH )
 558     {
 559         lvCol.mask |= LVCF_WIDTH;
 560         lvCol.cx = item.m_width;
 561
 562         if ( lvCol.cx == wxLIST_AUTOSIZE)
 563             lvCol.cx = LVSCW_AUTOSIZE;
 564         else if ( lvCol.cx == wxLIST_AUTOSIZE_USEHEADER)
 565             lvCol.cx = LVSCW_AUTOSIZE_USEHEADER;
 566     }
 567     lvCol.mask |= LVCF_SUBITEM;
 568     lvCol.iSubItem = col;
 569     return (ListView_SetColumn(GetHwnd(), col, & lvCol) != 0);
 570 }
 571
 572 // Gets the column width
 573 int wxListCtrl::GetColumnWidth(int col) const
 574 {
 575     return ListView_GetColumnWidth(GetHwnd(), col);
 576 }
 577
 578 // Sets the column width
 579 bool wxListCtrl::SetColumnWidth(int col, int width)
 580 {
 581     int col2 = col;
 582     if ( m_windowStyle & wxLC_LIST )
 583         col2 = -1;
 584
 585     int width2 = width;
 586     if ( width2 == wxLIST_AUTOSIZE)
 587         width2 = LVSCW_AUTOSIZE;
 588     else if ( width2 == wxLIST_AUTOSIZE_USEHEADER)
 589         width2 = LVSCW_AUTOSIZE_USEHEADER;
 590
 591     return (ListView_SetColumnWidth(GetHwnd(), col2, width2) != 0);
 592 }
 593
 594 // Gets the number of items that can fit vertically in the
 595 // visible area of the list control (list or report view)
 596 // or the total number of items in the list control (icon
 597 // or small icon view)
 598 int wxListCtrl::GetCountPerPage() const
 599 {
 600     return ListView_GetCountPerPage(GetHwnd());
 601 }
 602
 603 // Gets the edit control for editing labels.
 604 wxTextCtrl* wxListCtrl::GetEditControl() const
 605 {
 606     return m_textCtrl;
 607 }
 608
 609 // Gets information about the item
 610 bool wxListCtrl::GetItem(wxListItem& info) const
 611 {
 612     LV_ITEM lvItem;
 613     wxZeroMemory(lvItem);
 614
 615     lvItem.iItem = info.m_itemId;
 616     lvItem.iSubItem = info.m_col;
 617
 618     if ( info.m_mask & wxLIST_MASK_TEXT )
 619     {
 620         lvItem.mask |= LVIF_TEXT;
 621         lvItem.pszText = new wxChar[513];
 622         lvItem.cchTextMax = 512;
 623     }
 624     else
 625     {
 626         lvItem.pszText = NULL;
 627     }
 628
 629     if (info.m_mask & wxLIST_MASK_DATA)
 630         lvItem.mask |= LVIF_PARAM;
 631
 632     if (info.m_mask & wxLIST_MASK_IMAGE)
 633         lvItem.mask |= LVIF_IMAGE;
 634
 635     if ( info.m_mask & wxLIST_MASK_STATE )
 636     {
 637         lvItem.mask |= LVIF_STATE;
 638         // the other bits are hardly interesting anyhow
 639         lvItem.stateMask = LVIS_SELECTED | LVIS_FOCUSED;
 640     }
 641
 642     bool success = ListView_GetItem((HWND)GetHWND(), &lvItem) != 0;
 643     if ( !success )
 644     {
 645         wxLogError(_("Couldn't retrieve information about list control item %d."),
 646                 lvItem.iItem);
 647     }
 648     else
 649     {
 650         wxConvertFromMSWListItem(this, info, lvItem);
 651     }
 652
 653     if (lvItem.pszText)
 654         delete[] lvItem.pszText;
 655
 656     return success;
 657 }
 658
 659 // Sets information about the item
 660 bool wxListCtrl::SetItem(wxListItem& info)
 661 {
 662     LV_ITEM item;
 663     wxConvertToMSWListItem(this, info, item);
 664
 665     item.cchTextMax = 0;
 666     if ( !ListView_SetItem(GetHwnd(), &item) )
 667     {
 668         wxLogDebug(_T("ListView_SetItem() failed"));
 669
 670         return FALSE;
 671     }
 672
 673     // we need to update the item immediately to show the new image
 674     bool updateNow = (info.m_mask & wxLIST_MASK_IMAGE) != 0;
 675
 676     // check whether it has any custom attributes
 677     if ( info.HasAttributes() )
 678     {
 679         wxListItemAttr *attr = (wxListItemAttr *)m_attrs.Get(item.iItem);
 680
 681         if ( attr == NULL )
 682             m_attrs.Put(item.iItem, (wxObject *)new wxListItemAttr(*info.GetAttributes()));
 683         else
 684             *attr = *info.GetAttributes();
 685
 686         m_hasAnyAttr = TRUE;
 687
 688         // if the colour has changed, we must redraw the item
 689         updateNow = TRUE;
 690     }
 691
 692     if ( updateNow )
 693     {
 694         // we need this to make the change visible right now
 695         ListView_Update(GetHwnd(), item.iItem);
 696     }
 697
 698     return TRUE;
 699 }
 700
 701 long wxListCtrl::SetItem(long index, int col, const wxString& label, int imageId)
 702 {
 703     wxListItem info;
 704     info.m_text = label;
 705     info.m_mask = wxLIST_MASK_TEXT;
 706     info.m_itemId = index;
 707     info.m_col = col;
 708     if ( imageId > -1 )
 709     {
 710         info.m_image = imageId;
 711         info.m_mask |= wxLIST_MASK_IMAGE;
 712     }
 713     return SetItem(info);
 714 }
 715
 716
 717 // Gets the item state
 718 int wxListCtrl::GetItemState(long item, long stateMask) const
 719 {
 720     wxListItem info;
 721
 722     info.m_mask = wxLIST_MASK_STATE;
 723     info.m_stateMask = stateMask;
 724     info.m_itemId = item;
 725
 726     if (!GetItem(info))
 727         return 0;
 728
 729     return info.m_state;
 730 }
 731
 732 // Sets the item state
 733 bool wxListCtrl::SetItemState(long item, long state, long stateMask)
 734 {
 735     wxListItem info;
 736
 737     info.m_mask = wxLIST_MASK_STATE;
 738     info.m_state = state;
 739     info.m_stateMask = stateMask;
 740     info.m_itemId = item;
 741
 742     return SetItem(info);
 743 }
 744
 745 // Sets the item image
 746 bool wxListCtrl::SetItemImage(long item, int image, int WXUNUSED(selImage))
 747 {
 748     wxListItem info;
 749
 750     info.m_mask = wxLIST_MASK_IMAGE;
 751     info.m_image = image;
 752     info.m_itemId = item;
 753
 754     return SetItem(info);
 755 }
 756
 757 // Gets the item text
 758 wxString wxListCtrl::GetItemText(long item) const
 759 {
 760     wxListItem info;
 761
 762     info.m_mask = wxLIST_MASK_TEXT;
 763     info.m_itemId = item;
 764
 765     if (!GetItem(info))
 766         return wxString("");
 767     return info.m_text;
 768 }
 769
 770 // Sets the item text
 771 void wxListCtrl::SetItemText(long item, const wxString& str)
 772 {
 773     wxListItem info;
 774
 775     info.m_mask = wxLIST_MASK_TEXT;
 776     info.m_itemId = item;
 777     info.m_text = str;
 778
 779     SetItem(info);
 780 }
 781
 782 // Gets the item data
 783 long wxListCtrl::GetItemData(long item) const
 784 {
 785     wxListItem info;
 786
 787     info.m_mask = wxLIST_MASK_DATA;
 788     info.m_itemId = item;
 789
 790     if (!GetItem(info))
 791         return 0;
 792     return info.m_data;
 793 }
 794
 795 // Sets the item data
 796 bool wxListCtrl::SetItemData(long item, long data)
 797 {
 798     wxListItem info;
 799
 800     info.m_mask = wxLIST_MASK_DATA;
 801     info.m_itemId = item;
 802     info.m_data = data;
 803
 804     return SetItem(info);
 805 }
 806
 807 // Gets the item rectangle
 808 bool wxListCtrl::GetItemRect(long item, wxRect& rect, int code) const
 809 {
 810     RECT rect2;
 811
 812     int code2 = LVIR_BOUNDS;
 813     if ( code == wxLIST_RECT_BOUNDS )
 814         code2 = LVIR_BOUNDS;
 815     else if ( code == wxLIST_RECT_ICON )
 816         code2 = LVIR_ICON;
 817     else if ( code == wxLIST_RECT_LABEL )
 818         code2 = LVIR_LABEL;
 819
 820 #ifdef __WXWINE__
 821     bool success = (ListView_GetItemRect(GetHwnd(), (int) item, &rect2 ) != 0);
 822 #else
 823     bool success = (ListView_GetItemRect(GetHwnd(), (int) item, &rect2, code2) != 0);
 824 #endif
 825
 826     rect.x = rect2.left;
 827     rect.y = rect2.top;
 828     rect.width = rect2.right - rect2.left;
 829     rect.height = rect2.bottom - rect2.top;
 830     return success;
 831 }
 832
 833 // Gets the item position
 834 bool wxListCtrl::GetItemPosition(long item, wxPoint& pos) const
 835 {
 836     POINT pt;
 837
 838     bool success = (ListView_GetItemPosition(GetHwnd(), (int) item, &pt) != 0);
 839
 840     pos.x = pt.x; pos.y = pt.y;
 841     return success;
 842 }
 843
 844 // Sets the item position.
 845 bool wxListCtrl::SetItemPosition(long item, const wxPoint& pos)
 846 {
 847     return (ListView_SetItemPosition(GetHwnd(), (int) item, pos.x, pos.y) != 0);
 848 }
 849
 850 // Gets the number of items in the list control
 851 int wxListCtrl::GetItemCount() const
 852 {
 853     return ListView_GetItemCount(GetHwnd());
 854 }
 855
 856 // Retrieves the spacing between icons in pixels.
 857 // If small is TRUE, gets the spacing for the small icon
 858 // view, otherwise the large icon view.
 859 int wxListCtrl::GetItemSpacing(bool isSmall) const
 860 {
 861     return ListView_GetItemSpacing(GetHwnd(), (BOOL) isSmall);
 862 }
 863
 864 // Gets the number of selected items in the list control
 865 int wxListCtrl::GetSelectedItemCount() const
 866 {
 867     return ListView_GetSelectedCount(GetHwnd());
 868 }
 869
 870 // Gets the text colour of the listview
 871 wxColour wxListCtrl::GetTextColour() const
 872 {
 873     COLORREF ref = ListView_GetTextColor(GetHwnd());
 874     wxColour col(GetRValue(ref), GetGValue(ref), GetBValue(ref));
 875     return col;
 876 }
 877
 878 // Sets the text colour of the listview
 879 void wxListCtrl::SetTextColour(const wxColour& col)
 880 {
 881     ListView_SetTextColor(GetHwnd(), PALETTERGB(col.Red(), col.Green(), col.Blue()));
 882 }
 883
 884 // Gets the index of the topmost visible item when in
 885 // list or report view
 886 long wxListCtrl::GetTopItem() const
 887 {
 888     return (long) ListView_GetTopIndex(GetHwnd());
 889 }
 890
 891 // Searches for an item, starting from 'item'.
 892 // 'geometry' is one of
 893 // wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT.
 894 // 'state' is a state bit flag, one or more of
 895 // wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT.
 896 // item can be -1 to find the first item that matches the
 897 // specified flags.
 898 // Returns the item or -1 if unsuccessful.
 899 long wxListCtrl::GetNextItem(long item, int geom, int state) const
 900 {
 901     long flags = 0;
 902
 903     if ( geom == wxLIST_NEXT_ABOVE )
 904         flags |= LVNI_ABOVE;
 905     if ( geom == wxLIST_NEXT_ALL )
 906         flags |= LVNI_ALL;
 907     if ( geom == wxLIST_NEXT_BELOW )
 908         flags |= LVNI_BELOW;
 909     if ( geom == wxLIST_NEXT_LEFT )
 910         flags |= LVNI_TOLEFT;
 911     if ( geom == wxLIST_NEXT_RIGHT )
 912         flags |= LVNI_TORIGHT;
 913
 914     if ( state & wxLIST_STATE_CUT )
 915         flags |= LVNI_CUT;
 916     if ( state & wxLIST_STATE_DROPHILITED )
 917         flags |= LVNI_DROPHILITED;
 918     if ( state & wxLIST_STATE_FOCUSED )
 919         flags |= LVNI_FOCUSED;
 920     if ( state & wxLIST_STATE_SELECTED )
 921         flags |= LVNI_SELECTED;
 922
 923     return (long) ListView_GetNextItem(GetHwnd(), item, flags);
 924 }
 925
 926
 927 wxImageList *wxListCtrl::GetImageList(int which) const
 928 {
 929     if ( which == wxIMAGE_LIST_NORMAL )
 930     {
 931         return m_imageListNormal;
 932     }
 933     else if ( which == wxIMAGE_LIST_SMALL )
 934     {
 935         return m_imageListSmall;
 936     }
 937     else if ( which == wxIMAGE_LIST_STATE )
 938     {
 939         return m_imageListState;
 940     }
 941     return NULL;
 942 }
 943
 944 void wxListCtrl::SetImageList(wxImageList *imageList, int which)
 945 {
 946     int flags = 0;
 947     if ( which == wxIMAGE_LIST_NORMAL )
 948     {
 949         flags = LVSIL_NORMAL;
 950         if (m_ownsImageListNormal) delete m_imageListNormal;
 951         m_imageListNormal = imageList;
 952         m_ownsImageListNormal = FALSE;
 953     }
 954     else if ( which == wxIMAGE_LIST_SMALL )
 955     {
 956         flags = LVSIL_SMALL;
 957         if (m_ownsImageListSmall) delete m_imageListSmall;
 958         m_imageListSmall = imageList;
 959         m_ownsImageListSmall = FALSE;
 960     }
 961     else if ( which == wxIMAGE_LIST_STATE )
 962     {
 963         flags = LVSIL_STATE;
 964         if (m_ownsImageListState) delete m_imageListState;
 965         m_imageListState = imageList;
 966         m_ownsImageListState = FALSE;
 967     }
 968     ListView_SetImageList(GetHwnd(), (HIMAGELIST) imageList ? imageList->GetHIMAGELIST() : 0, flags);
 969 }
 970
 971 void wxListCtrl::AssignImageList(wxImageList *imageList, int which)
 972 {
 973     SetImageList(imageList, which);
 974     if ( which == wxIMAGE_LIST_NORMAL )
 975         m_ownsImageListNormal = TRUE;
 976     else if ( which == wxIMAGE_LIST_SMALL )
 977         m_ownsImageListSmall = TRUE;
 978     else if ( which == wxIMAGE_LIST_STATE )
 979         m_ownsImageListState = TRUE;
 980 }
 981
 982 // ----------------------------------------------------------------------------
 983 // Operations
 984 // ----------------------------------------------------------------------------
 985
 986 // Arranges the items
 987 bool wxListCtrl::Arrange(int flag)
 988 {
 989     UINT code = 0;
 990     if ( flag == wxLIST_ALIGN_LEFT )
 991         code = LVA_ALIGNLEFT;
 992     else if ( flag == wxLIST_ALIGN_TOP )
 993         code = LVA_ALIGNTOP;
 994     else if ( flag == wxLIST_ALIGN_DEFAULT )
 995         code = LVA_DEFAULT;
 996     else if ( flag == wxLIST_ALIGN_SNAP_TO_GRID )
 997         code = LVA_SNAPTOGRID;
 998
 999     return (ListView_Arrange(GetHwnd(), code) != 0);
1000 }
1001
1002 // Deletes an item
1003 bool wxListCtrl::DeleteItem(long item)
1004 {
1005     return (ListView_DeleteItem(GetHwnd(), (int) item) != 0);
1006 }
1007
1008 // Deletes all items
1009 bool wxListCtrl::DeleteAllItems()
1010 {
1011     return (ListView_DeleteAllItems(GetHwnd()) != 0);
1012 }
1013
1014 // Deletes all items
1015 bool wxListCtrl::DeleteAllColumns()
1016 {
1017     while ( m_colCount > 0 )
1018     {
1019         if ( ListView_DeleteColumn(GetHwnd(), 0) == 0 )
1020         {
1021             wxLogLastError(wxT("ListView_DeleteColumn"));
1022
1023             return FALSE;
1024         }
1025
1026         m_colCount--;
1027     }
1028
1029     wxASSERT_MSG( m_colCount == 0, wxT("no columns should be left") );
1030
1031     return TRUE;
1032 }
1033
1034 // Deletes a column
1035 bool wxListCtrl::DeleteColumn(int col)
1036 {
1037     bool success = (ListView_DeleteColumn(GetHwnd(), col) != 0);
1038
1039     if ( success && (m_colCount > 0) )
1040         m_colCount --;
1041     return success;
1042 }
1043
1044 // Clears items, and columns if there are any.
1045 void wxListCtrl::ClearAll()
1046 {
1047     DeleteAllItems();
1048     if ( m_colCount > 0 )
1049         DeleteAllColumns();
1050 }
1051
1052 wxTextCtrl* wxListCtrl::EditLabel(long item, wxClassInfo* textControlClass)
1053 {
1054     wxASSERT( (textControlClass->IsKindOf(CLASSINFO(wxTextCtrl))) );
1055
1056     // VS: ListView_EditLabel requires that the list has focus.
1057     SetFocus();
1058     HWND hWnd = (HWND) ListView_EditLabel(GetHwnd(), item);
1059
1060     if (m_textCtrl)
1061     {
1062         m_textCtrl->UnsubclassWin();
1063         m_textCtrl->SetHWND(0);
1064         delete m_textCtrl;
1065         m_textCtrl = NULL;
1066     }
1067
1068     m_textCtrl = (wxTextCtrl*) textControlClass->CreateObject();
1069     m_textCtrl->SetHWND((WXHWND) hWnd);
1070     m_textCtrl->SubclassWin((WXHWND) hWnd);
1071
1072     return m_textCtrl;
1073 }
1074
1075 // End label editing, optionally cancelling the edit
1076 bool wxListCtrl::EndEditLabel(bool WXUNUSED(cancel))
1077 {
1078     wxFAIL;
1079
1080     /* I don't know how to implement this: there's no such macro as ListView_EndEditLabelNow.
1081      * ???
1082      bool success = (ListView_EndEditLabelNow(GetHwnd(), cancel) != 0);
1083
1084      if (m_textCtrl)
1085      {
1086      m_textCtrl->UnsubclassWin();
1087      m_textCtrl->SetHWND(0);
1088      delete m_textCtrl;
1089      m_textCtrl = NULL;
1090      }
1091      return success;
1092      */
1093     return FALSE;
1094 }
1095
1096
1097 // Ensures this item is visible
1098 bool wxListCtrl::EnsureVisible(long item)
1099 {
1100     return (ListView_EnsureVisible(GetHwnd(), (int) item, FALSE) != 0);
1101 }
1102
1103 // Find an item whose label matches this string, starting from the item after 'start'
1104 // or the beginning if 'start' is -1.
1105 long wxListCtrl::FindItem(long start, const wxString& str, bool partial)
1106 {
1107     LV_FINDINFO findInfo;
1108
1109     findInfo.flags = LVFI_STRING;
1110     if ( partial )
1111         findInfo.flags |= LVFI_PARTIAL;
1112     findInfo.psz = str;
1113
1114     // ListView_FindItem() excludes the first item from search and to look
1115     // through all the items you need to start from -1 which is unnatural and
1116     // inconsistent with the generic version - so we adjust the index
1117     if (start != -1)
1118         start --;
1119     return ListView_FindItem(GetHwnd(), (int) start, &findInfo);
1120 }
1121
1122 // Find an item whose data matches this data, starting from the item after 'start'
1123 // or the beginning if 'start' is -1.
1124 long wxListCtrl::FindItem(long start, long data)
1125 {
1126     LV_FINDINFO findInfo;
1127
1128     findInfo.flags = LVFI_PARAM;
1129     findInfo.lParam = data;
1130
1131     return ListView_FindItem(GetHwnd(), (int) start, & findInfo);
1132 }
1133
1134 // Find an item nearest this position in the specified direction, starting from
1135 // the item after 'start' or the beginning if 'start' is -1.
1136 long wxListCtrl::FindItem(long start, const wxPoint& pt, int direction)
1137 {
1138     LV_FINDINFO findInfo;
1139
1140     findInfo.flags = LVFI_NEARESTXY;
1141     findInfo.pt.x = pt.x;
1142     findInfo.pt.y = pt.y;
1143     findInfo.vkDirection = VK_RIGHT;
1144
1145     if ( direction == wxLIST_FIND_UP )
1146         findInfo.vkDirection = VK_UP;
1147     else if ( direction == wxLIST_FIND_DOWN )
1148         findInfo.vkDirection = VK_DOWN;
1149     else if ( direction == wxLIST_FIND_LEFT )
1150         findInfo.vkDirection = VK_LEFT;
1151     else if ( direction == wxLIST_FIND_RIGHT )
1152         findInfo.vkDirection = VK_RIGHT;
1153
1154     return ListView_FindItem(GetHwnd(), (int) start, & findInfo);
1155 }
1156
1157 // Determines which item (if any) is at the specified point,
1158 // giving details in 'flags' (see wxLIST_HITTEST_... flags above)
1159 long wxListCtrl::HitTest(const wxPoint& point, int& flags)
1160 {
1161     LV_HITTESTINFO hitTestInfo;
1162     hitTestInfo.pt.x = (int) point.x;
1163     hitTestInfo.pt.y = (int) point.y;
1164
1165     ListView_HitTest(GetHwnd(), & hitTestInfo);
1166
1167     flags = 0;
1168     if ( hitTestInfo.flags & LVHT_ABOVE )
1169         flags |= wxLIST_HITTEST_ABOVE;
1170     if ( hitTestInfo.flags & LVHT_BELOW )
1171         flags |= wxLIST_HITTEST_BELOW;
1172     if ( hitTestInfo.flags & LVHT_NOWHERE )
1173         flags |= wxLIST_HITTEST_NOWHERE;
1174     if ( hitTestInfo.flags & LVHT_ONITEMICON )
1175         flags |= wxLIST_HITTEST_ONITEMICON;
1176     if ( hitTestInfo.flags & LVHT_ONITEMLABEL )
1177         flags |= wxLIST_HITTEST_ONITEMLABEL;
1178     if ( hitTestInfo.flags & LVHT_ONITEMSTATEICON )
1179         flags |= wxLIST_HITTEST_ONITEMSTATEICON;
1180     if ( hitTestInfo.flags & LVHT_TOLEFT )
1181         flags |= wxLIST_HITTEST_TOLEFT;
1182     if ( hitTestInfo.flags & LVHT_TORIGHT )
1183         flags |= wxLIST_HITTEST_TORIGHT;
1184
1185     return (long) hitTestInfo.iItem;
1186 }
1187
1188 // Inserts an item, returning the index of the new item if successful,
1189 // -1 otherwise.
1190 long wxListCtrl::InsertItem(wxListItem& info)
1191 {
1192     LV_ITEM item;
1193     wxConvertToMSWListItem(this, info, item);
1194
1195     // check whether it has any custom attributes
1196     if ( info.HasAttributes() )
1197     {
1198
1199         wxListItemAttr *attr;
1200         attr = (wxListItemAttr*) m_attrs.Get(item.iItem);
1201
1202         if (attr == NULL)
1203
1204             m_attrs.Put(item.iItem, (wxObject *)new wxListItemAttr(*info.GetAttributes()));
1205
1206         else *attr = *info.GetAttributes();
1207
1208         m_hasAnyAttr = TRUE;
1209     }
1210
1211     return (long) ListView_InsertItem(GetHwnd(), & item);
1212 }
1213
1214 long wxListCtrl::InsertItem(long index, const wxString& label)
1215 {
1216     wxListItem info;
1217     info.m_text = label;
1218     info.m_mask = wxLIST_MASK_TEXT;
1219     info.m_itemId = index;
1220     return InsertItem(info);
1221 }
1222
1223 // Inserts an image item
1224 long wxListCtrl::InsertItem(long index, int imageIndex)
1225 {
1226     wxListItem info;
1227     info.m_image = imageIndex;
1228     info.m_mask = wxLIST_MASK_IMAGE;
1229     info.m_itemId = index;
1230     return InsertItem(info);
1231 }
1232
1233 // Inserts an image/string item
1234 long wxListCtrl::InsertItem(long index, const wxString& label, int imageIndex)
1235 {
1236     wxListItem info;
1237     info.m_image = imageIndex;
1238     info.m_text = label;
1239     info.m_mask = wxLIST_MASK_IMAGE | wxLIST_MASK_TEXT;
1240     info.m_itemId = index;
1241     return InsertItem(info);
1242 }
1243
1244 // For list view mode (only), inserts a column.
1245 long wxListCtrl::InsertColumn(long col, wxListItem& item)
1246 {
1247     LV_COLUMN lvCol;
1248     lvCol.mask = 0;
1249     lvCol.fmt = 0;
1250     lvCol.pszText = NULL;
1251
1252     if ( item.m_mask & wxLIST_MASK_TEXT )
1253     {
1254         lvCol.mask |= LVCF_TEXT;
1255         lvCol.pszText = WXSTRINGCAST item.m_text;
1256         lvCol.cchTextMax = 0; // Ignored
1257     }
1258     if ( item.m_mask & wxLIST_MASK_FORMAT )
1259     {
1260         lvCol.mask |= LVCF_FMT;
1261
1262         if ( item.m_format == wxLIST_FORMAT_LEFT )
1263             lvCol.fmt = LVCFMT_LEFT;
1264         if ( item.m_format == wxLIST_FORMAT_RIGHT )
1265             lvCol.fmt = LVCFMT_RIGHT;
1266         if ( item.m_format == wxLIST_FORMAT_CENTRE )
1267             lvCol.fmt = LVCFMT_CENTER;
1268     }
1269
1270     lvCol.mask |= LVCF_WIDTH;
1271     if ( item.m_mask & wxLIST_MASK_WIDTH )
1272     {
1273         if ( item.m_width == wxLIST_AUTOSIZE)
1274             lvCol.cx = LVSCW_AUTOSIZE;
1275         else if ( item.m_width == wxLIST_AUTOSIZE_USEHEADER)
1276             lvCol.cx = LVSCW_AUTOSIZE_USEHEADER;
1277         else
1278             lvCol.cx = item.m_width;
1279     }
1280     else
1281     {
1282         // always give some width to the new column: this one is compatible
1283         // with wxGTK
1284         lvCol.cx = 80;
1285     }
1286
1287     lvCol.mask |= LVCF_SUBITEM;
1288     lvCol.iSubItem = col;
1289
1290     bool success = ListView_InsertColumn(GetHwnd(), col, & lvCol) != -1;
1291     if ( success )
1292     {
1293         m_colCount++;
1294     }
1295     else
1296     {
1297         wxLogDebug(wxT("Failed to insert the column '%s' into listview!"),
1298                    lvCol.pszText);
1299     }
1300
1301     return success;
1302 }
1303
1304 long wxListCtrl::InsertColumn(long col,
1305                               const wxString& heading,
1306                               int format,
1307                               int width)
1308 {
1309     wxListItem item;
1310     item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT;
1311     item.m_text = heading;
1312     if ( width > -1 )
1313     {
1314         item.m_mask |= wxLIST_MASK_WIDTH;
1315         item.m_width = width;
1316     }
1317     item.m_format = format;
1318
1319     return InsertColumn(col, item);
1320 }
1321
1322 // Scrolls the list control. If in icon, small icon or report view mode,
1323 // x specifies the number of pixels to scroll. If in list view mode, x
1324 // specifies the number of columns to scroll.
1325 // If in icon, small icon or list view mode, y specifies the number of pixels
1326 // to scroll. If in report view mode, y specifies the number of lines to scroll.
1327 bool wxListCtrl::ScrollList(int dx, int dy)
1328 {
1329     return (ListView_Scroll(GetHwnd(), dx, dy) != 0);
1330 }
1331
1332 // Sort items.
1333
1334 // fn is a function which takes 3 long arguments: item1, item2, data.
1335 // item1 is the long data associated with a first item (NOT the index).
1336 // item2 is the long data associated with a second item (NOT the index).
1337 // data is the same value as passed to SortItems.
1338 // The return value is a negative number if the first item should precede the second
1339 // item, a positive number of the second item should precede the first,
1340 // or zero if the two items are equivalent.
1341
1342 // data is arbitrary data to be passed to the sort function.
1343 bool wxListCtrl::SortItems(wxListCtrlCompare fn, long data)
1344 {
1345     return (ListView_SortItems(GetHwnd(), (PFNLVCOMPARE) fn, data) != 0);
1346 }
1347
1348 // ----------------------------------------------------------------------------
1349 // message processing
1350 // ----------------------------------------------------------------------------
1351
1352 bool wxListCtrl::MSWCommand(WXUINT cmd, WXWORD id)
1353 {
1354     if (cmd == EN_UPDATE)
1355     {
1356         wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
1357         event.SetEventObject( this );
1358         ProcessCommand(event);
1359         return TRUE;
1360     }
1361     else if (cmd == EN_KILLFOCUS)
1362     {
1363         wxCommandEvent event(wxEVT_KILL_FOCUS, id);
1364         event.SetEventObject( this );
1365         ProcessCommand(event);
1366         return TRUE;
1367     }
1368     else
1369         return FALSE;
1370 }
1371
1372 bool wxListCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
1373 {
1374     // prepare the event
1375     // -----------------
1376
1377     wxListEvent event(wxEVT_NULL, m_windowId);
1378     wxEventType eventType = wxEVT_NULL;
1379
1380     NMHDR *nmhdr = (NMHDR *)lParam;
1381
1382     // almost all messages use NM_LISTVIEW
1383     NM_LISTVIEW *nmLV = (NM_LISTVIEW *)nmhdr;
1384
1385     // this is true for almost all events
1386     event.m_item.m_data = nmLV->lParam;
1387
1388     switch ( nmhdr->code )
1389     {
1390         case LVN_BEGINRDRAG:
1391             eventType = wxEVT_COMMAND_LIST_BEGIN_RDRAG;
1392             // fall through
1393
1394         case LVN_BEGINDRAG:
1395             if ( eventType == wxEVT_NULL )
1396             {
1397                 eventType = wxEVT_COMMAND_LIST_BEGIN_DRAG;
1398             }
1399
1400             event.m_itemIndex = nmLV->iItem;
1401             event.m_pointDrag.x = nmLV->ptAction.x;
1402             event.m_pointDrag.y = nmLV->ptAction.y;
1403             break;
1404
1405         case LVN_BEGINLABELEDIT:
1406             {
1407                 eventType = wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT;
1408                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1409                 wxConvertFromMSWListItem(this, event.m_item, info->item, GetHwnd());
1410             }
1411             break;
1412
1413         case LVN_COLUMNCLICK:
1414             eventType = wxEVT_COMMAND_LIST_COL_CLICK;
1415             event.m_itemIndex = -1;
1416             event.m_col = nmLV->iSubItem;
1417             break;
1418
1419         case LVN_DELETEALLITEMS:
1420             eventType = wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS;
1421             event.m_itemIndex = -1;
1422
1423             FreeAllAttrs();
1424
1425             break;
1426
1427         case LVN_DELETEITEM:
1428             eventType = wxEVT_COMMAND_LIST_DELETE_ITEM;
1429             event.m_itemIndex = nmLV->iItem;
1430
1431             if ( m_hasAnyAttr )
1432             {
1433                 delete (wxListItemAttr *)m_attrs.Delete(nmLV->iItem);
1434             }
1435             break;
1436
1437         case LVN_ENDLABELEDIT:
1438             {
1439                 eventType = wxEVT_COMMAND_LIST_END_LABEL_EDIT;
1440                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1441                 wxConvertFromMSWListItem(this, event.m_item, info->item);
1442                 if ( info->item.pszText == NULL || info->item.iItem == -1 )
1443                     return FALSE;
1444             }
1445             break;
1446
1447         case LVN_SETDISPINFO:
1448             {
1449                 eventType = wxEVT_COMMAND_LIST_SET_INFO;
1450                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1451                 wxConvertFromMSWListItem(this, event.m_item, info->item, GetHwnd());
1452             }
1453             break;
1454
1455         case LVN_GETDISPINFO:
1456                 // this provokes stack overflow: indeed, wxConvertFromMSWListItem()
1457                 // sends us WM_NOTIFY! As it doesn't do anything for now, just leave
1458                 // it out.
1459 #if 0
1460             {
1461                 // TODO: some text buffering here, I think
1462                 // TODO: API for getting Windows to retrieve values
1463                 // on demand.
1464                 eventType = wxEVT_COMMAND_LIST_GET_INFO;
1465                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1466                 wxConvertFromMSWListItem(this, event.m_item, info->item, GetHwnd());
1467                 break;
1468             }
1469 #endif // 0
1470                 return FALSE;
1471
1472
1473         case LVN_INSERTITEM:
1474             eventType = wxEVT_COMMAND_LIST_INSERT_ITEM;
1475             event.m_itemIndex = nmLV->iItem;
1476             break;
1477
1478         case LVN_ITEMCHANGED:
1479             // This needs to be sent to wxListCtrl as a rather more concrete
1480             // event. For now, just detect a selection or deselection.
1481             if ( (nmLV->uNewState & LVIS_SELECTED) && !(nmLV->uOldState & LVIS_SELECTED) )
1482             {
1483                 eventType = wxEVT_COMMAND_LIST_ITEM_SELECTED;
1484                 event.m_itemIndex = nmLV->iItem;
1485             }
1486             else if ( !(nmLV->uNewState & LVIS_SELECTED) && (nmLV->uOldState & LVIS_SELECTED) )
1487             {
1488                 eventType = wxEVT_COMMAND_LIST_ITEM_DESELECTED;
1489                 event.m_itemIndex = nmLV->iItem;
1490             }
1491             else
1492             {
1493                 return FALSE;
1494             }
1495             break;
1496
1497         case LVN_KEYDOWN:
1498             {
1499                 LV_KEYDOWN *info = (LV_KEYDOWN *)lParam;
1500                 WORD wVKey = info->wVKey;
1501
1502                 // get the current selection
1503                 long lItem = GetNextItem(-1,
1504                                          wxLIST_NEXT_ALL,
1505                                          wxLIST_STATE_SELECTED);
1506
1507                 // <Enter> or <Space> activate the selected item if any (but
1508                 // not with Shift and/or Ctrl as then they have a predefined
1509                 // meaning for the list view)
1510                 if ( lItem != -1 &&
1511                      (wVKey == VK_RETURN || wVKey == VK_SPACE) &&
1512                      !(wxIsShiftDown() || wxIsCtrlDown()) )
1513                 {
1514                     eventType = wxEVT_COMMAND_LIST_ITEM_ACTIVATED;
1515                     event.m_itemIndex = lItem;
1516                 }
1517                 else
1518                 {
1519                     eventType = wxEVT_COMMAND_LIST_KEY_DOWN;
1520                     event.m_code = wxCharCodeMSWToWX(wVKey);
1521                 }
1522
1523                 if ( lItem != -1 )
1524                 {
1525                     // fill the other fields too
1526                     event.m_item.m_text = GetItemText(lItem);
1527                     event.m_item.m_data = GetItemData(lItem);
1528                 }
1529             }
1530             break;
1531
1532         case NM_DBLCLK:
1533             // if the user processes it in wxEVT_COMMAND_LEFT_CLICK(), don't do
1534             // anything else
1535             if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
1536             {
1537                 return TRUE;
1538             }
1539
1540             // else translate it into wxEVT_COMMAND_LIST_ITEM_ACTIVATED event
1541             // if it happened on an item (and not on empty place)
1542             if ( nmLV->iItem == -1 )
1543             {
1544                 // not on item
1545                 return FALSE;
1546             }
1547
1548             eventType = wxEVT_COMMAND_LIST_ITEM_ACTIVATED;
1549             event.m_itemIndex = nmLV->iItem;
1550             event.m_item.m_text = GetItemText(nmLV->iItem);
1551             event.m_item.m_data = GetItemData(nmLV->iItem);
1552             break;
1553
1554         case NM_RCLICK:
1555             /* TECH NOTE: NM_RCLICK isn't really good enough here. We want to
1556                subclass and check for the actual WM_RBUTTONDOWN message,
1557                because NM_RCLICK waits for the WM_RBUTTONUP message as well
1558                before firing off. We want to have notify events for both down
1559                -and- up. */
1560             {
1561                 // if the user processes it in wxEVT_COMMAND_RIGHT_CLICK(),
1562                 // don't do anything else
1563                 if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
1564                 {
1565                     return TRUE;
1566                 }
1567
1568                 // else translate it into wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK event
1569                 LV_HITTESTINFO lvhti;
1570                 wxZeroMemory(lvhti);
1571
1572                 ::GetCursorPos(&(lvhti.pt));
1573                 ::ScreenToClient(GetHwnd(),&(lvhti.pt));
1574                 if ( ListView_HitTest(GetHwnd(),&lvhti) != -1 )
1575                 {
1576                     if ( lvhti.flags & LVHT_ONITEM )
1577                     {
1578                         eventType = wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK;
1579                         event.m_itemIndex = lvhti.iItem;
1580                         event.m_pointDrag.x = lvhti.pt.x;
1581                         event.m_pointDrag.y = lvhti.pt.y;
1582                     }
1583                 }
1584             }
1585             break;
1586
1587 #if 0
1588         case NM_MCLICK: // ***** THERE IS NO NM_MCLICK. Subclass anyone? ******
1589             {
1590                 // if the user processes it in wxEVT_COMMAND_MIDDLE_CLICK(), don't do
1591                 // anything else
1592                 if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
1593                 {
1594                     return TRUE;
1595                 }
1596
1597                 // else translate it into wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK event
1598                 eventType = wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK;
1599                 NMITEMACTIVATE* hdr = (NMITEMACTIVATE*)lParam;
1600                 event.m_itemIndex = hdr->iItem;
1601             }
1602             break;
1603 #endif // 0
1604
1605 #if defined(_WIN32_IE) && _WIN32_IE >= 0x300
1606         case NM_CUSTOMDRAW:
1607             {
1608                 LPNMLVCUSTOMDRAW lplvcd = (LPNMLVCUSTOMDRAW)lParam;
1609                 NMCUSTOMDRAW& nmcd = lplvcd->nmcd;
1610                 switch( nmcd.dwDrawStage )
1611                 {
1612                     case CDDS_PREPAINT:
1613                         // if we've got any items with non standard attributes,
1614                         // notify us before painting each item
1615                         *result = m_hasAnyAttr ? CDRF_NOTIFYITEMDRAW
1616                                                : CDRF_DODEFAULT;
1617                         return TRUE;
1618
1619                     case CDDS_ITEMPREPAINT:
1620                         {
1621                             wxListItemAttr *attr =
1622                                 (wxListItemAttr *)m_attrs.Get(nmcd.dwItemSpec);
1623
1624                             if ( !attr )
1625                             {
1626                                 // nothing to do for this item
1627                                 return CDRF_DODEFAULT;
1628                             }
1629
1630                             HFONT hFont;
1631                             wxColour colText, colBack;
1632                             if ( attr->HasFont() )
1633                             {
1634                                 wxFont font = attr->GetFont();
1635                                 hFont = (HFONT)font.GetResourceHandle();
1636                             }
1637                             else
1638                             {
1639                                 hFont = 0;
1640                             }
1641
1642                             if ( attr->HasTextColour() )
1643                             {
1644                                 colText = attr->GetTextColour();
1645                             }
1646                             else
1647                             {
1648                                 colText = GetTextColour();
1649                             }
1650
1651                             if ( attr->HasBackgroundColour() )
1652                             {
1653                                 colBack = attr->GetBackgroundColour();
1654                             }
1655                             else
1656                             {
1657                                 colBack = GetBackgroundColour();
1658                             }
1659
1660                             // note that if we wanted to set colours for
1661                             // individual columns (subitems), we would have
1662                             // returned CDRF_NOTIFYSUBITEMREDRAW from here
1663                             if ( hFont )
1664                             {
1665                                 ::SelectObject(nmcd.hdc, hFont);
1666
1667                                 *result = CDRF_NEWFONT;
1668                             }
1669                             else
1670                             {
1671                                 *result = CDRF_DODEFAULT;
1672                             }
1673
1674                             lplvcd->clrText = wxColourToRGB(colText);
1675                             lplvcd->clrTextBk = wxColourToRGB(colBack);
1676
1677                             return TRUE;
1678                         }
1679
1680                     default:
1681                         *result = CDRF_DODEFAULT;
1682                         return TRUE;
1683                 }
1684             }
1685 //            break; // can never be reached
1686 #endif // _WIN32_IE >= 0x300
1687
1688         default:
1689             return wxControl::MSWOnNotify(idCtrl, lParam, result);
1690     }
1691
1692     // process the event
1693     // -----------------
1694
1695     event.SetEventObject( this );
1696     event.SetEventType(eventType);
1697
1698     if ( !GetEventHandler()->ProcessEvent(event) )
1699         return FALSE;
1700
1701     // post processing
1702     // ---------------
1703
1704     switch ( nmhdr->code )
1705     {
1706         case LVN_DELETEALLITEMS:
1707             // always return TRUE to suppress all additional LVN_DELETEITEM
1708             // notifications - this makes deleting all items from a list ctrl
1709             // much faster
1710             *result = TRUE;
1711
1712             return TRUE;
1713
1714         case LVN_GETDISPINFO:
1715             {
1716                 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
1717                 if ( info->item.mask & LVIF_TEXT )
1718                 {
1719                     if ( !event.m_item.m_text.IsNull() )
1720                     {
1721                         info->item.pszText = AddPool(event.m_item.m_text);
1722                         info->item.cchTextMax = wxStrlen(info->item.pszText) + 1;
1723                     }
1724                 }
1725                 //    wxConvertToMSWListItem(this, event.m_item, info->item);
1726                 break;
1727             }
1728         case LVN_ENDLABELEDIT:
1729             {
1730                 *result = event.IsAllowed();
1731                 return TRUE;
1732             }
1733     }
1734
1735     *result = !event.IsAllowed();
1736
1737     return TRUE;
1738 }
1739
1740 wxChar *wxListCtrl::AddPool(const wxString& str)
1741 {
1742     // Remove the first element if 3 strings exist
1743     if ( m_stringPool.Number() == 3 )
1744     {
1745         wxNode *node = m_stringPool.First();
1746         delete[] (char *)node->Data();
1747         delete node;
1748     }
1749     wxNode *node = m_stringPool.Add(WXSTRINGCAST str);
1750     return (wxChar *)node->Data();
1751 }
1752
1753 // Necessary for drawing hrules and vrules, if specified
1754 void wxListCtrl::OnPaint(wxPaintEvent& event)
1755 {
1756     wxPaintDC dc(this);
1757
1758     wxControl::OnPaint(event);
1759
1760     // Reset the device origin since it may have been set
1761     dc.SetDeviceOrigin(0, 0);
1762
1763     bool drawHRules = ((GetWindowStyle() & wxLC_HRULES) != 0);
1764     bool drawVRules = ((GetWindowStyle() & wxLC_VRULES) != 0);
1765
1766     if (!drawHRules && !drawVRules)
1767         return;
1768     if ((GetWindowStyle() & wxLC_REPORT) == 0)
1769         return;
1770
1771     wxPen pen(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DLIGHT), 1, wxSOLID);
1772     dc.SetPen(pen);
1773     dc.SetBrush(* wxTRANSPARENT_BRUSH);
1774
1775     wxSize clientSize = GetClientSize();
1776     wxRect itemRect;
1777     int cy=0;
1778
1779     int itemCount = GetItemCount();
1780     int i;
1781     for (i = 0; i < itemCount; i++)
1782     {
1783         if (GetItemRect(i, itemRect))
1784         {
1785             cy = itemRect.GetTop();
1786             if (i != 0) // Don't draw the first one
1787             {
1788                 dc.DrawLine(0, cy, clientSize.x, cy);
1789             }
1790             // Draw last line
1791             if (i == (GetItemCount() - 1))
1792             {
1793                 cy = itemRect.GetBottom();
1794                 dc.DrawLine(0, cy, clientSize.x, cy);
1795             }
1796         }
1797     }
1798     i = (GetItemCount() - 1);
1799     if (drawVRules && (i > -1))
1800     {
1801         wxRect firstItemRect;
1802         GetItemRect(0, firstItemRect);
1803
1804         if (GetItemRect(i, itemRect))
1805         {
1806             int col;
1807             int x = itemRect.GetX();
1808             for (col = 0; col < GetColumnCount(); col++)
1809             {
1810                 int colWidth = GetColumnWidth(col);
1811                 x += colWidth ;
1812                 dc.DrawLine(x, firstItemRect.GetY() - 2, x, itemRect.GetBottom());
1813             }
1814         }
1815     }
1816 }
1817
1818 // ----------------------------------------------------------------------------
1819 // wxListItem
1820 // ----------------------------------------------------------------------------
1821
1822 // List item structure
1823 wxListItem::wxListItem()
1824 {
1825     m_mask = 0;
1826     m_itemId = 0;
1827     m_col = 0;
1828     m_state = 0;
1829     m_stateMask = 0;
1830     m_image = 0;
1831     m_data = 0;
1832
1833     m_format = wxLIST_FORMAT_CENTRE;
1834     m_width = 0;
1835
1836     m_attr = NULL;
1837 }
1838
1839 void wxListItem::Clear()
1840 {
1841     m_mask = 0;
1842     m_itemId = 0;
1843     m_col = 0;
1844     m_state = 0;
1845     m_stateMask = 0;
1846     m_image = 0;
1847     m_data = 0;
1848     m_format = wxLIST_FORMAT_CENTRE;
1849     m_width = 0;
1850     m_text = wxEmptyString;
1851
1852     if (m_attr) delete m_attr;
1853     m_attr = NULL;
1854 }
1855
1856 void wxListItem::ClearAttributes()
1857 {
1858     if (m_attr) delete m_attr;
1859     m_attr = NULL;
1860 }
1861
1862 static void wxConvertFromMSWListItem(const wxListCtrl *WXUNUSED(ctrl), wxListItem& info, LV_ITEM& lvItem, HWND getFullInfo)
1863 {
1864     info.m_data = lvItem.lParam;
1865     info.m_mask = 0;
1866     info.m_state = 0;
1867     info.m_stateMask = 0;
1868     info.m_itemId = lvItem.iItem;
1869
1870     long oldMask = lvItem.mask;
1871
1872     bool needText = FALSE;
1873     if (getFullInfo != 0)
1874     {
1875         if ( lvItem.mask & LVIF_TEXT )
1876             needText = FALSE;
1877         else
1878             needText = TRUE;
1879
1880         if ( needText )
1881         {
1882             lvItem.pszText = new wxChar[513];
1883             lvItem.cchTextMax = 512;
1884         }
1885         //    lvItem.mask |= TVIF_HANDLE | TVIF_STATE | TVIF_TEXT | TVIF_IMAGE | TVIF_SELECTEDIMAGE | TVIF_CHILDREN | TVIF_PARAM;
1886         lvItem.mask |= LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
1887         ::SendMessage(getFullInfo, LVM_GETITEM, 0, (LPARAM)& lvItem);
1888     }
1889
1890     if ( lvItem.mask & LVIF_STATE )
1891     {
1892         info.m_mask |= wxLIST_MASK_STATE;
1893
1894         if ( lvItem.stateMask & LVIS_CUT)
1895         {
1896             info.m_stateMask |= wxLIST_STATE_CUT;
1897             if ( lvItem.state & LVIS_CUT )
1898                 info.m_state |= wxLIST_STATE_CUT;
1899         }
1900         if ( lvItem.stateMask & LVIS_DROPHILITED)
1901         {
1902             info.m_stateMask |= wxLIST_STATE_DROPHILITED;
1903             if ( lvItem.state & LVIS_DROPHILITED )
1904                 info.m_state |= wxLIST_STATE_DROPHILITED;
1905         }
1906         if ( lvItem.stateMask & LVIS_FOCUSED)
1907         {
1908             info.m_stateMask |= wxLIST_STATE_FOCUSED;
1909             if ( lvItem.state & LVIS_FOCUSED )
1910                 info.m_state |= wxLIST_STATE_FOCUSED;
1911         }
1912         if ( lvItem.stateMask & LVIS_SELECTED)
1913         {
1914             info.m_stateMask |= wxLIST_STATE_SELECTED;
1915             if ( lvItem.state & LVIS_SELECTED )
1916                 info.m_state |= wxLIST_STATE_SELECTED;
1917         }
1918     }
1919
1920     if ( lvItem.mask & LVIF_TEXT )
1921     {
1922         info.m_mask |= wxLIST_MASK_TEXT;
1923         info.m_text = lvItem.pszText;
1924     }
1925     if ( lvItem.mask & LVIF_IMAGE )
1926     {
1927         info.m_mask |= wxLIST_MASK_IMAGE;
1928         info.m_image = lvItem.iImage;
1929     }
1930     if ( lvItem.mask & LVIF_PARAM )
1931         info.m_mask |= wxLIST_MASK_DATA;
1932     if ( lvItem.mask & LVIF_DI_SETITEM )
1933         info.m_mask |= wxLIST_SET_ITEM;
1934     info.m_col = lvItem.iSubItem;
1935
1936     if (needText)
1937     {
1938         if (lvItem.pszText)
1939             delete[] lvItem.pszText;
1940     }
1941     lvItem.mask = oldMask;
1942 }
1943
1944 static void wxConvertToMSWListItem(const wxListCtrl *ctrl, wxListItem& info, LV_ITEM& lvItem)
1945 {
1946     lvItem.iItem = (int) info.m_itemId;
1947
1948     lvItem.iImage = info.m_image;
1949     lvItem.lParam = info.m_data;
1950     lvItem.stateMask = 0;
1951     lvItem.state = 0;
1952     lvItem.mask = 0;
1953     lvItem.iSubItem = info.m_col;
1954
1955     if (info.m_mask & wxLIST_MASK_STATE)
1956     {
1957         lvItem.mask |= LVIF_STATE;
1958         if (info.m_stateMask & wxLIST_STATE_CUT)
1959         {
1960             lvItem.stateMask |= LVIS_CUT;
1961             if (info.m_state & wxLIST_STATE_CUT)
1962                 lvItem.state |= LVIS_CUT;
1963         }
1964         if (info.m_stateMask & wxLIST_STATE_DROPHILITED)
1965         {
1966             lvItem.stateMask |= LVIS_DROPHILITED;
1967             if (info.m_state & wxLIST_STATE_DROPHILITED)
1968                 lvItem.state |= LVIS_DROPHILITED;
1969         }
1970         if (info.m_stateMask & wxLIST_STATE_FOCUSED)
1971         {
1972             lvItem.stateMask |= LVIS_FOCUSED;
1973             if (info.m_state & wxLIST_STATE_FOCUSED)
1974                 lvItem.state |= LVIS_FOCUSED;
1975         }
1976         if (info.m_stateMask & wxLIST_STATE_SELECTED)
1977         {
1978             lvItem.stateMask |= LVIS_SELECTED;
1979             if (info.m_state & wxLIST_STATE_SELECTED)
1980                 lvItem.state |= LVIS_SELECTED;
1981         }
1982     }
1983
1984     if (info.m_mask & wxLIST_MASK_TEXT)
1985     {
1986         lvItem.mask |= LVIF_TEXT;
1987         if ( ctrl->GetWindowStyleFlag() & wxLC_USER_TEXT )
1988         {
1989             lvItem.pszText = LPSTR_TEXTCALLBACK;
1990         }
1991         else
1992         {
1993             lvItem.pszText = WXSTRINGCAST info.m_text;
1994             if ( lvItem.pszText )
1995                 lvItem.cchTextMax = info.m_text.Length();
1996             else
1997                 lvItem.cchTextMax = 0;
1998         }
1999     }
2000     if (info.m_mask & wxLIST_MASK_IMAGE)
2001         lvItem.mask |= LVIF_IMAGE;
2002     if (info.m_mask & wxLIST_MASK_DATA)
2003         lvItem.mask |= LVIF_PARAM;
2004 }
2005
2006 // ----------------------------------------------------------------------------
2007 // List event
2008 // ----------------------------------------------------------------------------
2009
2010 IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxNotifyEvent)
2011
2012 wxListEvent::wxListEvent(wxEventType commandType, int id)
2013            : wxNotifyEvent(commandType, id)
2014 {
2015     m_code = 0;
2016     m_itemIndex = 0;
2017     m_oldItemIndex = 0;
2018     m_col = 0;
2019     m_cancelled = FALSE;
2020 }
2021
2022 #endif // __WIN95__
2023