]> git.saurik.com Git - wxWidgets.git/blame - src/msw/listctrl.cpp
split wxEVT_GRID_CELL_CHANGE into wxEVT_GRID_CELL_CHANGING/ED pair for consistency...
[wxWidgets.git] / src / msw / listctrl.cpp
CommitLineData
2bda0e17 1/////////////////////////////////////////////////////////////////////////////
648bec3e 2// Name: src/msw/listctrl.cpp
2bda0e17
KB
3// Purpose: wxListCtrl
4// Author: Julian Smart
164a7972 5// Modified by: Agron Selimaj
2bda0e17
KB
6// Created: 04/01/98
7// RCS-ID: $Id$
6c9a19aa 8// Copyright: (c) Julian Smart
65571936 9// Licence: wxWindows licence
2bda0e17
KB
10/////////////////////////////////////////////////////////////////////////////
11
edccf428
VZ
12// ============================================================================
13// declarations
14// ============================================================================
15
16// ----------------------------------------------------------------------------
17// headers
18// ----------------------------------------------------------------------------
19
2bda0e17
KB
20// For compilers that support precompilation, includes "wx.h".
21#include "wx/wxprec.h"
22
23#ifdef __BORLANDC__
0b5efdc7 24 #pragma hdrstop
2bda0e17
KB
25#endif
26
a71d815b 27#if wxUSE_LISTCTRL
9f303149 28
e409b62a
PC
29#include "wx/listctrl.h"
30
2bda0e17 31#ifndef WX_PRECOMP
57bd4c60 32 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
9f303149 33 #include "wx/app.h"
9f303149
VZ
34 #include "wx/intl.h"
35 #include "wx/log.h"
36 #include "wx/settings.h"
ed4b0fdc 37 #include "wx/dcclient.h"
fec9cc08 38 #include "wx/textctrl.h"
2bda0e17
KB
39#endif
40
de8e98f1 41#include "wx/imaglist.h"
ceef3893 42#include "wx/vector.h"
2bda0e17
KB
43
44#include "wx/msw/private.h"
45
781a24e8 46#if defined(__WXWINCE__) && !defined(__HANDHELDPC__)
80a81a12
JS
47 #include <ole2.h>
48 #include <shellapi.h>
2d36b3d8
JS
49 #if _WIN32_WCE < 400
50 #include <aygshell.h>
51 #endif
80a81a12
JS
52#endif
53
2f73fd38
MW
54// Currently gcc and watcom don't define NMLVFINDITEM, and DMC only defines
55// it by its old name NM_FINDTIEM.
56//
73f91e1e 57#if defined(__VISUALC__) || defined(__BORLANDC__) || defined(NMLVFINDITEM)
2f73fd38 58 #define HAVE_NMLVFINDITEM 1
73f91e1e 59#elif defined(__DMC__) || defined(NM_FINDITEM)
206391cb
VZ
60 #define HAVE_NMLVFINDITEM 1
61 #define NMLVFINDITEM NM_FINDITEM
2f73fd38
MW
62#endif
63
edccf428
VZ
64// ----------------------------------------------------------------------------
65// private functions
66// ----------------------------------------------------------------------------
2bda0e17 67
8dff2b5c
VZ
68// convert our state and mask flags to LV_ITEM constants
69static void wxConvertToMSWFlags(long state, long mask, LV_ITEM& lvItem);
70
71// convert wxListItem to LV_ITEM
72static void wxConvertToMSWListItem(const wxListCtrl *ctrl,
73 const wxListItem& info, LV_ITEM& lvItem);
74
75// convert LV_ITEM to wxListItem
76static void wxConvertFromMSWListItem(HWND hwndListCtrl,
77 wxListItem& info,
78 /* const */ LV_ITEM& lvItem);
2bda0e17 79
6f806543 80// convert our wxListItem to LV_COLUMN
e64658ed
VZ
81static void wxConvertToMSWListCol(HWND hwndList,
82 int col,
83 const wxListItem& item,
6f806543
VZ
84 LV_COLUMN& lvCol);
85
89cafab0
VZ
86namespace
87{
88
89// replacement for ListView_GetSubItemRect() which provokes warnings like
90// "the address of 'rc' will always evaluate as 'true'" when used with mingw32
91// 4.3+
92//
93// this function does no error checking on item and subitem parameters, notice
67561862
VZ
94// that subitem 0 means the whole item so there is no way to retrieve the
95// rectangle of the first subitem using this function, in particular notice
96// that the index is *not* 1-based, in spite of what MSDN says
89cafab0
VZ
97inline bool
98wxGetListCtrlSubItemRect(HWND hwnd, int item, int subitem, int flags, RECT& rect)
99{
100 rect.top = subitem;
101 rect.left = flags;
102 return ::SendMessage(hwnd, LVM_GETSUBITEMRECT, item, (LPARAM)&rect) != 0;
103}
104
105inline bool
106wxGetListCtrlItemRect(HWND hwnd, int item, int flags, RECT& rect)
107{
108 return wxGetListCtrlSubItemRect(hwnd, item, 0, flags, rect);
109}
110
111} // anonymous namespace
112
8c21905b
VS
113// ----------------------------------------------------------------------------
114// private helper classes
115// ----------------------------------------------------------------------------
116
117// We have to handle both fooW and fooA notifications in several cases
d2ed74b9 118// because of broken comctl32.dll and/or unicows.dll. This class is used to
73d8c5fd 119// convert LV_ITEMA and LV_ITEMW to LV_ITEM (which is either LV_ITEMA or
8c21905b
VS
120// LV_ITEMW depending on wxUSE_UNICODE setting), so that it can be processed
121// by wxConvertToMSWListItem().
d2ed74b9
VZ
122#if wxUSE_UNICODE
123 #define LV_ITEM_NATIVE LV_ITEMW
124 #define LV_ITEM_OTHER LV_ITEMA
125
126 #define LV_CONV_TO_WX cMB2WX
127 #define LV_CONV_BUF wxMB2WXbuf
128#else // ANSI
129 #define LV_ITEM_NATIVE LV_ITEMA
130 #define LV_ITEM_OTHER LV_ITEMW
131
132 #define LV_CONV_TO_WX cWC2WX
133 #define LV_CONV_BUF wxWC2WXbuf
134#endif // Unicode/ANSI
135
8c21905b
VS
136class wxLV_ITEM
137{
138public:
d2ed74b9
VZ
139 // default ctor, use Init() later
140 wxLV_ITEM() { m_buf = NULL; m_pItem = NULL; }
8c21905b 141
d2ed74b9
VZ
142 // init without conversion
143 void Init(LV_ITEM_NATIVE& item)
8c21905b 144 {
d2ed74b9
VZ
145 wxASSERT_MSG( !m_pItem, _T("Init() called twice?") );
146
147 m_pItem = &item;
73d8c5fd 148 }
8c21905b 149
d2ed74b9 150 // init with conversion
fbfb8bcc 151 void Init(const LV_ITEM_OTHER& item)
8c21905b 152 {
d2ed74b9
VZ
153 // avoid unnecessary dynamic memory allocation, jjust make m_pItem
154 // point to our own m_item
2b5f62a0 155
1c6f2414
WS
156 // memcpy() can't work if the struct sizes are different
157 wxCOMPILE_TIME_ASSERT( sizeof(LV_ITEM_OTHER) == sizeof(LV_ITEM_NATIVE),
158 CodeCantWorkIfDiffSizes);
159
d2ed74b9
VZ
160 memcpy(&m_item, &item, sizeof(LV_ITEM_NATIVE));
161
162 // convert text from ANSI to Unicod if necessary
8c21905b
VS
163 if ( (item.mask & LVIF_TEXT) && item.pszText )
164 {
d2ed74b9
VZ
165 m_buf = new LV_CONV_BUF(wxConvLocal.LV_CONV_TO_WX(item.pszText));
166 m_item.pszText = (wxChar *)m_buf->data();
8c21905b 167 }
73d8c5fd 168 }
d2ed74b9
VZ
169
170 // ctor without conversion
171 wxLV_ITEM(LV_ITEM_NATIVE& item) : m_buf(NULL), m_pItem(&item) { }
172
173 // ctor with conversion
174 wxLV_ITEM(LV_ITEM_OTHER& item) : m_buf(NULL)
175 {
176 Init(item);
177 }
178
179 ~wxLV_ITEM() { delete m_buf; }
180
181 // conversion to the real LV_ITEM
182 operator LV_ITEM_NATIVE&() const { return *m_pItem; }
183
8c21905b 184private:
d2ed74b9 185 LV_CONV_BUF *m_buf;
8c21905b 186
d2ed74b9
VZ
187 LV_ITEM_NATIVE *m_pItem;
188 LV_ITEM_NATIVE m_item;
22f3361e
VZ
189
190 DECLARE_NO_COPY_CLASS(wxLV_ITEM)
8c21905b
VS
191};
192
7cf46fdb
VZ
193///////////////////////////////////////////////////////
194// Problem:
73d8c5fd
RD
195// The MSW version had problems with SetTextColour() et
196// al as the wxListItemAttr's were stored keyed on the
197// item index. If a item was inserted anywhere but the end
198// of the list the the text attributes (colour etc) for
7cf46fdb 199// the following items were out of sync.
73d8c5fd 200//
7cf46fdb 201// Solution:
73d8c5fd 202// Under MSW the only way to associate data with a List
43e8916f 203// item independent of its position in the list is to
73d8c5fd
RD
204// store a pointer to it in its lParam attribute. However
205// user programs are already using this (via the
7cf46fdb 206// SetItemData() GetItemData() calls).
73d8c5fd
RD
207//
208// However what we can do is store a pointer to a
209// structure which contains the attributes we want *and*
7cf46fdb 210// a lParam for the users data, e.g.
73d8c5fd 211//
7cf46fdb
VZ
212// class wxListItemInternalData
213// {
214// public:
73d8c5fd 215// wxListItemAttr *attr;
7cf46fdb
VZ
216// long lParam; // user data
217// };
73d8c5fd
RD
218//
219// To conserve memory, a wxListItemInternalData is
220// only allocated for a LV_ITEM if text attributes or
7cf46fdb
VZ
221// user data(lparam) are being set.
222
223
224// class wxListItemInternalData
225class wxListItemInternalData
226{
227public:
73d8c5fd 228 wxListItemAttr *attr;
7cf46fdb
VZ
229 LPARAM lParam; // user data
230
231 wxListItemInternalData() : attr(NULL), lParam(0) {}
232 ~wxListItemInternalData()
233 {
234 if (attr)
235 delete attr;
47b378bd 236 }
22f3361e
VZ
237
238 DECLARE_NO_COPY_CLASS(wxListItemInternalData)
7cf46fdb
VZ
239};
240
241// Get the internal data structure
6149de71 242static wxListItemInternalData *wxGetInternalData(HWND hwnd, long itemId);
97c611f8 243static wxListItemInternalData *wxGetInternalData(const wxListCtrl *ctl, long itemId);
e6b1317b 244static wxListItemAttr *wxGetInternalDataAttr(const wxListCtrl *ctl, long itemId);
6149de71 245static void wxDeleteInternalData(wxListCtrl* ctl, long itemId);
7cf46fdb
VZ
246
247
786a2425 248#if wxUSE_EXTENDED_RTTI
bc9fb572
JS
249WX_DEFINE_FLAGS( wxListCtrlStyle )
250
321239b6 251wxBEGIN_FLAGS( wxListCtrlStyle )
bc9fb572
JS
252 // new style border flags, we put them first to
253 // use them for streaming out
321239b6
SC
254 wxFLAGS_MEMBER(wxBORDER_SIMPLE)
255 wxFLAGS_MEMBER(wxBORDER_SUNKEN)
256 wxFLAGS_MEMBER(wxBORDER_DOUBLE)
257 wxFLAGS_MEMBER(wxBORDER_RAISED)
258 wxFLAGS_MEMBER(wxBORDER_STATIC)
259 wxFLAGS_MEMBER(wxBORDER_NONE)
598ddd96 260
bc9fb572 261 // old style border flags
321239b6
SC
262 wxFLAGS_MEMBER(wxSIMPLE_BORDER)
263 wxFLAGS_MEMBER(wxSUNKEN_BORDER)
264 wxFLAGS_MEMBER(wxDOUBLE_BORDER)
265 wxFLAGS_MEMBER(wxRAISED_BORDER)
266 wxFLAGS_MEMBER(wxSTATIC_BORDER)
cb0afb26 267 wxFLAGS_MEMBER(wxBORDER)
bc9fb572
JS
268
269 // standard window styles
321239b6
SC
270 wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
271 wxFLAGS_MEMBER(wxCLIP_CHILDREN)
272 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
273 wxFLAGS_MEMBER(wxWANTS_CHARS)
cb0afb26 274 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
321239b6
SC
275 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
276 wxFLAGS_MEMBER(wxVSCROLL)
277 wxFLAGS_MEMBER(wxHSCROLL)
278
279 wxFLAGS_MEMBER(wxLC_LIST)
280 wxFLAGS_MEMBER(wxLC_REPORT)
281 wxFLAGS_MEMBER(wxLC_ICON)
282 wxFLAGS_MEMBER(wxLC_SMALL_ICON)
283 wxFLAGS_MEMBER(wxLC_ALIGN_TOP)
284 wxFLAGS_MEMBER(wxLC_ALIGN_LEFT)
285 wxFLAGS_MEMBER(wxLC_AUTOARRANGE)
286 wxFLAGS_MEMBER(wxLC_USER_TEXT)
287 wxFLAGS_MEMBER(wxLC_EDIT_LABELS)
288 wxFLAGS_MEMBER(wxLC_NO_HEADER)
289 wxFLAGS_MEMBER(wxLC_SINGLE_SEL)
290 wxFLAGS_MEMBER(wxLC_SORT_ASCENDING)
291 wxFLAGS_MEMBER(wxLC_SORT_DESCENDING)
292 wxFLAGS_MEMBER(wxLC_VIRTUAL)
293
294wxEND_FLAGS( wxListCtrlStyle )
bc9fb572 295
786a2425
SC
296IMPLEMENT_DYNAMIC_CLASS_XTI(wxListCtrl, wxControl,"wx/listctrl.h")
297
321239b6 298wxBEGIN_PROPERTIES_TABLE(wxListCtrl)
598ddd96 299 wxEVENT_PROPERTY( TextUpdated , wxEVT_COMMAND_TEXT_UPDATED , wxCommandEvent )
c5ca409b 300
af498247 301 wxPROPERTY_FLAGS( WindowStyle , wxListCtrlStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
321239b6 302wxEND_PROPERTIES_TABLE()
786a2425 303
321239b6
SC
304wxBEGIN_HANDLERS_TABLE(wxListCtrl)
305wxEND_HANDLERS_TABLE()
786a2425 306
598ddd96 307wxCONSTRUCTOR_5( wxListCtrl , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
786a2425
SC
308
309/*
9d55bfef 310 TODO : Expose more information of a list's layout etc. via appropriate objects (a la NotebookPageInfo)
786a2425
SC
311*/
312#else
8f177c8e 313IMPLEMENT_DYNAMIC_CLASS(wxListCtrl, wxControl)
786a2425
SC
314#endif
315
bf9b6266 316IMPLEMENT_DYNAMIC_CLASS(wxListView, wxListCtrl)
8f177c8e 317IMPLEMENT_DYNAMIC_CLASS(wxListItem, wxObject)
2bda0e17 318
2d33aec9
VZ
319IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxNotifyEvent)
320
2702ed5a
JS
321BEGIN_EVENT_TABLE(wxListCtrl, wxControl)
322 EVT_PAINT(wxListCtrl::OnPaint)
323END_EVENT_TABLE()
324
edccf428
VZ
325// ============================================================================
326// implementation
327// ============================================================================
328
329// ----------------------------------------------------------------------------
330// wxListCtrl construction
331// ----------------------------------------------------------------------------
332
bdc72a22 333void wxListCtrl::Init()
2bda0e17 334{
0b5efdc7
VZ
335 m_imageListNormal = NULL;
336 m_imageListSmall = NULL;
337 m_imageListState = NULL;
598ddd96 338 m_ownsImageListNormal = m_ownsImageListSmall = m_ownsImageListState = false;
2bda0e17 339 m_colCount = 0;
68c124a1 340 m_count = 0;
598ddd96 341 m_ignoreChangeMessages = false;
bbcdf8bc 342 m_textCtrl = NULL;
598ddd96
WS
343 m_AnyInternalData = false;
344 m_hasAnyAttr = false;
2bda0e17
KB
345}
346
0b5efdc7
VZ
347bool wxListCtrl::Create(wxWindow *parent,
348 wxWindowID id,
349 const wxPoint& pos,
350 const wxSize& size,
351 long style,
97c611f8 352 const wxValidator& validator,
0b5efdc7 353 const wxString& name)
2bda0e17 354{
97c611f8 355 if ( !CreateControl(parent, id, pos, size, style, validator, name) )
598ddd96 356 return false;
11b6a93b 357
f31a4098 358 if ( !MSWCreateControl(WC_LISTVIEW, wxEmptyString, pos, size) )
598ddd96 359 return false;
2bda0e17 360
97c611f8
VZ
361 // explicitly say that we want to use Unicode because otherwise we get ANSI
362 // versions of _some_ messages (notably LVN_GETDISPINFOA) in MSLU build
9a63feff 363 wxSetCCUnicodeFormat(GetHwnd());
2bda0e17 364
6e21a3db
KH
365 // We must set the default text colour to the system/theme color, otherwise
366 // GetTextColour will always return black
367 SetTextColour(GetDefaultAttributes().colFg);
368
04d24675
VZ
369 if ( InReportView() )
370 MSWSetExListStyles();
371
372 return true;
373}
374
375void wxListCtrl::MSWSetExListStyles()
376{
16a0ccd0
VZ
377 // for comctl32.dll v 4.70+ we want to have some non default extended
378 // styles because it's prettier (and also because wxGTK does it like this)
04d24675 379 if ( wxApp::GetComCtl32Version() >= 470 )
97c611f8 380 {
67d3fc49
VZ
381 ::SendMessage
382 (
383 GetHwnd(), LVM_SETEXTENDEDLISTVIEWSTYLE, 0,
2036bdd3
VZ
384 // LVS_EX_LABELTIP shouldn't be used under Windows CE where it's
385 // not defined in the SDK headers
386#ifdef LVS_EX_LABELTIP
67d3fc49 387 LVS_EX_LABELTIP |
2036bdd3 388#endif
67d3fc49
VZ
389 LVS_EX_FULLROWSELECT |
390 LVS_EX_SUBITEMIMAGES |
391 // normally this should be governed by a style as it's probably not
392 // always appropriate, but we don't have any free styles left and
393 // it seems better to enable it by default than disable
394 LVS_EX_HEADERDRAGDROP
395 );
97c611f8 396 }
97c611f8 397}
2bda0e17 398
97c611f8
VZ
399WXDWORD wxListCtrl::MSWGetStyle(long style, WXDWORD *exstyle) const
400{
401 WXDWORD wstyle = wxControl::MSWGetStyle(style, exstyle);
2bda0e17 402
97c611f8 403 wstyle |= LVS_SHAREIMAGELISTS | LVS_SHOWSELALWAYS;
b0766406 404
97c611f8
VZ
405#ifdef __WXDEBUG__
406 size_t nModes = 0;
edccf428 407
97c611f8
VZ
408 #define MAP_MODE_STYLE(wx, ms) \
409 if ( style & (wx) ) { wstyle |= (ms); nModes++; }
410#else // !__WXDEBUG__
411 #define MAP_MODE_STYLE(wx, ms) \
412 if ( style & (wx) ) wstyle |= (ms);
413#endif // __WXDEBUG__
edccf428 414
97c611f8
VZ
415 MAP_MODE_STYLE(wxLC_ICON, LVS_ICON)
416 MAP_MODE_STYLE(wxLC_SMALL_ICON, LVS_SMALLICON)
417 MAP_MODE_STYLE(wxLC_LIST, LVS_LIST)
418 MAP_MODE_STYLE(wxLC_REPORT, LVS_REPORT)
edccf428 419
97c611f8
VZ
420 wxASSERT_MSG( nModes == 1,
421 _T("wxListCtrl style should have exactly one mode bit set") );
edccf428 422
97c611f8 423#undef MAP_MODE_STYLE
2bda0e17 424
97c611f8
VZ
425 if ( style & wxLC_ALIGN_LEFT )
426 wstyle |= LVS_ALIGNLEFT;
2bda0e17 427
97c611f8
VZ
428 if ( style & wxLC_ALIGN_TOP )
429 wstyle |= LVS_ALIGNTOP;
2bda0e17 430
97c611f8
VZ
431 if ( style & wxLC_AUTOARRANGE )
432 wstyle |= LVS_AUTOARRANGE;
f8352807 433
97c611f8
VZ
434 if ( style & wxLC_NO_SORT_HEADER )
435 wstyle |= LVS_NOSORTHEADER;
0b5efdc7 436
97c611f8
VZ
437 if ( style & wxLC_NO_HEADER )
438 wstyle |= LVS_NOCOLUMNHEADER;
0b5efdc7 439
97c611f8
VZ
440 if ( style & wxLC_EDIT_LABELS )
441 wstyle |= LVS_EDITLABELS;
bfc8138f 442
97c611f8
VZ
443 if ( style & wxLC_SINGLE_SEL )
444 wstyle |= LVS_SINGLESEL;
445
446 if ( style & wxLC_SORT_ASCENDING )
0b5efdc7 447 {
97c611f8
VZ
448 wstyle |= LVS_SORTASCENDING;
449
450 wxASSERT_MSG( !(style & wxLC_SORT_DESCENDING),
451 _T("can't sort in ascending and descending orders at once") );
0b5efdc7 452 }
97c611f8
VZ
453 else if ( style & wxLC_SORT_DESCENDING )
454 wstyle |= LVS_SORTDESCENDING;
f8352807 455
97c611f8
VZ
456#if !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )
457 if ( style & wxLC_VIRTUAL )
458 {
2a1f999f 459 int ver = wxApp::GetComCtl32Version();
97c611f8
VZ
460 if ( ver < 470 )
461 {
462 wxLogWarning(_("Please install a newer version of comctl32.dll\n(at least version 4.70 is required but you have %d.%02d)\nor this program won't operate correctly."),
463 ver / 100, ver % 100);
464 }
2bda0e17 465
97c611f8
VZ
466 wstyle |= LVS_OWNERDATA;
467 }
468#endif // ancient cygwin
2bda0e17 469
97c611f8 470 return wstyle;
2bda0e17
KB
471}
472
edccf428
VZ
473void wxListCtrl::UpdateStyle()
474{
97c611f8 475 if ( GetHwnd() )
edccf428
VZ
476 {
477 // The new window view style
97c611f8 478 DWORD dwStyleNew = MSWGetStyle(m_windowStyle, NULL);
edccf428 479
6e2fef03
VZ
480 // some styles are not returned by MSWGetStyle()
481 if ( IsShown() )
482 dwStyleNew |= WS_VISIBLE;
483
910484a6 484 // Get the current window style.
edccf428
VZ
485 DWORD dwStyleOld = ::GetWindowLong(GetHwnd(), GWL_STYLE);
486
6e2fef03
VZ
487 // we don't have wxVSCROLL style, but the list control may have it,
488 // don't change it then
489 dwStyleNew |= dwStyleOld & (WS_HSCROLL | WS_VSCROLL);
490
910484a6 491 // Only set the window style if the view bits have changed.
edccf428
VZ
492 if ( dwStyleOld != dwStyleNew )
493 {
494 ::SetWindowLong(GetHwnd(), GWL_STYLE, dwStyleNew);
04d24675
VZ
495
496 // if we switched to the report view, set the extended styles for
497 // it too
498 if ( !(dwStyleOld & LVS_REPORT) && (dwStyleNew & LVS_REPORT) )
499 MSWSetExListStyles();
edccf428
VZ
500 }
501 }
502}
503
7cf46fdb 504void wxListCtrl::FreeAllInternalData()
2bda0e17 505{
7cf46fdb 506 if (m_AnyInternalData)
73d8c5fd 507 {
7cf46fdb 508 int n = GetItemCount();
6932a32c 509
598ddd96 510 m_ignoreChangeMessages = true;
5cb598ae 511 for (int i = 0; i < n; i++)
6149de71 512 wxDeleteInternalData(this, i);
598ddd96 513 m_ignoreChangeMessages = false;
6149de71 514
598ddd96 515 m_AnyInternalData = false;
73d8c5fd 516 }
6932a32c 517}
d62228a6 518
5cd4cb75 519void wxListCtrl::DeleteEditControl()
6932a32c 520{
d62228a6 521 if ( m_textCtrl )
bbcdf8bc 522 {
7bf1474a 523 m_textCtrl->UnsubclassWin();
f3076f9f 524 m_textCtrl->SetHWND(0);
0b5efdc7
VZ
525 delete m_textCtrl;
526 m_textCtrl = NULL;
bbcdf8bc 527 }
5cd4cb75
VZ
528}
529
530wxListCtrl::~wxListCtrl()
531{
532 FreeAllInternalData();
533
534 DeleteEditControl();
33ac7e6f 535
07763c99
VZ
536 if (m_ownsImageListNormal)
537 delete m_imageListNormal;
538 if (m_ownsImageListSmall)
539 delete m_imageListSmall;
540 if (m_ownsImageListState)
541 delete m_imageListState;
2bda0e17
KB
542}
543
edccf428
VZ
544// ----------------------------------------------------------------------------
545// set/get/change style
546// ----------------------------------------------------------------------------
547
2bda0e17 548// Add or remove a single window style
debe6624 549void wxListCtrl::SetSingleStyle(long style, bool add)
2bda0e17 550{
0b5efdc7 551 long flag = GetWindowStyleFlag();
2bda0e17 552
0b5efdc7 553 // Get rid of conflicting styles
acb62b84
VZ
554 if ( add )
555 {
0b5efdc7 556 if ( style & wxLC_MASK_TYPE)
edccf428 557 flag = flag & ~wxLC_MASK_TYPE;
0b5efdc7 558 if ( style & wxLC_MASK_ALIGN )
edccf428 559 flag = flag & ~wxLC_MASK_ALIGN;
0b5efdc7 560 if ( style & wxLC_MASK_SORT )
edccf428 561 flag = flag & ~wxLC_MASK_SORT;
acb62b84 562 }
2bda0e17 563
6e2fef03
VZ
564 if ( add )
565 flag |= style;
0b5efdc7 566 else
6e2fef03 567 flag &= ~style;
2bda0e17 568
6e2fef03 569 SetWindowStyleFlag(flag);
2bda0e17
KB
570}
571
572// Set the whole window style
debe6624 573void wxListCtrl::SetWindowStyleFlag(long flag)
2bda0e17 574{
6e2fef03
VZ
575 if ( flag != m_windowStyle )
576 {
9a8d75f1 577 wxControl::SetWindowStyleFlag(flag);
6e2fef03
VZ
578
579 UpdateStyle();
2bda0e17 580
6e2fef03
VZ
581 Refresh();
582 }
2bda0e17
KB
583}
584
edccf428
VZ
585// ----------------------------------------------------------------------------
586// accessors
587// ----------------------------------------------------------------------------
588
39c7a53c
VZ
589/* static */ wxVisualAttributes
590wxListCtrl::GetClassDefaultAttributes(wxWindowVariant variant)
591{
592 wxVisualAttributes attrs = GetCompositeControlsDefaultAttributes(variant);
593
594 // common controls have their own default font
595 attrs.font = wxGetCCDefaultFont();
596
597 return attrs;
598}
599
91b4c08d
VZ
600// Sets the foreground, i.e. text, colour
601bool wxListCtrl::SetForegroundColour(const wxColour& col)
602{
603 if ( !wxWindow::SetForegroundColour(col) )
598ddd96 604 return false;
91b4c08d
VZ
605
606 ListView_SetTextColor(GetHwnd(), wxColourToRGB(col));
607
598ddd96 608 return true;
91b4c08d
VZ
609}
610
611// Sets the background colour
cc2b7472 612bool wxListCtrl::SetBackgroundColour(const wxColour& col)
2bda0e17 613{
cc2b7472 614 if ( !wxWindow::SetBackgroundColour(col) )
598ddd96 615 return false;
2bda0e17 616
91b4c08d
VZ
617 // we set the same colour for both the "empty" background and the items
618 // background
619 COLORREF color = wxColourToRGB(col);
620 ListView_SetBkColor(GetHwnd(), color);
621 ListView_SetTextBkColor(GetHwnd(), color);
cc2b7472 622
598ddd96 623 return true;
2bda0e17
KB
624}
625
626// Gets information about this column
debe6624 627bool wxListCtrl::GetColumn(int col, wxListItem& item) const
2bda0e17 628{
0b5efdc7 629 LV_COLUMN lvCol;
6f806543 630 wxZeroMemory(lvCol);
0b5efdc7 631
37094564
RD
632 lvCol.mask = LVCF_WIDTH;
633
0b5efdc7
VZ
634 if ( item.m_mask & wxLIST_MASK_TEXT )
635 {
636 lvCol.mask |= LVCF_TEXT;
837e5743 637 lvCol.pszText = new wxChar[513];
0b5efdc7
VZ
638 lvCol.cchTextMax = 512;
639 }
640
37094564
RD
641 if ( item.m_mask & wxLIST_MASK_FORMAT )
642 {
643 lvCol.mask |= LVCF_FMT;
644 }
645
646 if ( item.m_mask & wxLIST_MASK_IMAGE )
647 {
648 lvCol.mask |= LVCF_IMAGE;
649 }
650
0b190ffc 651 bool success = ListView_GetColumn(GetHwnd(), col, &lvCol) != 0;
0b5efdc7
VZ
652
653 // item.m_subItem = lvCol.iSubItem;
654 item.m_width = lvCol.cx;
655
656 if ( (item.m_mask & wxLIST_MASK_TEXT) && lvCol.pszText )
657 {
658 item.m_text = lvCol.pszText;
659 delete[] lvCol.pszText;
660 }
661
662 if ( item.m_mask & wxLIST_MASK_FORMAT )
663 {
0b190ffc
RD
664 switch (lvCol.fmt & LVCFMT_JUSTIFYMASK) {
665 case LVCFMT_LEFT:
666 item.m_format = wxLIST_FORMAT_LEFT;
667 break;
668 case LVCFMT_RIGHT:
669 item.m_format = wxLIST_FORMAT_RIGHT;
670 break;
671 case LVCFMT_CENTER:
672 item.m_format = wxLIST_FORMAT_CENTRE;
673 break;
674 default:
675 item.m_format = -1; // Unknown?
676 break;
677 }
2bda0e17
KB
678 }
679
5b59df83
VZ
680 // the column images were not supported in older versions but how to check
681 // for this? we can't use _WIN32_IE because we always define it to a very
682 // high value, so see if another symbol which is only defined starting from
683 // comctl32.dll 4.70 is available
684#ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
37094564
RD
685 if ( item.m_mask & wxLIST_MASK_IMAGE )
686 {
687 item.m_image = lvCol.iImage;
688 }
5b59df83 689#endif // LVCOLUMN::iImage exists
37094564 690
0b5efdc7 691 return success;
2bda0e17
KB
692}
693
694// Sets information about this column
fbfb8bcc 695bool wxListCtrl::SetColumn(int col, const wxListItem& item)
2bda0e17 696{
0b5efdc7 697 LV_COLUMN lvCol;
e64658ed 698 wxConvertToMSWListCol(GetHwnd(), col, item, lvCol);
0b5efdc7 699
6f806543 700 return ListView_SetColumn(GetHwnd(), col, &lvCol) != 0;
2bda0e17
KB
701}
702
703// Gets the column width
debe6624 704int wxListCtrl::GetColumnWidth(int col) const
2bda0e17 705{
edccf428 706 return ListView_GetColumnWidth(GetHwnd(), col);
2bda0e17
KB
707}
708
709// Sets the column width
debe6624 710bool wxListCtrl::SetColumnWidth(int col, int width)
2bda0e17 711{
0b5efdc7 712 if ( m_windowStyle & wxLC_LIST )
514ee250 713 col = 0;
2bda0e17 714
514ee250
VZ
715 if ( width == wxLIST_AUTOSIZE)
716 width = LVSCW_AUTOSIZE;
717 else if ( width == wxLIST_AUTOSIZE_USEHEADER)
718 width = LVSCW_AUTOSIZE_USEHEADER;
2bda0e17 719
514ee250 720 return ListView_SetColumnWidth(GetHwnd(), col, width) != 0;
2bda0e17
KB
721}
722
67d3fc49
VZ
723// ----------------------------------------------------------------------------
724// columns order
725// ----------------------------------------------------------------------------
726
80cc5fc7 727int wxListCtrl::GetColumnIndexFromOrder(int order) const
67d3fc49
VZ
728{
729 const int numCols = GetColumnCount();
80cc5fc7
VZ
730 wxCHECK_MSG( order >= 0 && order < numCols, -1,
731 _T("Column position out of bounds") );
67d3fc49
VZ
732
733 wxArrayInt indexArray(numCols);
67d3fc49
VZ
734 if ( !ListView_GetColumnOrderArray(GetHwnd(), numCols, &indexArray[0]) )
735 return -1;
736
80cc5fc7 737 return indexArray[order];
67d3fc49
VZ
738}
739
80cc5fc7 740int wxListCtrl::GetColumnOrder(int col) const
67d3fc49
VZ
741{
742 const int numCols = GetColumnCount();
80cc5fc7 743 wxASSERT_MSG( col >= 0 && col < numCols, _T("Column index out of bounds") );
67d3fc49
VZ
744
745 wxArrayInt indexArray(numCols);
67d3fc49
VZ
746 if ( !ListView_GetColumnOrderArray(GetHwnd(), numCols, &indexArray[0]) )
747 return -1;
748
80cc5fc7 749 for ( int pos = 0; pos < numCols; pos++ )
67d3fc49 750 {
80cc5fc7
VZ
751 if ( indexArray[pos] == col )
752 return pos;
67d3fc49
VZ
753 }
754
755 wxFAIL_MSG( _T("no column with with given order?") );
756
757 return -1;
758}
759
760// Gets the column order for all columns
761wxArrayInt wxListCtrl::GetColumnsOrder() const
762{
763 const int numCols = GetColumnCount();
764
765 wxArrayInt orders(numCols);
766 if ( !ListView_GetColumnOrderArray(GetHwnd(), numCols, &orders[0]) )
767 orders.clear();
768
769 return orders;
770}
771
772// Sets the column order for all columns
773bool wxListCtrl::SetColumnsOrder(const wxArrayInt& orders)
774{
775 const int numCols = GetColumnCount();
776
777 wxCHECK_MSG( orders.size() == (size_t)numCols, false,
778 _T("wrong number of elements in column orders array") );
779
780 return ListView_SetColumnOrderArray(GetHwnd(), numCols, &orders[0]) != 0;
781}
782
783
2bda0e17
KB
784// Gets the number of items that can fit vertically in the
785// visible area of the list control (list or report view)
786// or the total number of items in the list control (icon
787// or small icon view)
c42404a5 788int wxListCtrl::GetCountPerPage() const
2bda0e17 789{
edccf428 790 return ListView_GetCountPerPage(GetHwnd());
2bda0e17
KB
791}
792
793// Gets the edit control for editing labels.
c42404a5 794wxTextCtrl* wxListCtrl::GetEditControl() const
2bda0e17 795{
508b6523
VZ
796 // first check corresponds to the case when the label editing was started
797 // by user and hence m_textCtrl wasn't created by EditLabel() at all, while
798 // the second case corresponds to us being called from inside EditLabel()
799 // (e.g. from a user wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT handler): in this
800 // case EditLabel() did create the control but it didn't have an HWND to
801 // initialize it with yet
802 if ( !m_textCtrl || !m_textCtrl->GetHWND() )
803 {
804 HWND hwndEdit = ListView_GetEditControl(GetHwnd());
805 if ( hwndEdit )
806 {
5c33522f 807 wxListCtrl * const self = const_cast<wxListCtrl *>(this);
508b6523
VZ
808
809 if ( !m_textCtrl )
810 self->m_textCtrl = new wxTextCtrl;
811 self->InitEditControl((WXHWND)hwndEdit);
812 }
813 }
814
bbcdf8bc 815 return m_textCtrl;
2bda0e17
KB
816}
817
818// Gets information about the item
819bool wxListCtrl::GetItem(wxListItem& info) const
820{
0b5efdc7 821 LV_ITEM lvItem;
11c7d5b6 822 wxZeroMemory(lvItem);
2bda0e17 823
0b5efdc7 824 lvItem.iItem = info.m_itemId;
fc5a93cd 825 lvItem.iSubItem = info.m_col;
0b5efdc7
VZ
826
827 if ( info.m_mask & wxLIST_MASK_TEXT )
828 {
829 lvItem.mask |= LVIF_TEXT;
837e5743 830 lvItem.pszText = new wxChar[513];
0b5efdc7
VZ
831 lvItem.cchTextMax = 512;
832 }
833 else
834 {
835 lvItem.pszText = NULL;
836 }
837
838 if (info.m_mask & wxLIST_MASK_DATA)
edccf428 839 lvItem.mask |= LVIF_PARAM;
0b5efdc7 840
2189c644
JS
841 if (info.m_mask & wxLIST_MASK_IMAGE)
842 lvItem.mask |= LVIF_IMAGE;
843
0b5efdc7
VZ
844 if ( info.m_mask & wxLIST_MASK_STATE )
845 {
846 lvItem.mask |= LVIF_STATE;
7c392815 847 wxConvertToMSWFlags(0, info.m_stateMask, lvItem);
0b5efdc7
VZ
848 }
849
850 bool success = ListView_GetItem((HWND)GetHWND(), &lvItem) != 0;
851 if ( !success )
852 {
853 wxLogError(_("Couldn't retrieve information about list control item %d."),
854 lvItem.iItem);
855 }
856 else
857 {
dccde0c0
VZ
858 // give NULL as hwnd as we already have everything we need
859 wxConvertFromMSWListItem(NULL, info, lvItem);
0b5efdc7
VZ
860 }
861
862 if (lvItem.pszText)
863 delete[] lvItem.pszText;
864
865 return success;
2bda0e17
KB
866}
867
868// Sets information about the item
869bool wxListCtrl::SetItem(wxListItem& info)
870{
4ce04fd8
VZ
871 const long id = info.GetId();
872 wxCHECK_MSG( id >= 0 && id < GetItemCount(), false,
873 _T("invalid item index in SetItem") );
874
0b5efdc7 875 LV_ITEM item;
2bda0e17 876 wxConvertToMSWListItem(this, info, item);
bdc72a22 877
7cf46fdb
VZ
878 // we never update the lParam if it contains our pointer
879 // to the wxListItemInternalData structure
880 item.mask &= ~LVIF_PARAM;
881
882 // check if setting attributes or lParam
883 if (info.HasAttributes() || (info.m_mask & wxLIST_MASK_DATA))
884 {
885 // get internal item data
886 // perhaps a cache here ?
4ce04fd8 887 wxListItemInternalData *data = wxGetInternalData(this, id);
73d8c5fd 888
7cf46fdb
VZ
889 if (! data)
890 {
891 // need to set it
598ddd96 892 m_AnyInternalData = true;
7cf46fdb
VZ
893 data = new wxListItemInternalData();
894 item.lParam = (LPARAM) data;
895 item.mask |= LVIF_PARAM;
896 };
897
898
899 // user data
900 if (info.m_mask & wxLIST_MASK_DATA)
901 data->lParam = info.m_data;
902
903 // attributes
0f3888a5 904 if ( info.HasAttributes() )
7cf46fdb 905 {
0f3888a5
VZ
906 const wxListItemAttr& attrNew = *info.GetAttributes();
907
908 // don't overwrite the already set attributes if we have them
909 if ( data->attr )
910 data->attr->AssignFrom(attrNew);
7cf46fdb 911 else
0f3888a5 912 data->attr = new wxListItemAttr(attrNew);
7cf46fdb
VZ
913 };
914 };
915
916
2d33aec9
VZ
917 // we could be changing only the attribute in which case we don't need to
918 // call ListView_SetItem() at all
919 if ( item.mask )
bdc72a22 920 {
2d33aec9
VZ
921 item.cchTextMax = 0;
922 if ( !ListView_SetItem(GetHwnd(), &item) )
923 {
924 wxLogDebug(_T("ListView_SetItem() failed"));
2702ed5a 925
598ddd96 926 return false;
2d33aec9 927 }
233d0295 928 }
2702ed5a 929
233d0295
VZ
930 // we need to update the item immediately to show the new image
931 bool updateNow = (info.m_mask & wxLIST_MASK_IMAGE) != 0;
2702ed5a 932
233d0295
VZ
933 // check whether it has any custom attributes
934 if ( info.HasAttributes() )
935 {
598ddd96 936 m_hasAnyAttr = true;
233d0295
VZ
937
938 // if the colour has changed, we must redraw the item
598ddd96 939 updateNow = true;
bdc72a22 940 }
bdc72a22 941
233d0295 942 if ( updateNow )
7cc98b3e 943 {
233d0295 944 // we need this to make the change visible right now
2d33aec9 945 RefreshItem(item.iItem);
7cc98b3e
VZ
946 }
947
598ddd96 948 return true;
2bda0e17
KB
949}
950
debe6624 951long wxListCtrl::SetItem(long index, int col, const wxString& label, int imageId)
2bda0e17 952{
0b5efdc7
VZ
953 wxListItem info;
954 info.m_text = label;
955 info.m_mask = wxLIST_MASK_TEXT;
956 info.m_itemId = index;
957 info.m_col = col;
958 if ( imageId > -1 )
959 {
960 info.m_image = imageId;
961 info.m_mask |= wxLIST_MASK_IMAGE;
962 }
963 return SetItem(info);
2bda0e17
KB
964}
965
966
967// Gets the item state
debe6624 968int wxListCtrl::GetItemState(long item, long stateMask) const
2bda0e17 969{
0b5efdc7 970 wxListItem info;
2bda0e17 971
edccf428 972 info.m_mask = wxLIST_MASK_STATE;
0b5efdc7
VZ
973 info.m_stateMask = stateMask;
974 info.m_itemId = item;
2bda0e17 975
0b5efdc7
VZ
976 if (!GetItem(info))
977 return 0;
2bda0e17 978
0b5efdc7 979 return info.m_state;
2bda0e17
KB
980}
981
982// Sets the item state
debe6624 983bool wxListCtrl::SetItemState(long item, long state, long stateMask)
2bda0e17 984{
8dff2b5c
VZ
985 // NB: don't use SetItem() here as it doesn't work with the virtual list
986 // controls
987 LV_ITEM lvItem;
988 wxZeroMemory(lvItem);
2bda0e17 989
8dff2b5c 990 wxConvertToMSWFlags(state, stateMask, lvItem);
2bda0e17 991
b720b86b
VZ
992 const bool changingFocus = (stateMask & wxLIST_STATE_FOCUSED) &&
993 (state & wxLIST_STATE_FOCUSED);
994
2d33aec9 995 // for the virtual list controls we need to refresh the previously focused
ad9f477d
VZ
996 // item manually when changing focus without changing selection
997 // programmatically because otherwise it keeps its focus rectangle until
998 // next repaint (yet another comctl32 bug)
2d33aec9 999 long focusOld;
b720b86b 1000 if ( IsVirtual() && changingFocus )
2d33aec9
VZ
1001 {
1002 focusOld = GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_FOCUSED);
1003 }
1004 else
1005 {
1006 focusOld = -1;
1007 }
1008
8dff2b5c
VZ
1009 if ( !::SendMessage(GetHwnd(), LVM_SETITEMSTATE,
1010 (WPARAM)item, (LPARAM)&lvItem) )
1011 {
1012 wxLogLastError(_T("ListView_SetItemState"));
1013
598ddd96 1014 return false;
8dff2b5c
VZ
1015 }
1016
2d33aec9
VZ
1017 if ( focusOld != -1 )
1018 {
ad9f477d
VZ
1019 // no need to refresh the item if it was previously selected, it would
1020 // only result in annoying flicker
1021 if ( !(GetItemState(focusOld,
1022 wxLIST_STATE_SELECTED) & wxLIST_STATE_SELECTED) )
1023 {
1024 RefreshItem(focusOld);
1025 }
2d33aec9
VZ
1026 }
1027
b720b86b
VZ
1028 // we expect the selection anchor, i.e. the item from which multiple
1029 // selection (such as performed with e.g. Shift-arrows) starts, to be the
1030 // same as the currently focused item but the native control doesn't update
1031 // it when we change focus and leaves at the last item it set itself focus
1032 // to, so do it explicitly
1033 if ( changingFocus && !HasFlag(wxLC_SINGLE_SEL) )
1034 {
1035 ListView_SetSelectionMark(GetHwnd(), item);
1036 }
1037
598ddd96 1038 return true;
2bda0e17
KB
1039}
1040
1041// Sets the item image
33ac7e6f 1042bool wxListCtrl::SetItemImage(long item, int image, int WXUNUSED(selImage))
06db67bc
RD
1043{
1044 return SetItemColumnImage(item, 0, image);
1045}
1046
1047// Sets the item image
1048bool wxListCtrl::SetItemColumnImage(long item, long column, int image)
2bda0e17 1049{
0b5efdc7 1050 wxListItem info;
2bda0e17 1051
edccf428 1052 info.m_mask = wxLIST_MASK_IMAGE;
0b5efdc7
VZ
1053 info.m_image = image;
1054 info.m_itemId = item;
06db67bc 1055 info.m_col = column;
2bda0e17 1056
0b5efdc7 1057 return SetItem(info);
2bda0e17
KB
1058}
1059
1060// Gets the item text
debe6624 1061wxString wxListCtrl::GetItemText(long item) const
2bda0e17 1062{
0b5efdc7 1063 wxListItem info;
2bda0e17 1064
edccf428 1065 info.m_mask = wxLIST_MASK_TEXT;
0b5efdc7 1066 info.m_itemId = item;
2bda0e17 1067
0b5efdc7 1068 if (!GetItem(info))
2b5f62a0 1069 return wxEmptyString;
0b5efdc7 1070 return info.m_text;
2bda0e17
KB
1071}
1072
1073// Sets the item text
debe6624 1074void wxListCtrl::SetItemText(long item, const wxString& str)
2bda0e17 1075{
0b5efdc7 1076 wxListItem info;
2bda0e17 1077
edccf428 1078 info.m_mask = wxLIST_MASK_TEXT;
0b5efdc7
VZ
1079 info.m_itemId = item;
1080 info.m_text = str;
2bda0e17 1081
0b5efdc7 1082 SetItem(info);
2bda0e17
KB
1083}
1084
1085// Gets the item data
81ce36aa 1086wxUIntPtr wxListCtrl::GetItemData(long item) const
2bda0e17 1087{
0b5efdc7 1088 wxListItem info;
2bda0e17 1089
edccf428 1090 info.m_mask = wxLIST_MASK_DATA;
0b5efdc7 1091 info.m_itemId = item;
2bda0e17 1092
0b5efdc7
VZ
1093 if (!GetItem(info))
1094 return 0;
1095 return info.m_data;
2bda0e17
KB
1096}
1097
1098// Sets the item data
9fcd0bf7 1099bool wxListCtrl::SetItemPtrData(long item, wxUIntPtr data)
2bda0e17 1100{
0b5efdc7 1101 wxListItem info;
2bda0e17 1102
edccf428 1103 info.m_mask = wxLIST_MASK_DATA;
0b5efdc7
VZ
1104 info.m_itemId = item;
1105 info.m_data = data;
2bda0e17 1106
0b5efdc7 1107 return SetItem(info);
2bda0e17
KB
1108}
1109
11ebea16
VZ
1110wxRect wxListCtrl::GetViewRect() const
1111{
929b7901 1112 wxRect rect;
11ebea16 1113
929b7901
VZ
1114 // ListView_GetViewRect() can only be used in icon and small icon views
1115 // (this is documented in MSDN and, indeed, it returns bogus results in
1116 // report view, at least with comctl32.dll v6 under Windows 2003)
1117 if ( HasFlag(wxLC_ICON | wxLC_SMALL_ICON) )
11ebea16 1118 {
929b7901
VZ
1119 RECT rc;
1120 if ( !ListView_GetViewRect(GetHwnd(), &rc) )
1121 {
1122 wxLogDebug(_T("ListView_GetViewRect() failed."));
1123
1124 wxZeroMemory(rc);
1125 }
11ebea16 1126
929b7901 1127 wxCopyRECTToRect(rc, rect);
11ebea16 1128 }
929b7901
VZ
1129 else if ( HasFlag(wxLC_REPORT) )
1130 {
1131 const long count = GetItemCount();
1132 if ( count )
1133 {
1134 GetItemRect(wxMin(GetTopItem() + GetCountPerPage(), count - 1), rect);
11ebea16 1135
929b7901
VZ
1136 // extend the rectangle to start at the top (we include the column
1137 // headers, if any, for compatibility with the generic version)
1138 rect.height += rect.y;
1139 rect.y = 0;
1140 }
1141 }
1142 else
1143 {
1144 wxFAIL_MSG( _T("not implemented in this mode") );
1145 }
11ebea16
VZ
1146
1147 return rect;
1148}
1149
2bda0e17 1150// Gets the item rectangle
16e93305 1151bool wxListCtrl::GetItemRect(long item, wxRect& rect, int code) const
164a7972
VZ
1152{
1153 return GetSubItemRect( item, wxLIST_GETSUBITEMRECT_WHOLEITEM, rect, code) ;
1154}
1155
164a7972 1156bool wxListCtrl::GetSubItemRect(long item, long subItem, wxRect& rect, int code) const
2bda0e17 1157{
e974c5d2
VZ
1158 // ListView_GetSubItemRect() doesn't do subItem error checking and returns
1159 // true even for the out of range values of it (even if the results are
1160 // completely bogus in this case), so we check item validity ourselves
1161 wxCHECK_MSG( subItem == wxLIST_GETSUBITEMRECT_WHOLEITEM ||
1162 (subItem >= 0 && subItem < GetColumnCount()),
1163 false, _T("invalid sub item index") );
2bda0e17 1164
2d33aec9 1165 int codeWin;
0b5efdc7 1166 if ( code == wxLIST_RECT_BOUNDS )
2d33aec9 1167 codeWin = LVIR_BOUNDS;
0b5efdc7 1168 else if ( code == wxLIST_RECT_ICON )
2d33aec9 1169 codeWin = LVIR_ICON;
0b5efdc7 1170 else if ( code == wxLIST_RECT_LABEL )
2d33aec9
VZ
1171 codeWin = LVIR_LABEL;
1172 else
1173 {
164a7972 1174 wxFAIL_MSG( _T("incorrect code in GetItemRect() / GetSubItemRect()") );
2d33aec9
VZ
1175 codeWin = LVIR_BOUNDS;
1176 }
2bda0e17 1177
e974c5d2 1178 RECT rectWin;
89cafab0 1179 if ( !wxGetListCtrlSubItemRect
e974c5d2
VZ
1180 (
1181 GetHwnd(),
1182 item,
1183 subItem == wxLIST_GETSUBITEMRECT_WHOLEITEM ? 0 : subItem,
1184 codeWin,
89cafab0 1185 rectWin
e974c5d2 1186 ) )
164a7972 1187 {
e974c5d2 1188 return false;
164a7972 1189 }
2bda0e17 1190
e974c5d2 1191 wxCopyRECTToRect(rectWin, rect);
2d33aec9 1192
67561862
VZ
1193 // there is no way to retrieve the first sub item bounding rectangle using
1194 // wxGetListCtrlSubItemRect() as 0 means the whole item, so we need to
1195 // truncate it at first column ourselves
1196 if ( subItem == 0 )
1197 rect.width = GetColumnWidth(0);
e974c5d2
VZ
1198
1199 return true;
2bda0e17
KB
1200}
1201
164a7972
VZ
1202
1203
1204
2bda0e17 1205// Gets the item position
debe6624 1206bool wxListCtrl::GetItemPosition(long item, wxPoint& pos) const
2bda0e17 1207{
0b5efdc7 1208 POINT pt;
2bda0e17 1209
edccf428 1210 bool success = (ListView_GetItemPosition(GetHwnd(), (int) item, &pt) != 0);
2bda0e17 1211
0b5efdc7
VZ
1212 pos.x = pt.x; pos.y = pt.y;
1213 return success;
2bda0e17
KB
1214}
1215
1216// Sets the item position.
debe6624 1217bool wxListCtrl::SetItemPosition(long item, const wxPoint& pos)
2bda0e17 1218{
edccf428 1219 return (ListView_SetItemPosition(GetHwnd(), (int) item, pos.x, pos.y) != 0);
2bda0e17
KB
1220}
1221
1222// Gets the number of items in the list control
c42404a5 1223int wxListCtrl::GetItemCount() const
2bda0e17 1224{
68c124a1 1225 return m_count;
2bda0e17
KB
1226}
1227
5db8d758
VZ
1228wxSize wxListCtrl::GetItemSpacing() const
1229{
66b9ec3d 1230 const int spacing = ListView_GetItemSpacing(GetHwnd(), (BOOL)HasFlag(wxLC_SMALL_ICON));
5db8d758
VZ
1231
1232 return wxSize(LOWORD(spacing), HIWORD(spacing));
1233}
1234
40ff126a
WS
1235#if WXWIN_COMPATIBILITY_2_6
1236
2bda0e17
KB
1237int wxListCtrl::GetItemSpacing(bool isSmall) const
1238{
edccf428 1239 return ListView_GetItemSpacing(GetHwnd(), (BOOL) isSmall);
2bda0e17
KB
1240}
1241
40ff126a
WS
1242#endif // WXWIN_COMPATIBILITY_2_6
1243
5b98eb2f
RL
1244void wxListCtrl::SetItemTextColour( long item, const wxColour &col )
1245{
1246 wxListItem info;
1247 info.m_itemId = item;
1248 info.SetTextColour( col );
1249 SetItem( info );
1250}
1251
1252wxColour wxListCtrl::GetItemTextColour( long item ) const
1253{
97c611f8
VZ
1254 wxColour col;
1255 wxListItemInternalData *data = wxGetInternalData(this, item);
1256 if ( data && data->attr )
1257 col = data->attr->GetTextColour();
1258
1259 return col;
5b98eb2f
RL
1260}
1261
1262void wxListCtrl::SetItemBackgroundColour( long item, const wxColour &col )
1263{
1264 wxListItem info;
1265 info.m_itemId = item;
1266 info.SetBackgroundColour( col );
1267 SetItem( info );
1268}
1269
1270wxColour wxListCtrl::GetItemBackgroundColour( long item ) const
1271{
97c611f8
VZ
1272 wxColour col;
1273 wxListItemInternalData *data = wxGetInternalData(this, item);
1274 if ( data && data->attr )
1275 col = data->attr->GetBackgroundColour();
1276
1277 return col;
5b98eb2f
RL
1278}
1279
35c2acd4
MW
1280void wxListCtrl::SetItemFont( long item, const wxFont &f )
1281{
1282 wxListItem info;
1283 info.m_itemId = item;
1284 info.SetFont( f );
1285 SetItem( info );
1286}
1287
1288wxFont wxListCtrl::GetItemFont( long item ) const
1289{
1290 wxFont f;
1291 wxListItemInternalData *data = wxGetInternalData(this, item);
1292 if ( data && data->attr )
1293 f = data->attr->GetFont();
1294
1295 return f;
1296}
1297
2bda0e17 1298// Gets the number of selected items in the list control
c42404a5 1299int wxListCtrl::GetSelectedItemCount() const
2bda0e17 1300{
edccf428 1301 return ListView_GetSelectedCount(GetHwnd());
2bda0e17
KB
1302}
1303
1304// Gets the text colour of the listview
c42404a5 1305wxColour wxListCtrl::GetTextColour() const
2bda0e17 1306{
6e21a3db
KH
1307 COLORREF ref = ListView_GetTextColor(GetHwnd());
1308 wxColour col(GetRValue(ref), GetGValue(ref), GetBValue(ref));
1309 return col;
2bda0e17
KB
1310}
1311
1312// Sets the text colour of the listview
1313void wxListCtrl::SetTextColour(const wxColour& col)
1314{
910484a6 1315 ListView_SetTextColor(GetHwnd(), PALETTERGB(col.Red(), col.Green(), col.Blue()));
2bda0e17
KB
1316}
1317
1318// Gets the index of the topmost visible item when in
1319// list or report view
c42404a5 1320long wxListCtrl::GetTopItem() const
2bda0e17 1321{
edccf428 1322 return (long) ListView_GetTopIndex(GetHwnd());
2bda0e17
KB
1323}
1324
1325// Searches for an item, starting from 'item'.
1326// 'geometry' is one of
1327// wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT.
1328// 'state' is a state bit flag, one or more of
1329// wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT.
1330// item can be -1 to find the first item that matches the
1331// specified flags.
1332// Returns the item or -1 if unsuccessful.
debe6624 1333long wxListCtrl::GetNextItem(long item, int geom, int state) const
2bda0e17 1334{
0b5efdc7 1335 long flags = 0;
2bda0e17 1336
0b5efdc7
VZ
1337 if ( geom == wxLIST_NEXT_ABOVE )
1338 flags |= LVNI_ABOVE;
1339 if ( geom == wxLIST_NEXT_ALL )
1340 flags |= LVNI_ALL;
1341 if ( geom == wxLIST_NEXT_BELOW )
1342 flags |= LVNI_BELOW;
1343 if ( geom == wxLIST_NEXT_LEFT )
1344 flags |= LVNI_TOLEFT;
1345 if ( geom == wxLIST_NEXT_RIGHT )
1346 flags |= LVNI_TORIGHT;
2bda0e17 1347
0b5efdc7
VZ
1348 if ( state & wxLIST_STATE_CUT )
1349 flags |= LVNI_CUT;
1350 if ( state & wxLIST_STATE_DROPHILITED )
1351 flags |= LVNI_DROPHILITED;
1352 if ( state & wxLIST_STATE_FOCUSED )
1353 flags |= LVNI_FOCUSED;
1354 if ( state & wxLIST_STATE_SELECTED )
1355 flags |= LVNI_SELECTED;
2bda0e17 1356
edccf428 1357 return (long) ListView_GetNextItem(GetHwnd(), item, flags);
2bda0e17
KB
1358}
1359
1360
debe6624 1361wxImageList *wxListCtrl::GetImageList(int which) const
2bda0e17 1362{
0b5efdc7 1363 if ( which == wxIMAGE_LIST_NORMAL )
2bda0e17 1364 {
0b5efdc7
VZ
1365 return m_imageListNormal;
1366 }
1367 else if ( which == wxIMAGE_LIST_SMALL )
2bda0e17 1368 {
0b5efdc7
VZ
1369 return m_imageListSmall;
1370 }
1371 else if ( which == wxIMAGE_LIST_STATE )
2bda0e17 1372 {
0b5efdc7
VZ
1373 return m_imageListState;
1374 }
1375 return NULL;
2bda0e17
KB
1376}
1377
debe6624 1378void wxListCtrl::SetImageList(wxImageList *imageList, int which)
2bda0e17 1379{
0b5efdc7
VZ
1380 int flags = 0;
1381 if ( which == wxIMAGE_LIST_NORMAL )
2bda0e17 1382 {
0b5efdc7 1383 flags = LVSIL_NORMAL;
2e12c11a 1384 if (m_ownsImageListNormal) delete m_imageListNormal;
0b5efdc7 1385 m_imageListNormal = imageList;
598ddd96 1386 m_ownsImageListNormal = false;
0b5efdc7
VZ
1387 }
1388 else if ( which == wxIMAGE_LIST_SMALL )
2bda0e17 1389 {
0b5efdc7 1390 flags = LVSIL_SMALL;
2e12c11a 1391 if (m_ownsImageListSmall) delete m_imageListSmall;
0b5efdc7 1392 m_imageListSmall = imageList;
598ddd96 1393 m_ownsImageListSmall = false;
0b5efdc7
VZ
1394 }
1395 else if ( which == wxIMAGE_LIST_STATE )
2bda0e17 1396 {
0b5efdc7 1397 flags = LVSIL_STATE;
2e12c11a 1398 if (m_ownsImageListState) delete m_imageListState;
0b5efdc7 1399 m_imageListState = imageList;
598ddd96 1400 m_ownsImageListState = false;
0b5efdc7 1401 }
8ecd5de2 1402 (void) ListView_SetImageList(GetHwnd(), (HIMAGELIST) imageList ? imageList->GetHIMAGELIST() : 0, flags);
2bda0e17
KB
1403}
1404
2e12c11a
VS
1405void wxListCtrl::AssignImageList(wxImageList *imageList, int which)
1406{
1407 SetImageList(imageList, which);
1408 if ( which == wxIMAGE_LIST_NORMAL )
598ddd96 1409 m_ownsImageListNormal = true;
2e12c11a 1410 else if ( which == wxIMAGE_LIST_SMALL )
598ddd96 1411 m_ownsImageListSmall = true;
2e12c11a 1412 else if ( which == wxIMAGE_LIST_STATE )
598ddd96 1413 m_ownsImageListState = true;
2e12c11a
VS
1414}
1415
edccf428 1416// ----------------------------------------------------------------------------
2bda0e17 1417// Operations
edccf428 1418// ----------------------------------------------------------------------------
2bda0e17
KB
1419
1420// Arranges the items
debe6624 1421bool wxListCtrl::Arrange(int flag)
2bda0e17 1422{
0b5efdc7
VZ
1423 UINT code = 0;
1424 if ( flag == wxLIST_ALIGN_LEFT )
1425 code = LVA_ALIGNLEFT;
1426 else if ( flag == wxLIST_ALIGN_TOP )
1427 code = LVA_ALIGNTOP;
1428 else if ( flag == wxLIST_ALIGN_DEFAULT )
1429 code = LVA_DEFAULT;
1430 else if ( flag == wxLIST_ALIGN_SNAP_TO_GRID )
1431 code = LVA_SNAPTOGRID;
2bda0e17 1432
edccf428 1433 return (ListView_Arrange(GetHwnd(), code) != 0);
2bda0e17
KB
1434}
1435
1436// Deletes an item
debe6624 1437bool wxListCtrl::DeleteItem(long item)
2bda0e17 1438{
2e9f62da
VZ
1439 if ( !ListView_DeleteItem(GetHwnd(), (int) item) )
1440 {
1441 wxLogLastError(_T("ListView_DeleteItem"));
598ddd96 1442 return false;
2e9f62da
VZ
1443 }
1444
7a462631 1445 m_count--;
68c124a1
RD
1446 wxASSERT_MSG( m_count == ListView_GetItemCount(GetHwnd()),
1447 wxT("m_count should match ListView_GetItemCount"));
1448
2e9f62da
VZ
1449 // the virtual list control doesn't refresh itself correctly, help it
1450 if ( IsVirtual() )
1451 {
1452 // we need to refresh all the lines below the one which was deleted
1453 wxRect rectItem;
1454 if ( item > 0 && GetItemCount() )
1455 {
1456 GetItemRect(item - 1, rectItem);
1457 }
1458 else
1459 {
1460 rectItem.y =
1461 rectItem.height = 0;
1462 }
1463
1464 wxRect rectWin = GetRect();
1465 rectWin.height = rectWin.GetBottom() - rectItem.GetBottom();
1466 rectWin.y = rectItem.GetBottom();
1467
1468 RefreshRect(rectWin);
1469 }
1470
598ddd96 1471 return true;
2bda0e17
KB
1472}
1473
1474// Deletes all items
0b5efdc7 1475bool wxListCtrl::DeleteAllItems()
2bda0e17 1476{
2e9f62da 1477 return ListView_DeleteAllItems(GetHwnd()) != 0;
2bda0e17
KB
1478}
1479
1480// Deletes all items
0b5efdc7 1481bool wxListCtrl::DeleteAllColumns()
2bda0e17 1482{
edccf428 1483 while ( m_colCount > 0 )
2bda0e17 1484 {
edccf428
VZ
1485 if ( ListView_DeleteColumn(GetHwnd(), 0) == 0 )
1486 {
f6bcfd97 1487 wxLogLastError(wxT("ListView_DeleteColumn"));
edccf428 1488
598ddd96 1489 return false;
edccf428
VZ
1490 }
1491
1492 m_colCount--;
2bda0e17 1493 }
edccf428 1494
223d09f6 1495 wxASSERT_MSG( m_colCount == 0, wxT("no columns should be left") );
edccf428 1496
598ddd96 1497 return true;
2bda0e17
KB
1498}
1499
1500// Deletes a column
debe6624 1501bool wxListCtrl::DeleteColumn(int col)
2bda0e17 1502{
edccf428 1503 bool success = (ListView_DeleteColumn(GetHwnd(), col) != 0);
2bda0e17
KB
1504
1505 if ( success && (m_colCount > 0) )
1506 m_colCount --;
1507 return success;
1508}
1509
1510// Clears items, and columns if there are any.
0b5efdc7 1511void wxListCtrl::ClearAll()
2bda0e17
KB
1512{
1513 DeleteAllItems();
1514 if ( m_colCount > 0 )
1515 DeleteAllColumns();
1516}
1517
508b6523
VZ
1518void wxListCtrl::InitEditControl(WXHWND hWnd)
1519{
1520 m_textCtrl->SetHWND(hWnd);
1521 m_textCtrl->SubclassWin(hWnd);
1522 m_textCtrl->SetParent(this);
1523
1524 // we must disallow TABbing away from the control while the edit contol is
1525 // shown because this leaves it in some strange state (just try removing
1526 // this line and then pressing TAB while editing an item in listctrl
1527 // inside a panel)
1528 m_textCtrl->SetWindowStyle(m_textCtrl->GetWindowStyle() | wxTE_PROCESS_TAB);
1529}
1530
bbcdf8bc
JS
1531wxTextCtrl* wxListCtrl::EditLabel(long item, wxClassInfo* textControlClass)
1532{
508b6523
VZ
1533 wxCHECK_MSG( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)), NULL,
1534 "control used for label editing must be a wxTextCtrl" );
bbcdf8bc 1535
6aaef140 1536 // ListView_EditLabel requires that the list has focus.
aa50e893 1537 SetFocus();
2b5f62a0 1538
508b6523
VZ
1539 // create m_textCtrl here before calling ListView_EditLabel() because it
1540 // generates wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT event from inside it and
1541 // the user handler for it can call GetEditControl() resulting in an on
1542 // demand creation of a stock wxTextCtrl instead of the control of a
1543 // (possibly) custom wxClassInfo
1544 DeleteEditControl();
1545 m_textCtrl = (wxTextCtrl *)textControlClass->CreateObject();
1546
6aaef140 1547 WXHWND hWnd = (WXHWND) ListView_EditLabel(GetHwnd(), item);
2b5f62a0
VZ
1548 if ( !hWnd )
1549 {
1550 // failed to start editing
508b6523
VZ
1551 delete m_textCtrl;
1552 m_textCtrl = NULL;
1553
2b5f62a0
VZ
1554 return NULL;
1555 }
bbcdf8bc 1556
508b6523
VZ
1557 // if GetEditControl() hasn't been called, we need to initialize the edit
1558 // control ourselves
1559 if ( !m_textCtrl->GetHWND() )
1560 InitEditControl(hWnd);
2b5f62a0 1561
bbcdf8bc
JS
1562 return m_textCtrl;
1563}
1564
1565// End label editing, optionally cancelling the edit
4496eadc 1566bool wxListCtrl::EndEditLabel(bool cancel)
2bda0e17 1567{
4496eadc
JS
1568 // m_textCtrl is not always ready, ie. in EVT_LIST_BEGIN_LABEL_EDIT
1569 HWND hwnd = ListView_GetEditControl(GetHwnd());
55f42db2
VZ
1570 if ( !hwnd )
1571 return false;
1572
1573 if ( cancel )
1574 ::SetWindowText(hwnd, wxEmptyString); // dubious but better than nothing
1575
1576 // we shouldn't destroy the control ourselves according to MSDN, which
1577 // proposes WM_CANCELMODE to do this, but it doesn't seem to work
1578 //
1579 // posting WM_CLOSE to it does seem to work without any side effects
1580 ::PostMessage(hwnd, WM_CLOSE, 0, 0);
1581
1582 return true;
2bda0e17
KB
1583}
1584
1585// Ensures this item is visible
debe6624 1586bool wxListCtrl::EnsureVisible(long item)
2bda0e17 1587{
598ddd96 1588 return ListView_EnsureVisible(GetHwnd(), (int) item, FALSE) != FALSE;
2bda0e17
KB
1589}
1590
1591// Find an item whose label matches this string, starting from the item after 'start'
1592// or the beginning if 'start' is -1.
debe6624 1593long wxListCtrl::FindItem(long start, const wxString& str, bool partial)
2bda0e17 1594{
0b5efdc7 1595 LV_FINDINFO findInfo;
2bda0e17 1596
0b5efdc7
VZ
1597 findInfo.flags = LVFI_STRING;
1598 if ( partial )
7edc258e 1599 findInfo.flags |= LVFI_PARTIAL;
e0a050e3 1600 findInfo.psz = str.wx_str();
2bda0e17 1601
3ca6a5f0
BP
1602 // ListView_FindItem() excludes the first item from search and to look
1603 // through all the items you need to start from -1 which is unnatural and
8036af01
JS
1604 // inconsistent with the generic version - so we adjust the index
1605 if (start != -1)
1606 start --;
1607 return ListView_FindItem(GetHwnd(), (int) start, &findInfo);
2bda0e17
KB
1608}
1609
1610// Find an item whose data matches this data, starting from the item after 'start'
1611// or the beginning if 'start' is -1.
72db8894
RD
1612// NOTE : Lindsay Mathieson - 14-July-2002
1613// No longer use ListView_FindItem as the data attribute is now stored
1614// in a wxListItemInternalData structure refernced by the actual lParam
81ce36aa 1615long wxListCtrl::FindItem(long start, wxUIntPtr data)
2bda0e17 1616{
72db8894
RD
1617 long idx = start + 1;
1618 long count = GetItemCount();
2bda0e17 1619
72db8894
RD
1620 while (idx < count)
1621 {
1622 if (GetItemData(idx) == data)
1623 return idx;
1624 idx++;
1625 };
2bda0e17 1626
72db8894 1627 return -1;
2bda0e17
KB
1628}
1629
1630// Find an item nearest this position in the specified direction, starting from
1631// the item after 'start' or the beginning if 'start' is -1.
debe6624 1632long wxListCtrl::FindItem(long start, const wxPoint& pt, int direction)
2bda0e17 1633{
0b5efdc7 1634 LV_FINDINFO findInfo;
2bda0e17 1635
0b5efdc7
VZ
1636 findInfo.flags = LVFI_NEARESTXY;
1637 findInfo.pt.x = pt.x;
1638 findInfo.pt.y = pt.y;
acb62b84 1639 findInfo.vkDirection = VK_RIGHT;
2bda0e17 1640
0b5efdc7
VZ
1641 if ( direction == wxLIST_FIND_UP )
1642 findInfo.vkDirection = VK_UP;
1643 else if ( direction == wxLIST_FIND_DOWN )
1644 findInfo.vkDirection = VK_DOWN;
1645 else if ( direction == wxLIST_FIND_LEFT )
1646 findInfo.vkDirection = VK_LEFT;
1647 else if ( direction == wxLIST_FIND_RIGHT )
1648 findInfo.vkDirection = VK_RIGHT;
1649
edccf428 1650 return ListView_FindItem(GetHwnd(), (int) start, & findInfo);
2bda0e17
KB
1651}
1652
1653// Determines which item (if any) is at the specified point,
1654// giving details in 'flags' (see wxLIST_HITTEST_... flags above)
be0e5d69
VZ
1655long
1656wxListCtrl::HitTest(const wxPoint& point, int& flags, long *ptrSubItem) const
2bda0e17
KB
1657{
1658 LV_HITTESTINFO hitTestInfo;
0b5efdc7
VZ
1659 hitTestInfo.pt.x = (int) point.x;
1660 hitTestInfo.pt.y = (int) point.y;
2bda0e17 1661
164a7972
VZ
1662 long item;
1663#ifdef LVM_SUBITEMHITTEST
1664 if ( ptrSubItem && wxApp::GetComCtl32Version() >= 470 )
1665 {
1666 item = ListView_SubItemHitTest(GetHwnd(), &hitTestInfo);
1667 *ptrSubItem = hitTestInfo.iSubItem;
1668 }
1669 else
1670#endif // LVM_SUBITEMHITTEST
1671 {
1672 item = ListView_HitTest(GetHwnd(), &hitTestInfo);
1673 }
2bda0e17 1674
0b5efdc7 1675 flags = 0;
698b34fa 1676
0b5efdc7
VZ
1677 if ( hitTestInfo.flags & LVHT_ABOVE )
1678 flags |= wxLIST_HITTEST_ABOVE;
1679 if ( hitTestInfo.flags & LVHT_BELOW )
1680 flags |= wxLIST_HITTEST_BELOW;
0b5efdc7
VZ
1681 if ( hitTestInfo.flags & LVHT_TOLEFT )
1682 flags |= wxLIST_HITTEST_TOLEFT;
1683 if ( hitTestInfo.flags & LVHT_TORIGHT )
1684 flags |= wxLIST_HITTEST_TORIGHT;
1685
698b34fa
VZ
1686 if ( hitTestInfo.flags & LVHT_NOWHERE )
1687 flags |= wxLIST_HITTEST_NOWHERE;
1688
1689 // note a bug or at least a very strange feature of comtl32.dll (tested
1690 // with version 4.0 under Win95 and 6.0 under Win 2003): if you click to
1691 // the right of the item label, ListView_HitTest() returns a combination of
1692 // LVHT_ONITEMICON, LVHT_ONITEMLABEL and LVHT_ONITEMSTATEICON -- filter out
1693 // the bits which don't make sense
1694 if ( hitTestInfo.flags & LVHT_ONITEMLABEL )
1695 {
1696 flags |= wxLIST_HITTEST_ONITEMLABEL;
1697
1698 // do not translate LVHT_ONITEMICON here, as per above
1699 }
1700 else
1701 {
1702 if ( hitTestInfo.flags & LVHT_ONITEMICON )
1703 flags |= wxLIST_HITTEST_ONITEMICON;
1704 if ( hitTestInfo.flags & LVHT_ONITEMSTATEICON )
1705 flags |= wxLIST_HITTEST_ONITEMSTATEICON;
1706 }
1707
164a7972 1708 return item;
2bda0e17
KB
1709}
1710
164a7972 1711
2bda0e17
KB
1712// Inserts an item, returning the index of the new item if successful,
1713// -1 otherwise.
fbfb8bcc 1714long wxListCtrl::InsertItem(const wxListItem& info)
2bda0e17 1715{
98ec9dbe
VZ
1716 wxASSERT_MSG( !IsVirtual(), _T("can't be used with virtual controls") );
1717
0b5efdc7
VZ
1718 LV_ITEM item;
1719 wxConvertToMSWListItem(this, info, item);
7cf46fdb 1720 item.mask &= ~LVIF_PARAM;
2bda0e17 1721
7cf46fdb
VZ
1722 // check wether we need to allocate our internal data
1723 bool needInternalData = ((info.m_mask & wxLIST_MASK_DATA) || info.HasAttributes());
1724 if (needInternalData)
bdc72a22 1725 {
598ddd96 1726 m_AnyInternalData = true;
7cf46fdb 1727 item.mask |= LVIF_PARAM;
2702ed5a 1728
7cf46fdb
VZ
1729 // internal stucture that manages data
1730 wxListItemInternalData *data = new wxListItemInternalData();
1731 item.lParam = (LPARAM) data;
2702ed5a 1732
7cf46fdb
VZ
1733 if (info.m_mask & wxLIST_MASK_DATA)
1734 data->lParam = info.m_data;
2702ed5a 1735
b653e655
VZ
1736 // check whether it has any custom attributes
1737 if ( info.HasAttributes() )
1738 {
7cf46fdb
VZ
1739 // take copy of attributes
1740 data->attr = new wxListItemAttr(*info.GetAttributes());
5205e26b
VZ
1741
1742 // and remember that we have some now...
598ddd96 1743 m_hasAnyAttr = true;
b653e655 1744 }
7cf46fdb
VZ
1745 };
1746
68c124a1 1747 long rv = ListView_InsertItem(GetHwnd(), & item);
b653e655
VZ
1748
1749 m_count++;
68c124a1
RD
1750 wxASSERT_MSG( m_count == ListView_GetItemCount(GetHwnd()),
1751 wxT("m_count should match ListView_GetItemCount"));
bdc72a22 1752
68c124a1 1753 return rv;
2bda0e17
KB
1754}
1755
debe6624 1756long wxListCtrl::InsertItem(long index, const wxString& label)
2bda0e17 1757{
0b5efdc7
VZ
1758 wxListItem info;
1759 info.m_text = label;
1760 info.m_mask = wxLIST_MASK_TEXT;
1761 info.m_itemId = index;
1762 return InsertItem(info);
2bda0e17
KB
1763}
1764
1765// Inserts an image item
debe6624 1766long wxListCtrl::InsertItem(long index, int imageIndex)
2bda0e17 1767{
0b5efdc7
VZ
1768 wxListItem info;
1769 info.m_image = imageIndex;
1770 info.m_mask = wxLIST_MASK_IMAGE;
1771 info.m_itemId = index;
1772 return InsertItem(info);
2bda0e17
KB
1773}
1774
1775// Inserts an image/string item
debe6624 1776long wxListCtrl::InsertItem(long index, const wxString& label, int imageIndex)
2bda0e17 1777{
0b5efdc7
VZ
1778 wxListItem info;
1779 info.m_image = imageIndex;
1780 info.m_text = label;
1781 info.m_mask = wxLIST_MASK_IMAGE | wxLIST_MASK_TEXT;
1782 info.m_itemId = index;
1783 return InsertItem(info);
2bda0e17
KB
1784}
1785
1786// For list view mode (only), inserts a column.
fbfb8bcc 1787long wxListCtrl::InsertColumn(long col, const wxListItem& item)
2bda0e17 1788{
0b5efdc7 1789 LV_COLUMN lvCol;
e64658ed 1790 wxConvertToMSWListCol(GetHwnd(), col, item, lvCol);
0b5efdc7 1791
6f806543 1792 if ( !(lvCol.mask & LVCF_WIDTH) )
e373f51b
VZ
1793 {
1794 // always give some width to the new column: this one is compatible
6f806543
VZ
1795 // with the generic version
1796 lvCol.mask |= LVCF_WIDTH;
e373f51b 1797 lvCol.cx = 80;
0b5efdc7 1798 }
e373f51b 1799
8b3a4016
VZ
1800 long n = ListView_InsertColumn(GetHwnd(), col, &lvCol);
1801 if ( n != -1 )
e373f51b
VZ
1802 {
1803 m_colCount++;
1804 }
8b3a4016 1805 else // failed to insert?
e373f51b 1806 {
223d09f6 1807 wxLogDebug(wxT("Failed to insert the column '%s' into listview!"),
e373f51b
VZ
1808 lvCol.pszText);
1809 }
1810
8b3a4016 1811 return n;
2bda0e17
KB
1812}
1813
bdc72a22
VZ
1814long wxListCtrl::InsertColumn(long col,
1815 const wxString& heading,
1816 int format,
1817 int width)
2bda0e17 1818{
0b5efdc7
VZ
1819 wxListItem item;
1820 item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT;
1821 item.m_text = heading;
1822 if ( width > -1 )
1823 {
1824 item.m_mask |= wxLIST_MASK_WIDTH;
1825 item.m_width = width;
1826 }
1827 item.m_format = format;
2bda0e17 1828
0b5efdc7 1829 return InsertColumn(col, item);
2bda0e17
KB
1830}
1831
2b5f62a0
VZ
1832// scroll the control by the given number of pixels (exception: in list view,
1833// dx is interpreted as number of columns)
debe6624 1834bool wxListCtrl::ScrollList(int dx, int dy)
2bda0e17 1835{
2b5f62a0
VZ
1836 if ( !ListView_Scroll(GetHwnd(), dx, dy) )
1837 {
1838 wxLogDebug(_T("ListView_Scroll(%d, %d) failed"), dx, dy);
1839
598ddd96 1840 return false;
2b5f62a0
VZ
1841 }
1842
598ddd96 1843 return true;
2bda0e17
KB
1844}
1845
1846// Sort items.
1847
1848// fn is a function which takes 3 long arguments: item1, item2, data.
1849// item1 is the long data associated with a first item (NOT the index).
1850// item2 is the long data associated with a second item (NOT the index).
1851// data is the same value as passed to SortItems.
1852// The return value is a negative number if the first item should precede the second
1853// item, a positive number of the second item should precede the first,
1854// or zero if the two items are equivalent.
1855
1856// data is arbitrary data to be passed to the sort function.
19230604 1857
7cf46fdb
VZ
1858// Internal structures for proxying the user compare function
1859// so that we can pass it the *real* user data
19230604 1860
7cf46fdb
VZ
1861// translate lParam data and call user func
1862struct wxInternalDataSort
19230604 1863{
7cf46fdb
VZ
1864 wxListCtrlCompare user_fn;
1865 long data;
1866};
19230604 1867
7cf46fdb 1868int CALLBACK wxInternalDataCompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
2bda0e17 1869{
7cf46fdb 1870 struct wxInternalDataSort *internalData = (struct wxInternalDataSort *) lParamSort;
19230604 1871
7cf46fdb
VZ
1872 wxListItemInternalData *data1 = (wxListItemInternalData *) lParam1;
1873 wxListItemInternalData *data2 = (wxListItemInternalData *) lParam2;
19230604 1874
7cf46fdb
VZ
1875 long d1 = (data1 == NULL ? 0 : data1->lParam);
1876 long d2 = (data2 == NULL ? 0 : data2->lParam);
19230604 1877
7cf46fdb 1878 return internalData->user_fn(d1, d2, internalData->data);
19230604 1879
259c43f6 1880}
19230604 1881
7cf46fdb
VZ
1882bool wxListCtrl::SortItems(wxListCtrlCompare fn, long data)
1883{
1884 struct wxInternalDataSort internalData;
1885 internalData.user_fn = fn;
1886 internalData.data = data;
19230604 1887
14090241
VZ
1888 // WPARAM cast is needed for mingw/cygwin
1889 if ( !ListView_SortItems(GetHwnd(),
1890 wxInternalDataCompareFunc,
1891 (WPARAM) &internalData) )
19230604
RD
1892 {
1893 wxLogDebug(_T("ListView_SortItems() failed"));
1894
598ddd96 1895 return false;
19230604
RD
1896 }
1897
598ddd96 1898 return true;
2bda0e17
KB
1899}
1900
19230604
RD
1901
1902
edccf428
VZ
1903// ----------------------------------------------------------------------------
1904// message processing
1905// ----------------------------------------------------------------------------
1906
90c6edd7
VZ
1907bool wxListCtrl::MSWShouldPreProcessMessage(WXMSG* msg)
1908{
1909 if ( msg->message == WM_KEYDOWN )
1910 {
6719c06a
VZ
1911 // Only eat VK_RETURN if not being used by the application in
1912 // conjunction with modifiers
1913 if ( msg->wParam == VK_RETURN && !wxIsAnyModifierDown() )
90c6edd7 1914 {
6719c06a 1915 // we need VK_RETURN to generate wxEVT_COMMAND_LIST_ITEM_ACTIVATED
90c6edd7
VZ
1916 return false;
1917 }
1918 }
90c6edd7
VZ
1919 return wxControl::MSWShouldPreProcessMessage(msg);
1920}
1921
0edeeb6d 1922bool wxListCtrl::MSWCommand(WXUINT cmd, WXWORD id_)
2bda0e17 1923{
0edeeb6d 1924 const int id = (signed short)id_;
0b5efdc7 1925 if (cmd == EN_UPDATE)
acb62b84 1926 {
0b5efdc7
VZ
1927 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
1928 event.SetEventObject( this );
1929 ProcessCommand(event);
598ddd96 1930 return true;
acb62b84 1931 }
0b5efdc7 1932 else if (cmd == EN_KILLFOCUS)
acb62b84 1933 {
0b5efdc7
VZ
1934 wxCommandEvent event(wxEVT_KILL_FOCUS, id);
1935 event.SetEventObject( this );
1936 ProcessCommand(event);
598ddd96 1937 return true;
acb62b84 1938 }
edccf428 1939 else
598ddd96 1940 return false;
0b5efdc7
VZ
1941}
1942
a9fdf824 1943// utility used by wxListCtrl::MSWOnNotify and by wxDataViewHeaderWindowMSW::MSWOnNotify
a68962fc 1944int WXDLLIMPEXP_CORE wxMSWGetColumnClicked(NMHDR *nmhdr, POINT *ptClick)
a9fdf824 1945{
674c2750
VZ
1946 // find the column clicked: we have to search for it ourselves as the
1947 // notification message doesn't provide this info
a9fdf824
RR
1948
1949 // where did the click occur?
1950#if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
674c2750 1951 if ( nmhdr->code == GN_CONTEXTMENU )
a9fdf824
RR
1952 {
1953 *ptClick = ((NMRGINFO*)nmhdr)->ptAction;
f4322df6 1954 }
a9fdf824
RR
1955 else
1956#endif //__WXWINCE__
1957 if ( !::GetCursorPos(ptClick) )
1958 {
1959 wxLogLastError(_T("GetCursorPos"));
1960 }
1961
674c2750
VZ
1962 // we need to use listctrl coordinates for the event point so this is what
1963 // we return in ptClick, but for comparison with Header_GetItemRect()
1964 // result below we need to use header window coordinates
1965 POINT ptClickHeader = *ptClick;
1966 if ( !::ScreenToClient(nmhdr->hwndFrom, &ptClickHeader) )
a9fdf824 1967 {
674c2750 1968 wxLogLastError(_T("ScreenToClient(listctrl header)"));
a9fdf824
RR
1969 }
1970
674c2750
VZ
1971 if ( !::ScreenToClient(::GetParent(nmhdr->hwndFrom), ptClick) )
1972 {
1973 wxLogLastError(_T("ScreenToClient(listctrl)"));
1974 }
a9fdf824 1975
674c2750 1976 const int colCount = Header_GetItemCount(nmhdr->hwndFrom);
a9fdf824
RR
1977 for ( int col = 0; col < colCount; col++ )
1978 {
674c2750 1979 RECT rect;
a9fdf824
RR
1980 if ( Header_GetItemRect(nmhdr->hwndFrom, col, &rect) )
1981 {
674c2750 1982 if ( ::PtInRect(&rect, ptClickHeader) )
a9fdf824
RR
1983 {
1984 return col;
1985 }
1986 }
1987 }
1988
1989 return wxNOT_FOUND;
1990}
1991
a23fd0e1 1992bool wxListCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
0b5efdc7 1993{
68c124a1 1994
bdc72a22
VZ
1995 // prepare the event
1996 // -----------------
1997
0b5efdc7 1998 wxListEvent event(wxEVT_NULL, m_windowId);
648bec3e
VZ
1999 event.SetEventObject(this);
2000
0b5efdc7 2001 wxEventType eventType = wxEVT_NULL;
225fe9d6 2002
bdc72a22 2003 NMHDR *nmhdr = (NMHDR *)lParam;
225fe9d6 2004
d1f2eb1d
VZ
2005 // if your compiler is as broken as this, you should really change it: this
2006 // code is needed for normal operation! #ifdef below is only useful for
2007 // automatic rebuilds which are done with a very old compiler version
0cf5b099 2008#ifdef HDN_BEGINTRACKA
d1f2eb1d 2009
11358d39
VZ
2010 // check for messages from the header (in report view)
2011 HWND hwndHdr = ListView_GetHeader(GetHwnd());
225fe9d6 2012
11358d39
VZ
2013 // is it a message from the header?
2014 if ( nmhdr->hwndFrom == hwndHdr )
acb62b84 2015 {
00811ff9 2016 HD_NOTIFY *nmHDR = (HD_NOTIFY *)nmhdr;
0cf5b099 2017
11358d39 2018 event.m_itemIndex = -1;
cb0f56f9 2019
11358d39
VZ
2020 switch ( nmhdr->code )
2021 {
2022 // yet another comctl32.dll bug: under NT/W2K it sends Unicode
2023 // TRACK messages even to ANSI programs: on my system I get
2024 // HDN_BEGINTRACKW and HDN_ENDTRACKA and no HDN_TRACK at all!
2025 //
2026 // work around is to simply catch both versions and hope that it
2027 // works (why should this message exist in ANSI and Unicode is
2028 // beyond me as it doesn't deal with strings at all...)
2b5f62a0
VZ
2029 //
2030 // note that fr HDN_TRACK another possibility could be to use
2031 // HDN_ITEMCHANGING but it is sent even after HDN_ENDTRACK and when
2032 // something other than the item width changes so we'd have to
2033 // filter out the unwanted events then
11358d39
VZ
2034 case HDN_BEGINTRACKA:
2035 case HDN_BEGINTRACKW:
2036 eventType = wxEVT_COMMAND_LIST_COL_BEGIN_DRAG;
2037 // fall through
2038
2039 case HDN_TRACKA:
2040 case HDN_TRACKW:
2041 if ( eventType == wxEVT_NULL )
2042 eventType = wxEVT_COMMAND_LIST_COL_DRAGGING;
2043 // fall through
2044
2045 case HDN_ENDTRACKA:
2046 case HDN_ENDTRACKW:
2047 if ( eventType == wxEVT_NULL )
2048 eventType = wxEVT_COMMAND_LIST_COL_END_DRAG;
2b5f62a0
VZ
2049
2050 event.m_item.m_width = nmHDR->pitem->cxy;
11358d39
VZ
2051 event.m_col = nmHDR->iItem;
2052 break;
2053
781a24e8 2054#if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
80a81a12 2055 case GN_CONTEXTMENU:
a61d4011 2056#endif //__WXWINCE__
11358d39
VZ
2057 case NM_RCLICK:
2058 {
11358d39 2059 POINT ptClick;
5ea47806 2060
a9fdf824
RR
2061 eventType = wxEVT_COMMAND_LIST_COL_RIGHT_CLICK;
2062 event.m_col = wxMSWGetColumnClicked(nmhdr, &ptClick);
11358d39
VZ
2063 event.m_pointDrag.x = ptClick.x;
2064 event.m_pointDrag.y = ptClick.y;
11358d39
VZ
2065 }
2066 break;
5ea47806 2067
2b5f62a0 2068 case HDN_GETDISPINFOW:
c68f590a
VZ
2069 // letting Windows XP handle this message results in mysterious
2070 // crashes in comctl32.dll seemingly because of bad message
2071 // parameters
2072 //
2073 // I have no idea what is the real cause of the bug (which is,
a9fdf824 2074 // just to make things interesting, impossible to reproduce
c68f590a
VZ
2075 // reliably) but ignoring all these messages does fix it and
2076 // doesn't seem to have any negative consequences
2077 return true;
2b5f62a0 2078
11358d39
VZ
2079 default:
2080 return wxControl::MSWOnNotify(idCtrl, lParam, result);
2081 }
2082 }
d1f2eb1d 2083 else
0cf5b099 2084#endif // defined(HDN_BEGINTRACKA)
164e8d41 2085 if ( nmhdr->hwndFrom == GetHwnd() )
11358d39
VZ
2086 {
2087 // almost all messages use NM_LISTVIEW
2088 NM_LISTVIEW *nmLV = (NM_LISTVIEW *)nmhdr;
bdc72a22 2089
2b5f62a0
VZ
2090 const int iItem = nmLV->iItem;
2091
68c124a1
RD
2092
2093 // FreeAllInternalData will cause LVN_ITEMCHANG* messages, which can be
2094 // ignored for efficiency. It is done here because the internal data is in the
2095 // process of being deleted so we don't want to try and access it below.
2096 if ( m_ignoreChangeMessages &&
7a462631
VZ
2097 ( (nmLV->hdr.code == LVN_ITEMCHANGED) ||
2098 (nmLV->hdr.code == LVN_ITEMCHANGING)) )
2b5f62a0 2099 {
598ddd96 2100 return true;
68c124a1 2101 }
7eb833e6 2102
2b5f62a0 2103
68c124a1
RD
2104 // If we have a valid item then check if there is a data value
2105 // associated with it and put it in the event.
2106 if ( iItem >= 0 && iItem < GetItemCount() )
2107 {
2108 wxListItemInternalData *internaldata =
2109 wxGetInternalData(GetHwnd(), iItem);
2b5f62a0 2110
68c124a1
RD
2111 if ( internaldata )
2112 event.m_item.m_data = internaldata->lParam;
2b5f62a0 2113 }
bdc72a22 2114
f0755097 2115 bool processed = true;
11358d39
VZ
2116 switch ( nmhdr->code )
2117 {
2118 case LVN_BEGINRDRAG:
2119 eventType = wxEVT_COMMAND_LIST_BEGIN_RDRAG;
2120 // fall through
7bf1474a 2121
11358d39
VZ
2122 case LVN_BEGINDRAG:
2123 if ( eventType == wxEVT_NULL )
2124 {
2125 eventType = wxEVT_COMMAND_LIST_BEGIN_DRAG;
2126 }
bdc72a22 2127
2b5f62a0 2128 event.m_itemIndex = iItem;
11358d39
VZ
2129 event.m_pointDrag.x = nmLV->ptAction.x;
2130 event.m_pointDrag.y = nmLV->ptAction.y;
2131 break;
2132
8c21905b 2133 // NB: we have to handle both *A and *W versions here because some
d2ed74b9
VZ
2134 // versions of comctl32.dll send ANSI messages even to the
2135 // Unicode windows
8c21905b 2136 case LVN_BEGINLABELEDITA:
8c21905b
VS
2137 case LVN_BEGINLABELEDITW:
2138 {
d2ed74b9
VZ
2139 wxLV_ITEM item;
2140 if ( nmhdr->code == LVN_BEGINLABELEDITA )
2141 {
2142 item.Init(((LV_DISPINFOA *)lParam)->item);
2143 }
2144 else // LVN_BEGINLABELEDITW
2145 {
2146 item.Init(((LV_DISPINFOW *)lParam)->item);
2147 }
2148
8c21905b 2149 eventType = wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT;
8c21905b
VS
2150 wxConvertFromMSWListItem(GetHwnd(), event.m_item, item);
2151 event.m_itemIndex = event.m_item.m_itemId;
2152 }
2153 break;
2154
2155 case LVN_ENDLABELEDITA:
d2ed74b9 2156 case LVN_ENDLABELEDITW:
8c21905b 2157 {
d2ed74b9
VZ
2158 wxLV_ITEM item;
2159 if ( nmhdr->code == LVN_ENDLABELEDITA )
c546974f 2160 {
d2ed74b9
VZ
2161 item.Init(((LV_DISPINFOA *)lParam)->item);
2162 }
2163 else // LVN_ENDLABELEDITW
2164 {
2165 item.Init(((LV_DISPINFOW *)lParam)->item);
c546974f 2166 }
8c21905b 2167
d2ed74b9
VZ
2168 // was editing cancelled?
2169 const LV_ITEM& lvi = (LV_ITEM)item;
2170 if ( !lvi.pszText || lvi.iItem == -1 )
c546974f 2171 {
5cd4cb75
VZ
2172 // EDIT control will be deleted by the list control
2173 // itself so prevent us from deleting it as well
2174 DeleteEditControl();
d2ed74b9
VZ
2175
2176 event.SetEditCanceled(true);
c546974f 2177 }
8c21905b 2178
d2ed74b9
VZ
2179 eventType = wxEVT_COMMAND_LIST_END_LABEL_EDIT;
2180 wxConvertFromMSWListItem(NULL, event.m_item, item);
11358d39
VZ
2181 event.m_itemIndex = event.m_item.m_itemId;
2182 }
2183 break;
edccf428 2184
11358d39
VZ
2185 case LVN_COLUMNCLICK:
2186 eventType = wxEVT_COMMAND_LIST_COL_CLICK;
2187 event.m_itemIndex = -1;
2188 event.m_col = nmLV->iSubItem;
2189 break;
bdc72a22 2190
11358d39
VZ
2191 case LVN_DELETEALLITEMS:
2192 eventType = wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS;
2193 event.m_itemIndex = -1;
11358d39
VZ
2194 break;
2195
2196 case LVN_DELETEITEM:
07763c99
VZ
2197 if ( m_count == 0 )
2198 {
2199 // this should be prevented by the post-processing code
2200 // below, but "just in case"
598ddd96 2201 return false;
07763c99 2202 }
68c124a1 2203
11358d39 2204 eventType = wxEVT_COMMAND_LIST_DELETE_ITEM;
2b5f62a0 2205 event.m_itemIndex = iItem;
7cf46fdb 2206 // delete the assoicated internal data
2b5f62a0 2207 wxDeleteInternalData(this, iItem);
11358d39
VZ
2208 break;
2209
11358d39
VZ
2210 case LVN_INSERTITEM:
2211 eventType = wxEVT_COMMAND_LIST_INSERT_ITEM;
2b5f62a0 2212 event.m_itemIndex = iItem;
11358d39 2213 break;
edccf428 2214
11358d39 2215 case LVN_ITEMCHANGED:
648bec3e 2216 // we translate this catch all message into more interesting
77ffb593 2217 // (and more easy to process) wxWidgets events
648bec3e 2218
2b5f62a0
VZ
2219 // first of all, we deal with the state change events only and
2220 // only for valid items (item == -1 for the virtual list
2221 // control)
2222 if ( nmLV->uChanged & LVIF_STATE && iItem != -1 )
11358d39 2223 {
648bec3e
VZ
2224 // temp vars for readability
2225 const UINT stOld = nmLV->uOldState;
2226 const UINT stNew = nmLV->uNewState;
2227
2b5f62a0
VZ
2228 event.m_item.SetId(iItem);
2229 event.m_item.SetMask(wxLIST_MASK_TEXT |
2230 wxLIST_MASK_IMAGE |
2231 wxLIST_MASK_DATA);
2232 GetItem(event.m_item);
2233
648bec3e
VZ
2234 // has the focus changed?
2235 if ( !(stOld & LVIS_FOCUSED) && (stNew & LVIS_FOCUSED) )
2236 {
2237 eventType = wxEVT_COMMAND_LIST_ITEM_FOCUSED;
2b5f62a0 2238 event.m_itemIndex = iItem;
648bec3e
VZ
2239 }
2240
2241 if ( (stNew & LVIS_SELECTED) != (stOld & LVIS_SELECTED) )
2242 {
2243 if ( eventType != wxEVT_NULL )
2244 {
2245 // focus and selection have both changed: send the
2246 // focus event from here and the selection one
2247 // below
2248 event.SetEventType(eventType);
937013e0 2249 (void)HandleWindowEvent(event);
648bec3e
VZ
2250 }
2251 else // no focus event to send
2252 {
2253 // then need to set m_itemIndex as it wasn't done
2254 // above
2b5f62a0 2255 event.m_itemIndex = iItem;
648bec3e
VZ
2256 }
2257
2258 eventType = stNew & LVIS_SELECTED
2259 ? wxEVT_COMMAND_LIST_ITEM_SELECTED
2260 : wxEVT_COMMAND_LIST_ITEM_DESELECTED;
2261 }
edccf428 2262 }
648bec3e
VZ
2263
2264 if ( eventType == wxEVT_NULL )
edccf428 2265 {
648bec3e 2266 // not an interesting event for us
598ddd96 2267 return false;
edccf428 2268 }
648bec3e 2269
11358d39 2270 break;
225fe9d6 2271
11358d39
VZ
2272 case LVN_KEYDOWN:
2273 {
2274 LV_KEYDOWN *info = (LV_KEYDOWN *)lParam;
2275 WORD wVKey = info->wVKey;
2276
2277 // get the current selection
2278 long lItem = GetNextItem(-1,
2279 wxLIST_NEXT_ALL,
2280 wxLIST_STATE_SELECTED);
2281
2282 // <Enter> or <Space> activate the selected item if any (but
ec27ba21
VZ
2283 // not with any modifiers as they have a predefined meaning
2284 // then)
11358d39
VZ
2285 if ( lItem != -1 &&
2286 (wVKey == VK_RETURN || wVKey == VK_SPACE) &&
ec27ba21 2287 !wxIsAnyModifierDown() )
11358d39
VZ
2288 {
2289 eventType = wxEVT_COMMAND_LIST_ITEM_ACTIVATED;
2290 }
2291 else
2292 {
2293 eventType = wxEVT_COMMAND_LIST_KEY_DOWN;
185d0094
VZ
2294
2295 // wxCharCodeMSWToWX() returns 0 if the key is an ASCII
2296 // value which should be used as is
2297 int code = wxCharCodeMSWToWX(wVKey);
2298 event.m_code = code ? code : wVKey;
11358d39 2299 }
7db91489 2300
11358d39
VZ
2301 event.m_itemIndex =
2302 event.m_item.m_itemId = lItem;
2303
2304 if ( lItem != -1 )
2305 {
2306 // fill the other fields too
2307 event.m_item.m_text = GetItemText(lItem);
2308 event.m_item.m_data = GetItemData(lItem);
2309 }
2310 }
2311 break;
2312
2313 case NM_DBLCLK:
2314 // if the user processes it in wxEVT_COMMAND_LEFT_CLICK(), don't do
2315 // anything else
2316 if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
f6bcfd97 2317 {
598ddd96 2318 return true;
f6bcfd97 2319 }
edccf428 2320
11358d39
VZ
2321 // else translate it into wxEVT_COMMAND_LIST_ITEM_ACTIVATED event
2322 // if it happened on an item (and not on empty place)
2b5f62a0 2323 if ( iItem == -1 )
11358d39
VZ
2324 {
2325 // not on item
598ddd96 2326 return false;
11358d39 2327 }
edccf428 2328
11358d39 2329 eventType = wxEVT_COMMAND_LIST_ITEM_ACTIVATED;
2b5f62a0
VZ
2330 event.m_itemIndex = iItem;
2331 event.m_item.m_text = GetItemText(iItem);
2332 event.m_item.m_data = GetItemData(iItem);
11358d39 2333 break;
225fe9d6 2334
781a24e8 2335#if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
80a81a12 2336 case GN_CONTEXTMENU:
a61d4011 2337#endif //__WXWINCE__
11358d39 2338 case NM_RCLICK:
225fe9d6
VZ
2339 // if the user processes it in wxEVT_COMMAND_RIGHT_CLICK(),
2340 // don't do anything else
2341 if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
2342 {
598ddd96 2343 return true;
225fe9d6 2344 }
cb0f56f9 2345
225fe9d6
VZ
2346 // else translate it into wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK event
2347 LV_HITTESTINFO lvhti;
2348 wxZeroMemory(lvhti);
11c7d5b6 2349
781a24e8 2350#if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
37b53d2a
JS
2351 if(nmhdr->code == GN_CONTEXTMENU) {
2352 lvhti.pt = ((NMRGINFO*)nmhdr)->ptAction;
598ddd96 2353 } else
a61d4011 2354#endif //__WXWINCE__
225fe9d6
VZ
2355 ::GetCursorPos(&(lvhti.pt));
2356 ::ScreenToClient(GetHwnd(),&(lvhti.pt));
2357 if ( ListView_HitTest(GetHwnd(),&lvhti) != -1 )
cb0f56f9 2358 {
225fe9d6
VZ
2359 if ( lvhti.flags & LVHT_ONITEM )
2360 {
2361 eventType = wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK;
2362 event.m_itemIndex = lvhti.iItem;
a1f79c1e
VZ
2363 event.m_pointDrag.x = lvhti.pt.x;
2364 event.m_pointDrag.y = lvhti.pt.y;
225fe9d6 2365 }
cb0f56f9 2366 }
11358d39 2367 break;
bdc72a22 2368
5b59df83 2369#ifdef NM_CUSTOMDRAW
80c54c3d 2370 case NM_CUSTOMDRAW:
11358d39 2371 *result = OnCustomDraw(lParam);
63166611 2372
e6b1317b 2373 return *result != CDRF_DODEFAULT;
6ecfe2ac 2374#endif // _WIN32_IE >= 0x300
0b5efdc7 2375
11358d39
VZ
2376 case LVN_ODCACHEHINT:
2377 {
2378 const NM_CACHEHINT *cacheHint = (NM_CACHEHINT *)lParam;
614391dc 2379
11358d39 2380 eventType = wxEVT_COMMAND_LIST_CACHE_HINT;
e623926d 2381
0ea0359b
VZ
2382 // we get some really stupid cache hints like ones for
2383 // items in range 0..0 for an empty control or, after
2384 // deleting an item, for items in invalid range -- filter
2385 // this garbage out
2386 if ( cacheHint->iFrom > cacheHint->iTo )
598ddd96 2387 return false;
0ea0359b
VZ
2388
2389 event.m_oldItemIndex = cacheHint->iFrom;
2390
2391 const long iMax = GetItemCount();
2392 event.m_itemIndex = cacheHint->iTo < iMax ? cacheHint->iTo
2393 : iMax - 1;
e623926d 2394 }
11358d39 2395 break;
614391dc 2396
206391cb 2397#ifdef HAVE_NMLVFINDITEM
f0755097
VZ
2398 case LVN_ODFINDITEM:
2399 // this message is only used with the virtual list control but
2400 // even there we don't want to always use it: in a control with
2401 // sufficiently big number of items (defined as > 1000 here),
2402 // accidentally pressing a key could result in hanging an
2403 // application waiting while it performs linear search
2404 if ( IsVirtual() && GetItemCount() <= 1000 )
2405 {
2406 NMLVFINDITEM* pFindInfo = (NMLVFINDITEM*)lParam;
2407
2408 // no match by default
2409 *result = -1;
2410
2411 // we only handle string-based searches here
2412 //
2413 // TODO: what about LVFI_PARTIAL, should we handle this?
2414 if ( !(pFindInfo->lvfi.flags & LVFI_STRING) )
2415 {
2416 return false;
2417 }
2418
2419 const wxChar * const searchstr = pFindInfo->lvfi.psz;
2420 const size_t len = wxStrlen(searchstr);
2421
2422 // this is the first item we should examine, search from it
2423 // wrapping if necessary
2424 const int startPos = pFindInfo->iStart;
2425 const int maxPos = GetItemCount();
2426 wxCHECK_MSG( startPos <= maxPos, false,
2427 _T("bad starting position in LVN_ODFINDITEM") );
2428
2429 int currentPos = startPos;
2430 do
2431 {
2432 // wrap to the beginning if necessary
2433 if ( currentPos == maxPos )
2434 {
2435 // somewhat surprizingly, LVFI_WRAP isn't set in
2436 // flags but we still should wrap
2437 currentPos = 0;
2438 }
2439
2440 // does this item begin with searchstr?
2441 if ( wxStrnicmp(searchstr,
2442 GetItemText(currentPos), len) == 0 )
2443 {
2444 *result = currentPos;
2445 break;
2446 }
2447 }
2448 while ( ++currentPos != startPos );
2449
2450 if ( *result == -1 )
2451 {
2452 // not found
2453 return false;
2454 }
2455
2456 SetItemState(*result,
2457 wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED,
2458 wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED);
2459 EnsureVisible(*result);
2460 return true;
2461 }
2462 else
2463 {
2464 processed = false;
2465 }
2466 break;
206391cb 2467#endif // HAVE_NMLVFINDITEM
f0755097 2468
11358d39
VZ
2469 case LVN_GETDISPINFO:
2470 if ( IsVirtual() )
2471 {
2472 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
98ec9dbe 2473
11358d39
VZ
2474 LV_ITEM& lvi = info->item;
2475 long item = lvi.iItem;
98ec9dbe 2476
11358d39
VZ
2477 if ( lvi.mask & LVIF_TEXT )
2478 {
2479 wxString text = OnGetItemText(item, lvi.iSubItem);
64accea5 2480 wxStrlcpy(lvi.pszText, text.c_str(), lvi.cchTextMax);
11358d39 2481 }
98ec9dbe 2482
5b59df83
VZ
2483 // see comment at the end of wxListCtrl::GetColumn()
2484#ifdef NM_CUSTOMDRAW
11358d39
VZ
2485 if ( lvi.mask & LVIF_IMAGE )
2486 {
208458a7 2487 lvi.iImage = OnGetItemColumnImage(item, lvi.iSubItem);
11358d39 2488 }
5b59df83 2489#endif // NM_CUSTOMDRAW
98ec9dbe 2490
19def5e7
VZ
2491 // even though we never use LVM_SETCALLBACKMASK, we still
2492 // can get messages with LVIF_STATE in lvi.mask under Vista
2493 if ( lvi.mask & LVIF_STATE )
2494 {
2495 // we don't have anything to return from here...
2496 lvi.stateMask = 0;
2497 }
98ec9dbe 2498
598ddd96 2499 return true;
11358d39
VZ
2500 }
2501 // fall through
98ec9dbe 2502
11358d39 2503 default:
f0755097 2504 processed = false;
11358d39 2505 }
f0755097
VZ
2506
2507 if ( !processed )
2508 return wxControl::MSWOnNotify(idCtrl, lParam, result);
11358d39
VZ
2509 }
2510 else
2511 {
2512 // where did this one come from?
598ddd96 2513 return false;
acb62b84
VZ
2514 }
2515
bdc72a22
VZ
2516 // process the event
2517 // -----------------
2518
0b5efdc7 2519 event.SetEventType(eventType);
acb62b84 2520
937013e0 2521 bool processed = HandleWindowEvent(event);
acb62b84 2522
bdc72a22
VZ
2523 // post processing
2524 // ---------------
225fe9d6 2525 switch ( nmhdr->code )
acb62b84 2526 {
6932a32c 2527 case LVN_DELETEALLITEMS:
598ddd96 2528 // always return true to suppress all additional LVN_DELETEITEM
6932a32c
VZ
2529 // notifications - this makes deleting all items from a list ctrl
2530 // much faster
2531 *result = TRUE;
f7df21aa
VZ
2532
2533 // also, we may free all user data now (couldn't do it before as
2534 // the user should have access to it in OnDeleteAllItems() handler)
2535 FreeAllInternalData();
07763c99
VZ
2536
2537 // the control is empty now, synchronize the cached number of items
2538 // with the real one
2539 m_count = 0;
598ddd96 2540 return true;
6932a32c 2541
8c21905b
VS
2542 case LVN_ENDLABELEDITA:
2543 case LVN_ENDLABELEDITW:
3103e8a9 2544 // logic here is inverted compared to all the other messages
614391dc
VZ
2545 *result = event.IsAllowed();
2546
5cd4cb75
VZ
2547 // EDIT control will be deleted by the list control itself so
2548 // prevent us from deleting it as well
2549 DeleteEditControl();
2b5f62a0 2550
598ddd96 2551 return true;
acb62b84 2552 }
acb62b84 2553
68c124a1
RD
2554 if ( processed )
2555 *result = !event.IsAllowed();
fd3f686c 2556
68c124a1 2557 return processed;
2bda0e17
KB
2558}
2559
e6b1317b
VZ
2560// ----------------------------------------------------------------------------
2561// custom draw stuff
2562// ----------------------------------------------------------------------------
2563
5b59df83
VZ
2564// see comment at the end of wxListCtrl::GetColumn()
2565#ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
63166611 2566
e6b1317b
VZ
2567static RECT GetCustomDrawnItemRect(const NMCUSTOMDRAW& nmcd)
2568{
2569 RECT rc;
89cafab0 2570 wxGetListCtrlItemRect(nmcd.hdr.hwndFrom, nmcd.dwItemSpec, LVIR_BOUNDS, rc);
e6b1317b
VZ
2571
2572 RECT rcIcon;
89cafab0 2573 wxGetListCtrlItemRect(nmcd.hdr.hwndFrom, nmcd.dwItemSpec, LVIR_ICON, rcIcon);
e6b1317b
VZ
2574
2575 // exclude the icon part, neither the selection background nor focus rect
2576 // should cover it
2577 rc.left = rcIcon.right;
2578
2579 return rc;
2580}
2581
0c1602b8
VZ
2582static
2583bool HandleSubItemPrepaint(LPNMLVCUSTOMDRAW pLVCD, HFONT hfont, int colCount)
e6b1317b
VZ
2584{
2585 NMCUSTOMDRAW& nmcd = pLVCD->nmcd;
2586
2587 HDC hdc = nmcd.hdc;
2588 HWND hwndList = nmcd.hdr.hwndFrom;
223b7504 2589 const int col = pLVCD->iSubItem;
e6b1317b
VZ
2590 const DWORD item = nmcd.dwItemSpec;
2591
e6b1317b
VZ
2592 // the font must be valid, otherwise we wouldn't be painting the item at all
2593 SelectInHDC selFont(hdc, hfont);
2594
2595 // get the rectangle to paint
89cafab0 2596 int subitem = colCount ? col + 1 : col;
e6b1317b 2597 RECT rc;
89cafab0
VZ
2598 wxGetListCtrlSubItemRect(hwndList, item, subitem, LVIR_BOUNDS, rc);
2599 rc.left += 6;
e6b1317b
VZ
2600
2601 // get the image and text to draw
2602 wxChar text[512];
2603 LV_ITEM it;
2604 wxZeroMemory(it);
2605 it.mask = LVIF_TEXT | LVIF_IMAGE;
2606 it.iItem = item;
223b7504 2607 it.iSubItem = col;
e6b1317b
VZ
2608 it.pszText = text;
2609 it.cchTextMax = WXSIZEOF(text);
2610 ListView_GetItem(hwndList, &it);
2611
25e6a4a6
VZ
2612 HIMAGELIST himl = ListView_GetImageList(hwndList, LVSIL_SMALL);
2613 if ( himl && ImageList_GetImageCount(himl) )
e6b1317b 2614 {
25e6a4a6
VZ
2615 if ( it.iImage != -1 )
2616 {
2617 ImageList_Draw(himl, it.iImage, hdc, rc.left, rc.top,
2618 nmcd.uItemState & CDIS_SELECTED ? ILD_SELECTED
2619 : ILD_TRANSPARENT);
2620 }
e6b1317b 2621
25e6a4a6 2622 // notice that even if this item doesn't have any image, the list
23535447
VZ
2623 // control still leaves space for the image in the first column if the
2624 // image list is not empty (presumably so that items with and without
2625 // images align?)
2626 if ( it.iImage != -1 || it.iSubItem == 0 )
2627 {
2628 int wImage, hImage;
2629 ImageList_GetIconSize(himl, &wImage, &hImage);
e6b1317b 2630
23535447
VZ
2631 rc.left += wImage + 2;
2632 }
e6b1317b
VZ
2633 }
2634
2635 ::SetBkMode(hdc, TRANSPARENT);
2636
223b7504 2637 UINT fmt = DT_SINGLELINE |
5cce8340
VZ
2638#ifndef __WXWINCE__
2639 DT_WORD_ELLIPSIS |
2640#endif // __WXWINCE__
223b7504
VZ
2641 DT_NOPREFIX |
2642 DT_VCENTER;
2643
2644 LV_COLUMN lvCol;
2645 wxZeroMemory(lvCol);
2646 lvCol.mask = LVCF_FMT;
2647 if ( ListView_GetColumn(hwndList, col, &lvCol) )
2648 {
2649 switch ( lvCol.fmt & LVCFMT_JUSTIFYMASK )
2650 {
2651 case LVCFMT_LEFT:
2652 fmt |= DT_LEFT;
2653 break;
2654
2655 case LVCFMT_CENTER:
2656 fmt |= DT_CENTER;
2657 break;
2658
2659 case LVCFMT_RIGHT:
2660 fmt |= DT_RIGHT;
2661 break;
2662 }
2663 }
2664 //else: failed to get alignment, assume it's DT_LEFT (default)
2665
2666 DrawText(hdc, text, -1, &rc, fmt);
2667
2668 return true;
e6b1317b
VZ
2669}
2670
2671static void HandleItemPostpaint(NMCUSTOMDRAW nmcd)
2672{
2673 if ( nmcd.uItemState & CDIS_FOCUS )
2674 {
2675 RECT rc = GetCustomDrawnItemRect(nmcd);
2676
2677 // don't use the provided HDC, it's in some strange state by now
2678 ::DrawFocusRect(WindowHDC(nmcd.hdr.hwndFrom), &rc);
2679 }
2680}
2681
2682// pLVCD->clrText and clrTextBk should contain the colours to use
2683static void HandleItemPaint(LPNMLVCUSTOMDRAW pLVCD, HFONT hfont)
2684{
2685 NMCUSTOMDRAW& nmcd = pLVCD->nmcd; // just a shortcut
2686
13845bd5
VZ
2687 const HWND hwndList = nmcd.hdr.hwndFrom;
2688 const int item = nmcd.dwItemSpec;
e6b1317b
VZ
2689
2690 // unfortunately we can't trust CDIS_SELECTED, it is often set even when
2691 // the item is not at all selected for some reason (comctl32 6), but we
2692 // also can't always trust ListView_GetItem() as it could return the old
2693 // item status if we're called just after the (de)selection, so remember
2694 // the last item to gain selection and also check for it here
2695 for ( int i = -1;; )
2696 {
2697 i = ListView_GetNextItem(hwndList, i, LVNI_SELECTED);
2698 if ( i == -1 )
2699 {
2700 nmcd.uItemState &= ~CDIS_SELECTED;
2701 break;
2702 }
2703
13845bd5 2704 if ( i == item )
e6b1317b
VZ
2705 {
2706 nmcd.uItemState |= CDIS_SELECTED;
2707 break;
2708 }
2709 }
2710
13845bd5 2711 // same thing for CDIS_FOCUS (except simpler as there is only one of them)
728f972b 2712 if ( ::GetFocus() == hwndList &&
77cfdec0 2713 ListView_GetNextItem(hwndList, -1, LVNI_FOCUSED) == item )
13845bd5
VZ
2714 {
2715 nmcd.uItemState |= CDIS_FOCUS;
2716 }
2717 else
2718 {
2719 nmcd.uItemState &= ~CDIS_FOCUS;
2720 }
2721
e6b1317b
VZ
2722 if ( nmcd.uItemState & CDIS_SELECTED )
2723 {
2724 int syscolFg, syscolBg;
2725 if ( ::GetFocus() == hwndList )
2726 {
2727 syscolFg = COLOR_HIGHLIGHTTEXT;
2728 syscolBg = COLOR_HIGHLIGHT;
2729 }
2730 else // selected but unfocused
2731 {
2732 syscolFg = COLOR_WINDOWTEXT;
2733 syscolBg = COLOR_BTNFACE;
2734
2735 // don't grey out the icon in this case neither
2736 nmcd.uItemState &= ~CDIS_SELECTED;
2737 }
2738
2739 pLVCD->clrText = ::GetSysColor(syscolFg);
2740 pLVCD->clrTextBk = ::GetSysColor(syscolBg);
2741 }
2742 //else: not selected, use normal colours from pLVCD
2743
2744 HDC hdc = nmcd.hdc;
2745 RECT rc = GetCustomDrawnItemRect(nmcd);
2746
2747 ::SetTextColor(hdc, pLVCD->clrText);
2748 ::FillRect(hdc, &rc, AutoHBRUSH(pLVCD->clrTextBk));
2749
2750 // we could use CDRF_NOTIFYSUBITEMDRAW here but it results in weird repaint
2751 // problems so just draw everything except the focus rect from here instead
2752 const int colCount = Header_GetItemCount(ListView_GetHeader(hwndList));
2753 for ( int col = 0; col < colCount; col++ )
2754 {
2755 pLVCD->iSubItem = col;
0c1602b8 2756 HandleSubItemPrepaint(pLVCD, hfont, colCount);
e6b1317b
VZ
2757 }
2758
2759 HandleItemPostpaint(nmcd);
2760}
2761
2762static WXLPARAM HandleItemPrepaint(wxListCtrl *listctrl,
2763 LPNMLVCUSTOMDRAW pLVCD,
2764 wxListItemAttr *attr)
2765{
2766 if ( !attr )
2767 {
2768 // nothing to do for this item
2769 return CDRF_DODEFAULT;
2770 }
2771
2772
2773 // set the colours to use for text drawing
3568f700
WS
2774 pLVCD->clrText = attr->HasTextColour()
2775 ? wxColourToRGB(attr->GetTextColour())
2776 : wxColourToRGB(listctrl->GetTextColour());
2777 pLVCD->clrTextBk = attr->HasBackgroundColour()
2778 ? wxColourToRGB(attr->GetBackgroundColour())
2779 : wxColourToRGB(listctrl->GetBackgroundColour());
e6b1317b
VZ
2780
2781 // select the font if non default one is specified
2782 if ( attr->HasFont() )
2783 {
2784 wxFont font = attr->GetFont();
2785 if ( font.GetEncoding() != wxFONTENCODING_SYSTEM )
2786 {
2787 // the standard control ignores the font encoding/charset, at least
2788 // with recent comctl32.dll versions (5 and 6, it uses to work with
2789 // 4.something) so we have to draw the item entirely ourselves in
2790 // this case
2791 HandleItemPaint(pLVCD, GetHfontOf(font));
2792 return CDRF_SKIPDEFAULT;
2793 }
2794
2795 ::SelectObject(pLVCD->nmcd.hdc, GetHfontOf(font));
2796
2797 return CDRF_NEWFONT;
2798 }
2799
2800 return CDRF_DODEFAULT;
2801}
2802
63166611
VZ
2803WXLPARAM wxListCtrl::OnCustomDraw(WXLPARAM lParam)
2804{
e6b1317b
VZ
2805 LPNMLVCUSTOMDRAW pLVCD = (LPNMLVCUSTOMDRAW)lParam;
2806 NMCUSTOMDRAW& nmcd = pLVCD->nmcd;
63166611
VZ
2807 switch ( nmcd.dwDrawStage )
2808 {
2809 case CDDS_PREPAINT:
2810 // if we've got any items with non standard attributes,
2811 // notify us before painting each item
2812 //
2813 // for virtual controls, always suppose that we have attributes as
2814 // there is no way to check for this
e6b1317b
VZ
2815 if ( IsVirtual() || m_hasAnyAttr )
2816 return CDRF_NOTIFYITEMDRAW;
2817 break;
63166611
VZ
2818
2819 case CDDS_ITEMPREPAINT:
e6b1317b 2820 const int item = nmcd.dwItemSpec;
63166611 2821
e6b1317b
VZ
2822 // we get this message with item == 0 for an empty control, we
2823 // must ignore it as calling OnGetItemAttr() would be wrong
2824 if ( item < 0 || item >= GetItemCount() )
2825 break;
63166611 2826
e6b1317b 2827 return HandleItemPrepaint(this, pLVCD, DoGetItemAttr(item));
63166611 2828 }
e6b1317b
VZ
2829
2830 return CDRF_DODEFAULT;
63166611
VZ
2831}
2832
2833#endif // NM_CUSTOMDRAW supported
2834
2702ed5a
JS
2835// Necessary for drawing hrules and vrules, if specified
2836void wxListCtrl::OnPaint(wxPaintEvent& event)
2837{
d3acc83a
VZ
2838 const bool drawHRules = HasFlag(wxLC_HRULES);
2839 const bool drawVRules = HasFlag(wxLC_VRULES);
2e6a9dad 2840
d3acc83a 2841 if (!InReportView() || !(drawHRules || drawVRules))
2e6a9dad
VS
2842 {
2843 event.Skip();
2844 return;
2845 }
2846
2702ed5a
JS
2847 wxPaintDC dc(this);
2848
2849 wxControl::OnPaint(event);
2850
2851 // Reset the device origin since it may have been set
2852 dc.SetDeviceOrigin(0, 0);
2853
36c10aa1 2854 wxPen pen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT));
2702ed5a
JS
2855 dc.SetPen(pen);
2856 dc.SetBrush(* wxTRANSPARENT_BRUSH);
2857
2858 wxSize clientSize = GetClientSize();
2859 wxRect itemRect;
2702ed5a 2860
2702ed5a
JS
2861 int itemCount = GetItemCount();
2862 int i;
625cb8c0 2863 if (drawHRules)
2702ed5a 2864 {
6443de02
RD
2865 long top = GetTopItem();
2866 for (i = top; i < top + GetCountPerPage() + 1; i++)
2702ed5a 2867 {
625cb8c0 2868 if (GetItemRect(i, itemRect))
ca286917 2869 {
5cb598ae 2870 int cy = itemRect.GetTop();
625cb8c0
RD
2871 if (i != 0) // Don't draw the first one
2872 {
2873 dc.DrawLine(0, cy, clientSize.x, cy);
2874 }
2875 // Draw last line
2cefcb34 2876 if (i == itemCount - 1)
625cb8c0
RD
2877 {
2878 cy = itemRect.GetBottom();
2879 dc.DrawLine(0, cy, clientSize.x, cy);
2880 }
2702ed5a
JS
2881 }
2882 }
2883 }
2cefcb34 2884 i = itemCount - 1;
2702ed5a
JS
2885 if (drawVRules && (i > -1))
2886 {
2887 wxRect firstItemRect;
2888 GetItemRect(0, firstItemRect);
2889
2890 if (GetItemRect(i, itemRect))
2891 {
9eaba692
VZ
2892 // this is a fix for bug 673394: erase the pixels which we would
2893 // otherwise leave on the screen
2894 static const int gap = 2;
2895 dc.SetPen(*wxTRANSPARENT_PEN);
2896 dc.SetBrush(wxBrush(GetBackgroundColour()));
2897 dc.DrawRectangle(0, firstItemRect.GetY() - gap,
2898 clientSize.GetWidth(), gap);
2899
2900 dc.SetPen(pen);
2901 dc.SetBrush(*wxTRANSPARENT_BRUSH);
67d3fc49 2902
ceef3893
VZ
2903 const int numCols = GetColumnCount();
2904 wxVector<int> indexArray(numCols);
2905 if ( !ListView_GetColumnOrderArray(GetHwnd(),
2906 numCols,
2907 &indexArray[0]) )
7a8dce71
VZ
2908 {
2909 wxFAIL_MSG( _T("invalid column index array in OnPaint()") );
ceef3893 2910 return;
7a8dce71 2911 }
67d3fc49 2912
2702ed5a 2913 int x = itemRect.GetX();
67d3fc49 2914 for (int col = 0; col < numCols; col++)
2702ed5a 2915 {
67d3fc49 2916 int colWidth = GetColumnWidth(indexArray[col]);
2702ed5a 2917 x += colWidth ;
9eaba692
VZ
2918 dc.DrawLine(x-1, firstItemRect.GetY() - gap,
2919 x-1, itemRect.GetBottom());
2702ed5a
JS
2920 }
2921 }
2922 }
2923}
2924
4bd6ae0f
VZ
2925WXLRESULT
2926wxListCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
2927{
777f37e0 2928 switch ( nMsg )
4bd6ae0f 2929 {
777f37e0
VZ
2930#ifdef WM_PRINT
2931 case WM_PRINT:
2932 // we should bypass our own WM_PRINT handling as we don't handle
2933 // PRF_CHILDREN flag, so leave it to the native control itself
2934 return MSWDefWindowProc(nMsg, wParam, lParam);
4bd6ae0f
VZ
2935#endif // WM_PRINT
2936
777f37e0
VZ
2937 case WM_CONTEXTMENU:
2938 // because this message is propagated upwards the child-parent
2939 // chain, we get it for the right clicks on the header window but
2940 // this is confusing in wx as right clicking there already
2941 // generates a separate wxEVT_COMMAND_LIST_COL_RIGHT_CLICK event
2942 // so just ignore them
2943 if ( (HWND)wParam == ListView_GetHeader(GetHwnd()) )
2944 return 0;
2945 //else: break
2946 }
2947
4bd6ae0f
VZ
2948 return wxControl::MSWWindowProc(nMsg, wParam, lParam);
2949}
2950
98ec9dbe
VZ
2951// ----------------------------------------------------------------------------
2952// virtual list controls
2953// ----------------------------------------------------------------------------
2954
d699f48b 2955wxString wxListCtrl::OnGetItemText(long WXUNUSED(item), long WXUNUSED(col)) const
98ec9dbe
VZ
2956{
2957 // this is a pure virtual function, in fact - which is not really pure
2958 // because the controls which are not virtual don't need to implement it
271d1110 2959 wxFAIL_MSG( _T("wxListCtrl::OnGetItemText not supposed to be called") );
98ec9dbe
VZ
2960
2961 return wxEmptyString;
2962}
2963
d699f48b 2964int wxListCtrl::OnGetItemImage(long WXUNUSED(item)) const
98ec9dbe 2965{
611a725e
RD
2966 wxCHECK_MSG(!GetImageList(wxIMAGE_LIST_SMALL),
2967 -1,
208458a7
RD
2968 wxT("List control has an image list, OnGetItemImage or OnGetItemColumnImage should be overridden."));
2969 return -1;
2970}
2971
2972int wxListCtrl::OnGetItemColumnImage(long item, long column) const
2973{
2974 if (!column)
2975 return OnGetItemImage(item);
2976
98ec9dbe
VZ
2977 return -1;
2978}
2979
d699f48b 2980wxListItemAttr *wxListCtrl::OnGetItemAttr(long WXUNUSED_UNLESS_DEBUG(item)) const
6c02c329 2981{
63166611 2982 wxASSERT_MSG( item >= 0 && item < GetItemCount(),
6c02c329
VZ
2983 _T("invalid item index in OnGetItemAttr()") );
2984
2985 // no attributes by default
2986 return NULL;
2987}
2988
e6b1317b
VZ
2989wxListItemAttr *wxListCtrl::DoGetItemAttr(long item) const
2990{
2991 return IsVirtual() ? OnGetItemAttr(item)
2992 : wxGetInternalDataAttr(this, item);
2993}
2994
98ec9dbe
VZ
2995void wxListCtrl::SetItemCount(long count)
2996{
2997 wxASSERT_MSG( IsVirtual(), _T("this is for virtual controls only") );
2998
54759554
VZ
2999 if ( !::SendMessage(GetHwnd(), LVM_SETITEMCOUNT, (WPARAM)count,
3000 LVSICF_NOSCROLL | LVSICF_NOINVALIDATEALL) )
98ec9dbe
VZ
3001 {
3002 wxLogLastError(_T("ListView_SetItemCount"));
3003 }
68c124a1
RD
3004 m_count = count;
3005 wxASSERT_MSG( m_count == ListView_GetItemCount(GetHwnd()),
3006 wxT("m_count should match ListView_GetItemCount"));
98ec9dbe
VZ
3007}
3008
a7f560a2
VZ
3009void wxListCtrl::RefreshItem(long item)
3010{
ebc9b89d 3011 RefreshItems(item, item);
a7f560a2
VZ
3012}
3013
3014void wxListCtrl::RefreshItems(long itemFrom, long itemTo)
3015{
ebc9b89d 3016 ListView_RedrawItems(GetHwnd(), itemFrom, itemTo);
a7f560a2
VZ
3017}
3018
97c611f8
VZ
3019// ----------------------------------------------------------------------------
3020// internal data stuff
3021// ----------------------------------------------------------------------------
3022
6149de71 3023static wxListItemInternalData *wxGetInternalData(HWND hwnd, long itemId)
7cf46fdb
VZ
3024{
3025 LV_ITEM it;
3026 it.mask = LVIF_PARAM;
3027 it.iItem = itemId;
3028
97c611f8 3029 if ( !ListView_GetItem(hwnd, &it) )
7cf46fdb 3030 return NULL;
97c611f8
VZ
3031
3032 return (wxListItemInternalData *) it.lParam;
259c43f6 3033}
7cf46fdb 3034
97c611f8
VZ
3035static
3036wxListItemInternalData *wxGetInternalData(const wxListCtrl *ctl, long itemId)
7cf46fdb 3037{
97c611f8 3038 return wxGetInternalData(GetHwndOf(ctl), itemId);
259c43f6 3039}
7cf46fdb 3040
e6b1317b
VZ
3041static
3042wxListItemAttr *wxGetInternalDataAttr(const wxListCtrl *ctl, long itemId)
7cf46fdb 3043{
6149de71 3044 wxListItemInternalData *data = wxGetInternalData(ctl, itemId);
97c611f8
VZ
3045
3046 return data ? data->attr : NULL;
259c43f6 3047}
7cf46fdb 3048
6149de71
RD
3049static void wxDeleteInternalData(wxListCtrl* ctl, long itemId)
3050{
3051 wxListItemInternalData *data = wxGetInternalData(ctl, itemId);
3052 if (data)
3053 {
6149de71
RD
3054 LV_ITEM item;
3055 memset(&item, 0, sizeof(item));
3056 item.iItem = itemId;
3057 item.mask = LVIF_PARAM;
3058 item.lParam = (LPARAM) 0;
3059 ListView_SetItem((HWND)ctl->GetHWND(), &item);
cd01e364 3060 delete data;
6149de71
RD
3061 }
3062}
7cf46fdb 3063
97c611f8
VZ
3064// ----------------------------------------------------------------------------
3065// wxWin <-> MSW items conversions
3066// ----------------------------------------------------------------------------
3067
8dff2b5c
VZ
3068static void wxConvertFromMSWListItem(HWND hwndListCtrl,
3069 wxListItem& info,
3070 LV_ITEM& lvItem)
2bda0e17 3071{
73d8c5fd 3072 wxListItemInternalData *internaldata =
7cf46fdb
VZ
3073 (wxListItemInternalData *) lvItem.lParam;
3074
3075 if (internaldata)
3076 info.m_data = internaldata->lParam;
3077
0b5efdc7
VZ
3078 info.m_mask = 0;
3079 info.m_state = 0;
3080 info.m_stateMask = 0;
3081 info.m_itemId = lvItem.iItem;
acb62b84 3082
0b5efdc7 3083 long oldMask = lvItem.mask;
acb62b84 3084
598ddd96 3085 bool needText = false;
8dff2b5c 3086 if (hwndListCtrl != 0)
acb62b84 3087 {
0b5efdc7 3088 if ( lvItem.mask & LVIF_TEXT )
598ddd96 3089 needText = false;
0b5efdc7 3090 else
598ddd96 3091 needText = true;
acb62b84 3092
0b5efdc7
VZ
3093 if ( needText )
3094 {
837e5743 3095 lvItem.pszText = new wxChar[513];
0b5efdc7
VZ
3096 lvItem.cchTextMax = 512;
3097 }
edccf428 3098 lvItem.mask |= LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
8dff2b5c 3099 ::SendMessage(hwndListCtrl, LVM_GETITEM, 0, (LPARAM)& lvItem);
0b5efdc7 3100 }
acb62b84 3101
0b5efdc7 3102 if ( lvItem.mask & LVIF_STATE )
acb62b84 3103 {
0b5efdc7
VZ
3104 info.m_mask |= wxLIST_MASK_STATE;
3105
3106 if ( lvItem.stateMask & LVIS_CUT)
3107 {
edccf428 3108 info.m_stateMask |= wxLIST_STATE_CUT;
0b5efdc7 3109 if ( lvItem.state & LVIS_CUT )
edccf428 3110 info.m_state |= wxLIST_STATE_CUT;
0b5efdc7
VZ
3111 }
3112 if ( lvItem.stateMask & LVIS_DROPHILITED)
3113 {
edccf428 3114 info.m_stateMask |= wxLIST_STATE_DROPHILITED;
0b5efdc7 3115 if ( lvItem.state & LVIS_DROPHILITED )
edccf428 3116 info.m_state |= wxLIST_STATE_DROPHILITED;
0b5efdc7
VZ
3117 }
3118 if ( lvItem.stateMask & LVIS_FOCUSED)
3119 {
edccf428 3120 info.m_stateMask |= wxLIST_STATE_FOCUSED;
0b5efdc7 3121 if ( lvItem.state & LVIS_FOCUSED )
edccf428 3122 info.m_state |= wxLIST_STATE_FOCUSED;
0b5efdc7
VZ
3123 }
3124 if ( lvItem.stateMask & LVIS_SELECTED)
3125 {
edccf428 3126 info.m_stateMask |= wxLIST_STATE_SELECTED;
0b5efdc7 3127 if ( lvItem.state & LVIS_SELECTED )
edccf428 3128 info.m_state |= wxLIST_STATE_SELECTED;
0b5efdc7 3129 }
acb62b84 3130 }
0b5efdc7
VZ
3131
3132 if ( lvItem.mask & LVIF_TEXT )
acb62b84 3133 {
0b5efdc7
VZ
3134 info.m_mask |= wxLIST_MASK_TEXT;
3135 info.m_text = lvItem.pszText;
acb62b84 3136 }
0b5efdc7 3137 if ( lvItem.mask & LVIF_IMAGE )
acb62b84 3138 {
0b5efdc7
VZ
3139 info.m_mask |= wxLIST_MASK_IMAGE;
3140 info.m_image = lvItem.iImage;
acb62b84 3141 }
0b5efdc7
VZ
3142 if ( lvItem.mask & LVIF_PARAM )
3143 info.m_mask |= wxLIST_MASK_DATA;
3144 if ( lvItem.mask & LVIF_DI_SETITEM )
3145 info.m_mask |= wxLIST_SET_ITEM;
3146 info.m_col = lvItem.iSubItem;
3147
3148 if (needText)
acb62b84 3149 {
0b5efdc7
VZ
3150 if (lvItem.pszText)
3151 delete[] lvItem.pszText;
acb62b84 3152 }
edccf428 3153 lvItem.mask = oldMask;
2bda0e17
KB
3154}
3155
8dff2b5c
VZ
3156static void wxConvertToMSWFlags(long state, long stateMask, LV_ITEM& lvItem)
3157{
3158 if (stateMask & wxLIST_STATE_CUT)
3159 {
3160 lvItem.stateMask |= LVIS_CUT;
3161 if (state & wxLIST_STATE_CUT)
3162 lvItem.state |= LVIS_CUT;
3163 }
3164 if (stateMask & wxLIST_STATE_DROPHILITED)
3165 {
3166 lvItem.stateMask |= LVIS_DROPHILITED;
3167 if (state & wxLIST_STATE_DROPHILITED)
3168 lvItem.state |= LVIS_DROPHILITED;
3169 }
3170 if (stateMask & wxLIST_STATE_FOCUSED)
3171 {
3172 lvItem.stateMask |= LVIS_FOCUSED;
3173 if (state & wxLIST_STATE_FOCUSED)
3174 lvItem.state |= LVIS_FOCUSED;
3175 }
3176 if (stateMask & wxLIST_STATE_SELECTED)
3177 {
3178 lvItem.stateMask |= LVIS_SELECTED;
3179 if (state & wxLIST_STATE_SELECTED)
3180 lvItem.state |= LVIS_SELECTED;
3181 }
3182}
3183
3184static void wxConvertToMSWListItem(const wxListCtrl *ctrl,
3185 const wxListItem& info,
3186 LV_ITEM& lvItem)
2bda0e17 3187{
edccf428 3188 lvItem.iItem = (int) info.m_itemId;
acb62b84 3189
edccf428 3190 lvItem.iImage = info.m_image;
0b5efdc7
VZ
3191 lvItem.stateMask = 0;
3192 lvItem.state = 0;
3193 lvItem.mask = 0;
3194 lvItem.iSubItem = info.m_col;
acb62b84 3195
0b5efdc7 3196 if (info.m_mask & wxLIST_MASK_STATE)
acb62b84 3197 {
edccf428 3198 lvItem.mask |= LVIF_STATE;
8dff2b5c
VZ
3199
3200 wxConvertToMSWFlags(info.m_state, info.m_stateMask, lvItem);
acb62b84 3201 }
acb62b84 3202
0b5efdc7 3203 if (info.m_mask & wxLIST_MASK_TEXT)
acb62b84 3204 {
edccf428 3205 lvItem.mask |= LVIF_TEXT;
b5d43d1d 3206 if ( ctrl->HasFlag(wxLC_USER_TEXT) )
0b5efdc7
VZ
3207 {
3208 lvItem.pszText = LPSTR_TEXTCALLBACK;
3209 }
3210 else
3211 {
e421922f 3212 // pszText is not const, hence the cast
c9f78968 3213 lvItem.pszText = (wxChar *)info.m_text.wx_str();
0b5efdc7 3214 if ( lvItem.pszText )
8ecd5de2 3215 lvItem.cchTextMax = info.m_text.length();
0b5efdc7
VZ
3216 else
3217 lvItem.cchTextMax = 0;
3218 }
acb62b84 3219 }
0b5efdc7 3220 if (info.m_mask & wxLIST_MASK_IMAGE)
edccf428 3221 lvItem.mask |= LVIF_IMAGE;
2bda0e17
KB
3222}
3223
e64658ed
VZ
3224static void wxConvertToMSWListCol(HWND hwndList,
3225 int col,
3226 const wxListItem& item,
6f806543
VZ
3227 LV_COLUMN& lvCol)
3228{
3229 wxZeroMemory(lvCol);
3230
3231 if ( item.m_mask & wxLIST_MASK_TEXT )
3232 {
3233 lvCol.mask |= LVCF_TEXT;
c9f78968 3234 lvCol.pszText = (wxChar *)item.m_text.wx_str(); // cast is safe
6f806543
VZ
3235 }
3236
3237 if ( item.m_mask & wxLIST_MASK_FORMAT )
3238 {
3239 lvCol.mask |= LVCF_FMT;
3240
3241 if ( item.m_format == wxLIST_FORMAT_LEFT )
3242 lvCol.fmt = LVCFMT_LEFT;
3243 else if ( item.m_format == wxLIST_FORMAT_RIGHT )
3244 lvCol.fmt = LVCFMT_RIGHT;
3245 else if ( item.m_format == wxLIST_FORMAT_CENTRE )
3246 lvCol.fmt = LVCFMT_CENTER;
3247 }
3248
3249 if ( item.m_mask & wxLIST_MASK_WIDTH )
3250 {
3251 lvCol.mask |= LVCF_WIDTH;
3252 if ( item.m_width == wxLIST_AUTOSIZE)
3253 lvCol.cx = LVSCW_AUTOSIZE;
3254 else if ( item.m_width == wxLIST_AUTOSIZE_USEHEADER)
3255 lvCol.cx = LVSCW_AUTOSIZE_USEHEADER;
3256 else
3257 lvCol.cx = item.m_width;
3258 }
3259
5b59df83
VZ
3260 // see comment at the end of wxListCtrl::GetColumn()
3261#ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
6f806543
VZ
3262 if ( item.m_mask & wxLIST_MASK_IMAGE )
3263 {
5625d0d4 3264 if ( wxApp::GetComCtl32Version() >= 470 )
6f806543 3265 {
e64658ed 3266 lvCol.mask |= LVCF_IMAGE;
8b3a4016 3267
e64658ed 3268 // we use LVCFMT_BITMAP_ON_RIGHT because the images on the right
8b3a4016
VZ
3269 // seem to be generally nicer than on the left and the generic
3270 // version only draws them on the right (we don't have a flag to
3271 // specify the image location anyhow)
3272 //
3273 // we don't use LVCFMT_COL_HAS_IMAGES because it doesn't seem to
3274 // make any difference in my tests -- but maybe we should?
73bb5654 3275 if ( item.m_image != -1 )
e64658ed
VZ
3276 {
3277 // as we're going to overwrite the format field, get its
3278 // current value first -- unless we want to overwrite it anyhow
3279 if ( !(lvCol.mask & LVCF_FMT) )
3280 {
3281 LV_COLUMN lvColOld;
3282 wxZeroMemory(lvColOld);
3283 lvColOld.mask = LVCF_FMT;
3284 if ( ListView_GetColumn(hwndList, col, &lvColOld) )
3285 {
3286 lvCol.fmt = lvColOld.fmt;
3287 }
3288
3289 lvCol.mask |= LVCF_FMT;
3290 }
3291
73bb5654 3292 lvCol.fmt |= LVCFMT_BITMAP_ON_RIGHT | LVCFMT_IMAGE;
e64658ed 3293 }
8b3a4016 3294
6f806543
VZ
3295 lvCol.iImage = item.m_image;
3296 }
3297 //else: it doesn't support item images anyhow
3298 }
5b59df83 3299#endif // _WIN32_IE >= 0x0300
6f806543
VZ
3300}
3301
1e6feb95 3302#endif // wxUSE_LISTCTRL