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