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