]> git.saurik.com Git - wxWidgets.git/blame - src/msw/listctrl.cpp
Various compilation fixes.
[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 189
c0c133e1 190 wxDECLARE_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 237
c0c133e1 238 wxDECLARE_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
8d1a4101
FM
1165 // use wxCHECK_MSG against "item" too, for coherency with the generic implementation:
1166 wxCHECK_MSG( item >= 0 && item < GetItemCount(), false,
1167 _T("invalid item in GetSubItemRect") );
1168
2d33aec9 1169 int codeWin;
0b5efdc7 1170 if ( code == wxLIST_RECT_BOUNDS )
2d33aec9 1171 codeWin = LVIR_BOUNDS;
0b5efdc7 1172 else if ( code == wxLIST_RECT_ICON )
2d33aec9 1173 codeWin = LVIR_ICON;
0b5efdc7 1174 else if ( code == wxLIST_RECT_LABEL )
2d33aec9
VZ
1175 codeWin = LVIR_LABEL;
1176 else
1177 {
164a7972 1178 wxFAIL_MSG( _T("incorrect code in GetItemRect() / GetSubItemRect()") );
2d33aec9
VZ
1179 codeWin = LVIR_BOUNDS;
1180 }
2bda0e17 1181
e974c5d2 1182 RECT rectWin;
89cafab0 1183 if ( !wxGetListCtrlSubItemRect
e974c5d2
VZ
1184 (
1185 GetHwnd(),
1186 item,
1187 subItem == wxLIST_GETSUBITEMRECT_WHOLEITEM ? 0 : subItem,
1188 codeWin,
89cafab0 1189 rectWin
e974c5d2 1190 ) )
164a7972 1191 {
e974c5d2 1192 return false;
164a7972 1193 }
2bda0e17 1194
e974c5d2 1195 wxCopyRECTToRect(rectWin, rect);
2d33aec9 1196
67561862
VZ
1197 // there is no way to retrieve the first sub item bounding rectangle using
1198 // wxGetListCtrlSubItemRect() as 0 means the whole item, so we need to
1199 // truncate it at first column ourselves
1200 if ( subItem == 0 )
1201 rect.width = GetColumnWidth(0);
e974c5d2
VZ
1202
1203 return true;
2bda0e17
KB
1204}
1205
164a7972
VZ
1206
1207
1208
2bda0e17 1209// Gets the item position
debe6624 1210bool wxListCtrl::GetItemPosition(long item, wxPoint& pos) const
2bda0e17 1211{
0b5efdc7 1212 POINT pt;
2bda0e17 1213
edccf428 1214 bool success = (ListView_GetItemPosition(GetHwnd(), (int) item, &pt) != 0);
2bda0e17 1215
0b5efdc7
VZ
1216 pos.x = pt.x; pos.y = pt.y;
1217 return success;
2bda0e17
KB
1218}
1219
1220// Sets the item position.
debe6624 1221bool wxListCtrl::SetItemPosition(long item, const wxPoint& pos)
2bda0e17 1222{
edccf428 1223 return (ListView_SetItemPosition(GetHwnd(), (int) item, pos.x, pos.y) != 0);
2bda0e17
KB
1224}
1225
1226// Gets the number of items in the list control
c42404a5 1227int wxListCtrl::GetItemCount() const
2bda0e17 1228{
68c124a1 1229 return m_count;
2bda0e17
KB
1230}
1231
5db8d758
VZ
1232wxSize wxListCtrl::GetItemSpacing() const
1233{
66b9ec3d 1234 const int spacing = ListView_GetItemSpacing(GetHwnd(), (BOOL)HasFlag(wxLC_SMALL_ICON));
5db8d758
VZ
1235
1236 return wxSize(LOWORD(spacing), HIWORD(spacing));
1237}
1238
40ff126a
WS
1239#if WXWIN_COMPATIBILITY_2_6
1240
2bda0e17
KB
1241int wxListCtrl::GetItemSpacing(bool isSmall) const
1242{
edccf428 1243 return ListView_GetItemSpacing(GetHwnd(), (BOOL) isSmall);
2bda0e17
KB
1244}
1245
40ff126a
WS
1246#endif // WXWIN_COMPATIBILITY_2_6
1247
5b98eb2f
RL
1248void wxListCtrl::SetItemTextColour( long item, const wxColour &col )
1249{
1250 wxListItem info;
1251 info.m_itemId = item;
1252 info.SetTextColour( col );
1253 SetItem( info );
1254}
1255
1256wxColour wxListCtrl::GetItemTextColour( long item ) const
1257{
97c611f8
VZ
1258 wxColour col;
1259 wxListItemInternalData *data = wxGetInternalData(this, item);
1260 if ( data && data->attr )
1261 col = data->attr->GetTextColour();
1262
1263 return col;
5b98eb2f
RL
1264}
1265
1266void wxListCtrl::SetItemBackgroundColour( long item, const wxColour &col )
1267{
1268 wxListItem info;
1269 info.m_itemId = item;
1270 info.SetBackgroundColour( col );
1271 SetItem( info );
1272}
1273
1274wxColour wxListCtrl::GetItemBackgroundColour( long item ) const
1275{
97c611f8
VZ
1276 wxColour col;
1277 wxListItemInternalData *data = wxGetInternalData(this, item);
1278 if ( data && data->attr )
1279 col = data->attr->GetBackgroundColour();
1280
1281 return col;
5b98eb2f
RL
1282}
1283
35c2acd4
MW
1284void wxListCtrl::SetItemFont( long item, const wxFont &f )
1285{
1286 wxListItem info;
1287 info.m_itemId = item;
1288 info.SetFont( f );
1289 SetItem( info );
1290}
1291
1292wxFont wxListCtrl::GetItemFont( long item ) const
1293{
1294 wxFont f;
1295 wxListItemInternalData *data = wxGetInternalData(this, item);
1296 if ( data && data->attr )
1297 f = data->attr->GetFont();
1298
1299 return f;
1300}
1301
2bda0e17 1302// Gets the number of selected items in the list control
c42404a5 1303int wxListCtrl::GetSelectedItemCount() const
2bda0e17 1304{
edccf428 1305 return ListView_GetSelectedCount(GetHwnd());
2bda0e17
KB
1306}
1307
1308// Gets the text colour of the listview
c42404a5 1309wxColour wxListCtrl::GetTextColour() const
2bda0e17 1310{
6e21a3db
KH
1311 COLORREF ref = ListView_GetTextColor(GetHwnd());
1312 wxColour col(GetRValue(ref), GetGValue(ref), GetBValue(ref));
1313 return col;
2bda0e17
KB
1314}
1315
1316// Sets the text colour of the listview
1317void wxListCtrl::SetTextColour(const wxColour& col)
1318{
910484a6 1319 ListView_SetTextColor(GetHwnd(), PALETTERGB(col.Red(), col.Green(), col.Blue()));
2bda0e17
KB
1320}
1321
1322// Gets the index of the topmost visible item when in
1323// list or report view
c42404a5 1324long wxListCtrl::GetTopItem() const
2bda0e17 1325{
edccf428 1326 return (long) ListView_GetTopIndex(GetHwnd());
2bda0e17
KB
1327}
1328
1329// Searches for an item, starting from 'item'.
1330// 'geometry' is one of
1331// wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT.
1332// 'state' is a state bit flag, one or more of
1333// wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT.
1334// item can be -1 to find the first item that matches the
1335// specified flags.
1336// Returns the item or -1 if unsuccessful.
debe6624 1337long wxListCtrl::GetNextItem(long item, int geom, int state) const
2bda0e17 1338{
0b5efdc7 1339 long flags = 0;
2bda0e17 1340
0b5efdc7
VZ
1341 if ( geom == wxLIST_NEXT_ABOVE )
1342 flags |= LVNI_ABOVE;
1343 if ( geom == wxLIST_NEXT_ALL )
1344 flags |= LVNI_ALL;
1345 if ( geom == wxLIST_NEXT_BELOW )
1346 flags |= LVNI_BELOW;
1347 if ( geom == wxLIST_NEXT_LEFT )
1348 flags |= LVNI_TOLEFT;
1349 if ( geom == wxLIST_NEXT_RIGHT )
1350 flags |= LVNI_TORIGHT;
2bda0e17 1351
0b5efdc7
VZ
1352 if ( state & wxLIST_STATE_CUT )
1353 flags |= LVNI_CUT;
1354 if ( state & wxLIST_STATE_DROPHILITED )
1355 flags |= LVNI_DROPHILITED;
1356 if ( state & wxLIST_STATE_FOCUSED )
1357 flags |= LVNI_FOCUSED;
1358 if ( state & wxLIST_STATE_SELECTED )
1359 flags |= LVNI_SELECTED;
2bda0e17 1360
edccf428 1361 return (long) ListView_GetNextItem(GetHwnd(), item, flags);
2bda0e17
KB
1362}
1363
1364
debe6624 1365wxImageList *wxListCtrl::GetImageList(int which) const
2bda0e17 1366{
0b5efdc7 1367 if ( which == wxIMAGE_LIST_NORMAL )
2bda0e17 1368 {
0b5efdc7
VZ
1369 return m_imageListNormal;
1370 }
1371 else if ( which == wxIMAGE_LIST_SMALL )
2bda0e17 1372 {
0b5efdc7
VZ
1373 return m_imageListSmall;
1374 }
1375 else if ( which == wxIMAGE_LIST_STATE )
2bda0e17 1376 {
0b5efdc7
VZ
1377 return m_imageListState;
1378 }
1379 return NULL;
2bda0e17
KB
1380}
1381
debe6624 1382void wxListCtrl::SetImageList(wxImageList *imageList, int which)
2bda0e17 1383{
0b5efdc7
VZ
1384 int flags = 0;
1385 if ( which == wxIMAGE_LIST_NORMAL )
2bda0e17 1386 {
0b5efdc7 1387 flags = LVSIL_NORMAL;
2e12c11a 1388 if (m_ownsImageListNormal) delete m_imageListNormal;
0b5efdc7 1389 m_imageListNormal = imageList;
598ddd96 1390 m_ownsImageListNormal = false;
0b5efdc7
VZ
1391 }
1392 else if ( which == wxIMAGE_LIST_SMALL )
2bda0e17 1393 {
0b5efdc7 1394 flags = LVSIL_SMALL;
2e12c11a 1395 if (m_ownsImageListSmall) delete m_imageListSmall;
0b5efdc7 1396 m_imageListSmall = imageList;
598ddd96 1397 m_ownsImageListSmall = false;
0b5efdc7
VZ
1398 }
1399 else if ( which == wxIMAGE_LIST_STATE )
2bda0e17 1400 {
0b5efdc7 1401 flags = LVSIL_STATE;
2e12c11a 1402 if (m_ownsImageListState) delete m_imageListState;
0b5efdc7 1403 m_imageListState = imageList;
598ddd96 1404 m_ownsImageListState = false;
0b5efdc7 1405 }
8ecd5de2 1406 (void) ListView_SetImageList(GetHwnd(), (HIMAGELIST) imageList ? imageList->GetHIMAGELIST() : 0, flags);
2bda0e17
KB
1407}
1408
2e12c11a
VS
1409void wxListCtrl::AssignImageList(wxImageList *imageList, int which)
1410{
1411 SetImageList(imageList, which);
1412 if ( which == wxIMAGE_LIST_NORMAL )
598ddd96 1413 m_ownsImageListNormal = true;
2e12c11a 1414 else if ( which == wxIMAGE_LIST_SMALL )
598ddd96 1415 m_ownsImageListSmall = true;
2e12c11a 1416 else if ( which == wxIMAGE_LIST_STATE )
598ddd96 1417 m_ownsImageListState = true;
2e12c11a
VS
1418}
1419
edccf428 1420// ----------------------------------------------------------------------------
2bda0e17 1421// Operations
edccf428 1422// ----------------------------------------------------------------------------
2bda0e17
KB
1423
1424// Arranges the items
debe6624 1425bool wxListCtrl::Arrange(int flag)
2bda0e17 1426{
0b5efdc7
VZ
1427 UINT code = 0;
1428 if ( flag == wxLIST_ALIGN_LEFT )
1429 code = LVA_ALIGNLEFT;
1430 else if ( flag == wxLIST_ALIGN_TOP )
1431 code = LVA_ALIGNTOP;
1432 else if ( flag == wxLIST_ALIGN_DEFAULT )
1433 code = LVA_DEFAULT;
1434 else if ( flag == wxLIST_ALIGN_SNAP_TO_GRID )
1435 code = LVA_SNAPTOGRID;
2bda0e17 1436
edccf428 1437 return (ListView_Arrange(GetHwnd(), code) != 0);
2bda0e17
KB
1438}
1439
1440// Deletes an item
debe6624 1441bool wxListCtrl::DeleteItem(long item)
2bda0e17 1442{
2e9f62da
VZ
1443 if ( !ListView_DeleteItem(GetHwnd(), (int) item) )
1444 {
1445 wxLogLastError(_T("ListView_DeleteItem"));
598ddd96 1446 return false;
2e9f62da
VZ
1447 }
1448
7a462631 1449 m_count--;
68c124a1
RD
1450 wxASSERT_MSG( m_count == ListView_GetItemCount(GetHwnd()),
1451 wxT("m_count should match ListView_GetItemCount"));
1452
2e9f62da
VZ
1453 // the virtual list control doesn't refresh itself correctly, help it
1454 if ( IsVirtual() )
1455 {
1456 // we need to refresh all the lines below the one which was deleted
1457 wxRect rectItem;
1458 if ( item > 0 && GetItemCount() )
1459 {
1460 GetItemRect(item - 1, rectItem);
1461 }
1462 else
1463 {
1464 rectItem.y =
1465 rectItem.height = 0;
1466 }
1467
1468 wxRect rectWin = GetRect();
1469 rectWin.height = rectWin.GetBottom() - rectItem.GetBottom();
1470 rectWin.y = rectItem.GetBottom();
1471
1472 RefreshRect(rectWin);
1473 }
1474
598ddd96 1475 return true;
2bda0e17
KB
1476}
1477
1478// Deletes all items
0b5efdc7 1479bool wxListCtrl::DeleteAllItems()
2bda0e17 1480{
2e9f62da 1481 return ListView_DeleteAllItems(GetHwnd()) != 0;
2bda0e17
KB
1482}
1483
1484// Deletes all items
0b5efdc7 1485bool wxListCtrl::DeleteAllColumns()
2bda0e17 1486{
edccf428 1487 while ( m_colCount > 0 )
2bda0e17 1488 {
edccf428
VZ
1489 if ( ListView_DeleteColumn(GetHwnd(), 0) == 0 )
1490 {
f6bcfd97 1491 wxLogLastError(wxT("ListView_DeleteColumn"));
edccf428 1492
598ddd96 1493 return false;
edccf428
VZ
1494 }
1495
1496 m_colCount--;
2bda0e17 1497 }
edccf428 1498
223d09f6 1499 wxASSERT_MSG( m_colCount == 0, wxT("no columns should be left") );
edccf428 1500
598ddd96 1501 return true;
2bda0e17
KB
1502}
1503
1504// Deletes a column
debe6624 1505bool wxListCtrl::DeleteColumn(int col)
2bda0e17 1506{
edccf428 1507 bool success = (ListView_DeleteColumn(GetHwnd(), col) != 0);
2bda0e17
KB
1508
1509 if ( success && (m_colCount > 0) )
1510 m_colCount --;
1511 return success;
1512}
1513
1514// Clears items, and columns if there are any.
0b5efdc7 1515void wxListCtrl::ClearAll()
2bda0e17
KB
1516{
1517 DeleteAllItems();
1518 if ( m_colCount > 0 )
1519 DeleteAllColumns();
1520}
1521
508b6523
VZ
1522void wxListCtrl::InitEditControl(WXHWND hWnd)
1523{
1524 m_textCtrl->SetHWND(hWnd);
1525 m_textCtrl->SubclassWin(hWnd);
1526 m_textCtrl->SetParent(this);
1527
1528 // we must disallow TABbing away from the control while the edit contol is
1529 // shown because this leaves it in some strange state (just try removing
1530 // this line and then pressing TAB while editing an item in listctrl
1531 // inside a panel)
1532 m_textCtrl->SetWindowStyle(m_textCtrl->GetWindowStyle() | wxTE_PROCESS_TAB);
1533}
1534
bbcdf8bc
JS
1535wxTextCtrl* wxListCtrl::EditLabel(long item, wxClassInfo* textControlClass)
1536{
508b6523
VZ
1537 wxCHECK_MSG( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)), NULL,
1538 "control used for label editing must be a wxTextCtrl" );
bbcdf8bc 1539
6aaef140 1540 // ListView_EditLabel requires that the list has focus.
aa50e893 1541 SetFocus();
2b5f62a0 1542
508b6523
VZ
1543 // create m_textCtrl here before calling ListView_EditLabel() because it
1544 // generates wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT event from inside it and
1545 // the user handler for it can call GetEditControl() resulting in an on
1546 // demand creation of a stock wxTextCtrl instead of the control of a
1547 // (possibly) custom wxClassInfo
1548 DeleteEditControl();
1549 m_textCtrl = (wxTextCtrl *)textControlClass->CreateObject();
1550
6aaef140 1551 WXHWND hWnd = (WXHWND) ListView_EditLabel(GetHwnd(), item);
2b5f62a0
VZ
1552 if ( !hWnd )
1553 {
1554 // failed to start editing
508b6523
VZ
1555 delete m_textCtrl;
1556 m_textCtrl = NULL;
1557
2b5f62a0
VZ
1558 return NULL;
1559 }
bbcdf8bc 1560
508b6523
VZ
1561 // if GetEditControl() hasn't been called, we need to initialize the edit
1562 // control ourselves
1563 if ( !m_textCtrl->GetHWND() )
1564 InitEditControl(hWnd);
2b5f62a0 1565
bbcdf8bc
JS
1566 return m_textCtrl;
1567}
1568
1569// End label editing, optionally cancelling the edit
4496eadc 1570bool wxListCtrl::EndEditLabel(bool cancel)
2bda0e17 1571{
4496eadc
JS
1572 // m_textCtrl is not always ready, ie. in EVT_LIST_BEGIN_LABEL_EDIT
1573 HWND hwnd = ListView_GetEditControl(GetHwnd());
55f42db2
VZ
1574 if ( !hwnd )
1575 return false;
1576
1577 if ( cancel )
1578 ::SetWindowText(hwnd, wxEmptyString); // dubious but better than nothing
1579
1580 // we shouldn't destroy the control ourselves according to MSDN, which
1581 // proposes WM_CANCELMODE to do this, but it doesn't seem to work
1582 //
1583 // posting WM_CLOSE to it does seem to work without any side effects
1584 ::PostMessage(hwnd, WM_CLOSE, 0, 0);
1585
1586 return true;
2bda0e17
KB
1587}
1588
1589// Ensures this item is visible
debe6624 1590bool wxListCtrl::EnsureVisible(long item)
2bda0e17 1591{
598ddd96 1592 return ListView_EnsureVisible(GetHwnd(), (int) item, FALSE) != FALSE;
2bda0e17
KB
1593}
1594
1595// Find an item whose label matches this string, starting from the item after 'start'
1596// or the beginning if 'start' is -1.
debe6624 1597long wxListCtrl::FindItem(long start, const wxString& str, bool partial)
2bda0e17 1598{
0b5efdc7 1599 LV_FINDINFO findInfo;
2bda0e17 1600
0b5efdc7
VZ
1601 findInfo.flags = LVFI_STRING;
1602 if ( partial )
7edc258e 1603 findInfo.flags |= LVFI_PARTIAL;
e0a050e3 1604 findInfo.psz = str.wx_str();
2bda0e17 1605
3ca6a5f0
BP
1606 // ListView_FindItem() excludes the first item from search and to look
1607 // through all the items you need to start from -1 which is unnatural and
8036af01
JS
1608 // inconsistent with the generic version - so we adjust the index
1609 if (start != -1)
1610 start --;
1611 return ListView_FindItem(GetHwnd(), (int) start, &findInfo);
2bda0e17
KB
1612}
1613
1614// Find an item whose data matches this data, starting from the item after 'start'
1615// or the beginning if 'start' is -1.
72db8894
RD
1616// NOTE : Lindsay Mathieson - 14-July-2002
1617// No longer use ListView_FindItem as the data attribute is now stored
1618// in a wxListItemInternalData structure refernced by the actual lParam
81ce36aa 1619long wxListCtrl::FindItem(long start, wxUIntPtr data)
2bda0e17 1620{
72db8894
RD
1621 long idx = start + 1;
1622 long count = GetItemCount();
2bda0e17 1623
72db8894
RD
1624 while (idx < count)
1625 {
1626 if (GetItemData(idx) == data)
1627 return idx;
1628 idx++;
1629 };
2bda0e17 1630
72db8894 1631 return -1;
2bda0e17
KB
1632}
1633
1634// Find an item nearest this position in the specified direction, starting from
1635// the item after 'start' or the beginning if 'start' is -1.
debe6624 1636long wxListCtrl::FindItem(long start, const wxPoint& pt, int direction)
2bda0e17 1637{
0b5efdc7 1638 LV_FINDINFO findInfo;
2bda0e17 1639
0b5efdc7
VZ
1640 findInfo.flags = LVFI_NEARESTXY;
1641 findInfo.pt.x = pt.x;
1642 findInfo.pt.y = pt.y;
acb62b84 1643 findInfo.vkDirection = VK_RIGHT;
2bda0e17 1644
0b5efdc7
VZ
1645 if ( direction == wxLIST_FIND_UP )
1646 findInfo.vkDirection = VK_UP;
1647 else if ( direction == wxLIST_FIND_DOWN )
1648 findInfo.vkDirection = VK_DOWN;
1649 else if ( direction == wxLIST_FIND_LEFT )
1650 findInfo.vkDirection = VK_LEFT;
1651 else if ( direction == wxLIST_FIND_RIGHT )
1652 findInfo.vkDirection = VK_RIGHT;
1653
edccf428 1654 return ListView_FindItem(GetHwnd(), (int) start, & findInfo);
2bda0e17
KB
1655}
1656
1657// Determines which item (if any) is at the specified point,
1658// giving details in 'flags' (see wxLIST_HITTEST_... flags above)
be0e5d69
VZ
1659long
1660wxListCtrl::HitTest(const wxPoint& point, int& flags, long *ptrSubItem) const
2bda0e17
KB
1661{
1662 LV_HITTESTINFO hitTestInfo;
0b5efdc7
VZ
1663 hitTestInfo.pt.x = (int) point.x;
1664 hitTestInfo.pt.y = (int) point.y;
2bda0e17 1665
164a7972
VZ
1666 long item;
1667#ifdef LVM_SUBITEMHITTEST
1668 if ( ptrSubItem && wxApp::GetComCtl32Version() >= 470 )
1669 {
1670 item = ListView_SubItemHitTest(GetHwnd(), &hitTestInfo);
1671 *ptrSubItem = hitTestInfo.iSubItem;
1672 }
1673 else
1674#endif // LVM_SUBITEMHITTEST
1675 {
1676 item = ListView_HitTest(GetHwnd(), &hitTestInfo);
1677 }
2bda0e17 1678
0b5efdc7 1679 flags = 0;
698b34fa 1680
0b5efdc7
VZ
1681 if ( hitTestInfo.flags & LVHT_ABOVE )
1682 flags |= wxLIST_HITTEST_ABOVE;
1683 if ( hitTestInfo.flags & LVHT_BELOW )
1684 flags |= wxLIST_HITTEST_BELOW;
0b5efdc7
VZ
1685 if ( hitTestInfo.flags & LVHT_TOLEFT )
1686 flags |= wxLIST_HITTEST_TOLEFT;
1687 if ( hitTestInfo.flags & LVHT_TORIGHT )
1688 flags |= wxLIST_HITTEST_TORIGHT;
1689
698b34fa
VZ
1690 if ( hitTestInfo.flags & LVHT_NOWHERE )
1691 flags |= wxLIST_HITTEST_NOWHERE;
1692
1693 // note a bug or at least a very strange feature of comtl32.dll (tested
1694 // with version 4.0 under Win95 and 6.0 under Win 2003): if you click to
1695 // the right of the item label, ListView_HitTest() returns a combination of
1696 // LVHT_ONITEMICON, LVHT_ONITEMLABEL and LVHT_ONITEMSTATEICON -- filter out
1697 // the bits which don't make sense
1698 if ( hitTestInfo.flags & LVHT_ONITEMLABEL )
1699 {
1700 flags |= wxLIST_HITTEST_ONITEMLABEL;
1701
1702 // do not translate LVHT_ONITEMICON here, as per above
1703 }
1704 else
1705 {
1706 if ( hitTestInfo.flags & LVHT_ONITEMICON )
1707 flags |= wxLIST_HITTEST_ONITEMICON;
1708 if ( hitTestInfo.flags & LVHT_ONITEMSTATEICON )
1709 flags |= wxLIST_HITTEST_ONITEMSTATEICON;
1710 }
1711
164a7972 1712 return item;
2bda0e17
KB
1713}
1714
164a7972 1715
2bda0e17
KB
1716// Inserts an item, returning the index of the new item if successful,
1717// -1 otherwise.
fbfb8bcc 1718long wxListCtrl::InsertItem(const wxListItem& info)
2bda0e17 1719{
98ec9dbe
VZ
1720 wxASSERT_MSG( !IsVirtual(), _T("can't be used with virtual controls") );
1721
0b5efdc7
VZ
1722 LV_ITEM item;
1723 wxConvertToMSWListItem(this, info, item);
7cf46fdb 1724 item.mask &= ~LVIF_PARAM;
2bda0e17 1725
7cf46fdb
VZ
1726 // check wether we need to allocate our internal data
1727 bool needInternalData = ((info.m_mask & wxLIST_MASK_DATA) || info.HasAttributes());
1728 if (needInternalData)
bdc72a22 1729 {
598ddd96 1730 m_AnyInternalData = true;
7cf46fdb 1731 item.mask |= LVIF_PARAM;
2702ed5a 1732
7cf46fdb
VZ
1733 // internal stucture that manages data
1734 wxListItemInternalData *data = new wxListItemInternalData();
1735 item.lParam = (LPARAM) data;
2702ed5a 1736
7cf46fdb
VZ
1737 if (info.m_mask & wxLIST_MASK_DATA)
1738 data->lParam = info.m_data;
2702ed5a 1739
b653e655
VZ
1740 // check whether it has any custom attributes
1741 if ( info.HasAttributes() )
1742 {
7cf46fdb
VZ
1743 // take copy of attributes
1744 data->attr = new wxListItemAttr(*info.GetAttributes());
5205e26b
VZ
1745
1746 // and remember that we have some now...
598ddd96 1747 m_hasAnyAttr = true;
b653e655 1748 }
7cf46fdb
VZ
1749 };
1750
68c124a1 1751 long rv = ListView_InsertItem(GetHwnd(), & item);
b653e655
VZ
1752
1753 m_count++;
68c124a1
RD
1754 wxASSERT_MSG( m_count == ListView_GetItemCount(GetHwnd()),
1755 wxT("m_count should match ListView_GetItemCount"));
bdc72a22 1756
68c124a1 1757 return rv;
2bda0e17
KB
1758}
1759
debe6624 1760long wxListCtrl::InsertItem(long index, const wxString& label)
2bda0e17 1761{
0b5efdc7
VZ
1762 wxListItem info;
1763 info.m_text = label;
1764 info.m_mask = wxLIST_MASK_TEXT;
1765 info.m_itemId = index;
1766 return InsertItem(info);
2bda0e17
KB
1767}
1768
1769// Inserts an image item
debe6624 1770long wxListCtrl::InsertItem(long index, int imageIndex)
2bda0e17 1771{
0b5efdc7
VZ
1772 wxListItem info;
1773 info.m_image = imageIndex;
1774 info.m_mask = wxLIST_MASK_IMAGE;
1775 info.m_itemId = index;
1776 return InsertItem(info);
2bda0e17
KB
1777}
1778
1779// Inserts an image/string item
debe6624 1780long wxListCtrl::InsertItem(long index, const wxString& label, int imageIndex)
2bda0e17 1781{
0b5efdc7
VZ
1782 wxListItem info;
1783 info.m_image = imageIndex;
1784 info.m_text = label;
1785 info.m_mask = wxLIST_MASK_IMAGE | wxLIST_MASK_TEXT;
1786 info.m_itemId = index;
1787 return InsertItem(info);
2bda0e17
KB
1788}
1789
1790// For list view mode (only), inserts a column.
fbfb8bcc 1791long wxListCtrl::InsertColumn(long col, const wxListItem& item)
2bda0e17 1792{
0b5efdc7 1793 LV_COLUMN lvCol;
e64658ed 1794 wxConvertToMSWListCol(GetHwnd(), col, item, lvCol);
0b5efdc7 1795
6f806543 1796 if ( !(lvCol.mask & LVCF_WIDTH) )
e373f51b
VZ
1797 {
1798 // always give some width to the new column: this one is compatible
6f806543
VZ
1799 // with the generic version
1800 lvCol.mask |= LVCF_WIDTH;
e373f51b 1801 lvCol.cx = 80;
0b5efdc7 1802 }
e373f51b 1803
8b3a4016
VZ
1804 long n = ListView_InsertColumn(GetHwnd(), col, &lvCol);
1805 if ( n != -1 )
e373f51b
VZ
1806 {
1807 m_colCount++;
1808 }
8b3a4016 1809 else // failed to insert?
e373f51b 1810 {
223d09f6 1811 wxLogDebug(wxT("Failed to insert the column '%s' into listview!"),
e373f51b
VZ
1812 lvCol.pszText);
1813 }
1814
8b3a4016 1815 return n;
2bda0e17
KB
1816}
1817
bdc72a22
VZ
1818long wxListCtrl::InsertColumn(long col,
1819 const wxString& heading,
1820 int format,
1821 int width)
2bda0e17 1822{
0b5efdc7
VZ
1823 wxListItem item;
1824 item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT;
1825 item.m_text = heading;
1826 if ( width > -1 )
1827 {
1828 item.m_mask |= wxLIST_MASK_WIDTH;
1829 item.m_width = width;
1830 }
1831 item.m_format = format;
2bda0e17 1832
0b5efdc7 1833 return InsertColumn(col, item);
2bda0e17
KB
1834}
1835
2b5f62a0
VZ
1836// scroll the control by the given number of pixels (exception: in list view,
1837// dx is interpreted as number of columns)
debe6624 1838bool wxListCtrl::ScrollList(int dx, int dy)
2bda0e17 1839{
2b5f62a0
VZ
1840 if ( !ListView_Scroll(GetHwnd(), dx, dy) )
1841 {
1842 wxLogDebug(_T("ListView_Scroll(%d, %d) failed"), dx, dy);
1843
598ddd96 1844 return false;
2b5f62a0
VZ
1845 }
1846
598ddd96 1847 return true;
2bda0e17
KB
1848}
1849
1850// Sort items.
1851
1852// fn is a function which takes 3 long arguments: item1, item2, data.
1853// item1 is the long data associated with a first item (NOT the index).
1854// item2 is the long data associated with a second item (NOT the index).
1855// data is the same value as passed to SortItems.
1856// The return value is a negative number if the first item should precede the second
1857// item, a positive number of the second item should precede the first,
1858// or zero if the two items are equivalent.
1859
1860// data is arbitrary data to be passed to the sort function.
19230604 1861
7cf46fdb
VZ
1862// Internal structures for proxying the user compare function
1863// so that we can pass it the *real* user data
19230604 1864
7cf46fdb
VZ
1865// translate lParam data and call user func
1866struct wxInternalDataSort
19230604 1867{
7cf46fdb
VZ
1868 wxListCtrlCompare user_fn;
1869 long data;
1870};
19230604 1871
7cf46fdb 1872int CALLBACK wxInternalDataCompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
2bda0e17 1873{
7cf46fdb 1874 struct wxInternalDataSort *internalData = (struct wxInternalDataSort *) lParamSort;
19230604 1875
7cf46fdb
VZ
1876 wxListItemInternalData *data1 = (wxListItemInternalData *) lParam1;
1877 wxListItemInternalData *data2 = (wxListItemInternalData *) lParam2;
19230604 1878
7cf46fdb
VZ
1879 long d1 = (data1 == NULL ? 0 : data1->lParam);
1880 long d2 = (data2 == NULL ? 0 : data2->lParam);
19230604 1881
7cf46fdb 1882 return internalData->user_fn(d1, d2, internalData->data);
19230604 1883
259c43f6 1884}
19230604 1885
7cf46fdb
VZ
1886bool wxListCtrl::SortItems(wxListCtrlCompare fn, long data)
1887{
1888 struct wxInternalDataSort internalData;
1889 internalData.user_fn = fn;
1890 internalData.data = data;
19230604 1891
14090241
VZ
1892 // WPARAM cast is needed for mingw/cygwin
1893 if ( !ListView_SortItems(GetHwnd(),
1894 wxInternalDataCompareFunc,
1895 (WPARAM) &internalData) )
19230604
RD
1896 {
1897 wxLogDebug(_T("ListView_SortItems() failed"));
1898
598ddd96 1899 return false;
19230604
RD
1900 }
1901
598ddd96 1902 return true;
2bda0e17
KB
1903}
1904
19230604
RD
1905
1906
edccf428
VZ
1907// ----------------------------------------------------------------------------
1908// message processing
1909// ----------------------------------------------------------------------------
1910
90c6edd7
VZ
1911bool wxListCtrl::MSWShouldPreProcessMessage(WXMSG* msg)
1912{
1913 if ( msg->message == WM_KEYDOWN )
1914 {
6719c06a
VZ
1915 // Only eat VK_RETURN if not being used by the application in
1916 // conjunction with modifiers
1917 if ( msg->wParam == VK_RETURN && !wxIsAnyModifierDown() )
90c6edd7 1918 {
6719c06a 1919 // we need VK_RETURN to generate wxEVT_COMMAND_LIST_ITEM_ACTIVATED
90c6edd7
VZ
1920 return false;
1921 }
1922 }
90c6edd7
VZ
1923 return wxControl::MSWShouldPreProcessMessage(msg);
1924}
1925
0edeeb6d 1926bool wxListCtrl::MSWCommand(WXUINT cmd, WXWORD id_)
2bda0e17 1927{
0edeeb6d 1928 const int id = (signed short)id_;
0b5efdc7 1929 if (cmd == EN_UPDATE)
acb62b84 1930 {
0b5efdc7
VZ
1931 wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
1932 event.SetEventObject( this );
1933 ProcessCommand(event);
598ddd96 1934 return true;
acb62b84 1935 }
0b5efdc7 1936 else if (cmd == EN_KILLFOCUS)
acb62b84 1937 {
0b5efdc7
VZ
1938 wxCommandEvent event(wxEVT_KILL_FOCUS, id);
1939 event.SetEventObject( this );
1940 ProcessCommand(event);
598ddd96 1941 return true;
acb62b84 1942 }
edccf428 1943 else
598ddd96 1944 return false;
0b5efdc7
VZ
1945}
1946
a9fdf824 1947// utility used by wxListCtrl::MSWOnNotify and by wxDataViewHeaderWindowMSW::MSWOnNotify
a68962fc 1948int WXDLLIMPEXP_CORE wxMSWGetColumnClicked(NMHDR *nmhdr, POINT *ptClick)
a9fdf824 1949{
674c2750
VZ
1950 // find the column clicked: we have to search for it ourselves as the
1951 // notification message doesn't provide this info
a9fdf824
RR
1952
1953 // where did the click occur?
1954#if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
674c2750 1955 if ( nmhdr->code == GN_CONTEXTMENU )
a9fdf824
RR
1956 {
1957 *ptClick = ((NMRGINFO*)nmhdr)->ptAction;
f4322df6 1958 }
a9fdf824
RR
1959 else
1960#endif //__WXWINCE__
1961 if ( !::GetCursorPos(ptClick) )
1962 {
1963 wxLogLastError(_T("GetCursorPos"));
1964 }
1965
674c2750
VZ
1966 // we need to use listctrl coordinates for the event point so this is what
1967 // we return in ptClick, but for comparison with Header_GetItemRect()
1968 // result below we need to use header window coordinates
1969 POINT ptClickHeader = *ptClick;
1970 if ( !::ScreenToClient(nmhdr->hwndFrom, &ptClickHeader) )
a9fdf824 1971 {
674c2750 1972 wxLogLastError(_T("ScreenToClient(listctrl header)"));
a9fdf824
RR
1973 }
1974
674c2750
VZ
1975 if ( !::ScreenToClient(::GetParent(nmhdr->hwndFrom), ptClick) )
1976 {
1977 wxLogLastError(_T("ScreenToClient(listctrl)"));
1978 }
a9fdf824 1979
674c2750 1980 const int colCount = Header_GetItemCount(nmhdr->hwndFrom);
a9fdf824
RR
1981 for ( int col = 0; col < colCount; col++ )
1982 {
674c2750 1983 RECT rect;
a9fdf824
RR
1984 if ( Header_GetItemRect(nmhdr->hwndFrom, col, &rect) )
1985 {
674c2750 1986 if ( ::PtInRect(&rect, ptClickHeader) )
a9fdf824
RR
1987 {
1988 return col;
1989 }
1990 }
1991 }
1992
1993 return wxNOT_FOUND;
1994}
1995
a23fd0e1 1996bool wxListCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
0b5efdc7 1997{
68c124a1 1998
bdc72a22
VZ
1999 // prepare the event
2000 // -----------------
2001
0b5efdc7 2002 wxListEvent event(wxEVT_NULL, m_windowId);
648bec3e
VZ
2003 event.SetEventObject(this);
2004
0b5efdc7 2005 wxEventType eventType = wxEVT_NULL;
225fe9d6 2006
bdc72a22 2007 NMHDR *nmhdr = (NMHDR *)lParam;
225fe9d6 2008
d1f2eb1d
VZ
2009 // if your compiler is as broken as this, you should really change it: this
2010 // code is needed for normal operation! #ifdef below is only useful for
2011 // automatic rebuilds which are done with a very old compiler version
0cf5b099 2012#ifdef HDN_BEGINTRACKA
d1f2eb1d 2013
11358d39
VZ
2014 // check for messages from the header (in report view)
2015 HWND hwndHdr = ListView_GetHeader(GetHwnd());
225fe9d6 2016
11358d39
VZ
2017 // is it a message from the header?
2018 if ( nmhdr->hwndFrom == hwndHdr )
acb62b84 2019 {
00811ff9 2020 HD_NOTIFY *nmHDR = (HD_NOTIFY *)nmhdr;
0cf5b099 2021
11358d39 2022 event.m_itemIndex = -1;
cb0f56f9 2023
11358d39
VZ
2024 switch ( nmhdr->code )
2025 {
2026 // yet another comctl32.dll bug: under NT/W2K it sends Unicode
2027 // TRACK messages even to ANSI programs: on my system I get
2028 // HDN_BEGINTRACKW and HDN_ENDTRACKA and no HDN_TRACK at all!
2029 //
2030 // work around is to simply catch both versions and hope that it
2031 // works (why should this message exist in ANSI and Unicode is
2032 // beyond me as it doesn't deal with strings at all...)
2b5f62a0
VZ
2033 //
2034 // note that fr HDN_TRACK another possibility could be to use
2035 // HDN_ITEMCHANGING but it is sent even after HDN_ENDTRACK and when
2036 // something other than the item width changes so we'd have to
2037 // filter out the unwanted events then
11358d39
VZ
2038 case HDN_BEGINTRACKA:
2039 case HDN_BEGINTRACKW:
2040 eventType = wxEVT_COMMAND_LIST_COL_BEGIN_DRAG;
2041 // fall through
2042
2043 case HDN_TRACKA:
2044 case HDN_TRACKW:
2045 if ( eventType == wxEVT_NULL )
2046 eventType = wxEVT_COMMAND_LIST_COL_DRAGGING;
2047 // fall through
2048
2049 case HDN_ENDTRACKA:
2050 case HDN_ENDTRACKW:
2051 if ( eventType == wxEVT_NULL )
2052 eventType = wxEVT_COMMAND_LIST_COL_END_DRAG;
2b5f62a0
VZ
2053
2054 event.m_item.m_width = nmHDR->pitem->cxy;
11358d39
VZ
2055 event.m_col = nmHDR->iItem;
2056 break;
2057
781a24e8 2058#if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
80a81a12 2059 case GN_CONTEXTMENU:
a61d4011 2060#endif //__WXWINCE__
11358d39
VZ
2061 case NM_RCLICK:
2062 {
11358d39 2063 POINT ptClick;
5ea47806 2064
a9fdf824
RR
2065 eventType = wxEVT_COMMAND_LIST_COL_RIGHT_CLICK;
2066 event.m_col = wxMSWGetColumnClicked(nmhdr, &ptClick);
11358d39
VZ
2067 event.m_pointDrag.x = ptClick.x;
2068 event.m_pointDrag.y = ptClick.y;
11358d39
VZ
2069 }
2070 break;
5ea47806 2071
2b5f62a0 2072 case HDN_GETDISPINFOW:
c68f590a
VZ
2073 // letting Windows XP handle this message results in mysterious
2074 // crashes in comctl32.dll seemingly because of bad message
2075 // parameters
2076 //
2077 // I have no idea what is the real cause of the bug (which is,
a9fdf824 2078 // just to make things interesting, impossible to reproduce
c68f590a
VZ
2079 // reliably) but ignoring all these messages does fix it and
2080 // doesn't seem to have any negative consequences
2081 return true;
2b5f62a0 2082
11358d39
VZ
2083 default:
2084 return wxControl::MSWOnNotify(idCtrl, lParam, result);
2085 }
2086 }
d1f2eb1d 2087 else
0cf5b099 2088#endif // defined(HDN_BEGINTRACKA)
164e8d41 2089 if ( nmhdr->hwndFrom == GetHwnd() )
11358d39
VZ
2090 {
2091 // almost all messages use NM_LISTVIEW
2092 NM_LISTVIEW *nmLV = (NM_LISTVIEW *)nmhdr;
bdc72a22 2093
2b5f62a0
VZ
2094 const int iItem = nmLV->iItem;
2095
68c124a1
RD
2096
2097 // FreeAllInternalData will cause LVN_ITEMCHANG* messages, which can be
2098 // ignored for efficiency. It is done here because the internal data is in the
2099 // process of being deleted so we don't want to try and access it below.
2100 if ( m_ignoreChangeMessages &&
7a462631
VZ
2101 ( (nmLV->hdr.code == LVN_ITEMCHANGED) ||
2102 (nmLV->hdr.code == LVN_ITEMCHANGING)) )
2b5f62a0 2103 {
598ddd96 2104 return true;
68c124a1 2105 }
7eb833e6 2106
2b5f62a0 2107
68c124a1
RD
2108 // If we have a valid item then check if there is a data value
2109 // associated with it and put it in the event.
2110 if ( iItem >= 0 && iItem < GetItemCount() )
2111 {
2112 wxListItemInternalData *internaldata =
2113 wxGetInternalData(GetHwnd(), iItem);
2b5f62a0 2114
68c124a1
RD
2115 if ( internaldata )
2116 event.m_item.m_data = internaldata->lParam;
2b5f62a0 2117 }
bdc72a22 2118
f0755097 2119 bool processed = true;
11358d39
VZ
2120 switch ( nmhdr->code )
2121 {
2122 case LVN_BEGINRDRAG:
2123 eventType = wxEVT_COMMAND_LIST_BEGIN_RDRAG;
2124 // fall through
7bf1474a 2125
11358d39
VZ
2126 case LVN_BEGINDRAG:
2127 if ( eventType == wxEVT_NULL )
2128 {
2129 eventType = wxEVT_COMMAND_LIST_BEGIN_DRAG;
2130 }
bdc72a22 2131
2b5f62a0 2132 event.m_itemIndex = iItem;
11358d39
VZ
2133 event.m_pointDrag.x = nmLV->ptAction.x;
2134 event.m_pointDrag.y = nmLV->ptAction.y;
2135 break;
2136
8c21905b 2137 // NB: we have to handle both *A and *W versions here because some
d2ed74b9
VZ
2138 // versions of comctl32.dll send ANSI messages even to the
2139 // Unicode windows
8c21905b 2140 case LVN_BEGINLABELEDITA:
8c21905b
VS
2141 case LVN_BEGINLABELEDITW:
2142 {
d2ed74b9
VZ
2143 wxLV_ITEM item;
2144 if ( nmhdr->code == LVN_BEGINLABELEDITA )
2145 {
2146 item.Init(((LV_DISPINFOA *)lParam)->item);
2147 }
2148 else // LVN_BEGINLABELEDITW
2149 {
2150 item.Init(((LV_DISPINFOW *)lParam)->item);
2151 }
2152
8c21905b 2153 eventType = wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT;
8c21905b
VS
2154 wxConvertFromMSWListItem(GetHwnd(), event.m_item, item);
2155 event.m_itemIndex = event.m_item.m_itemId;
2156 }
2157 break;
2158
2159 case LVN_ENDLABELEDITA:
d2ed74b9 2160 case LVN_ENDLABELEDITW:
8c21905b 2161 {
d2ed74b9
VZ
2162 wxLV_ITEM item;
2163 if ( nmhdr->code == LVN_ENDLABELEDITA )
c546974f 2164 {
d2ed74b9
VZ
2165 item.Init(((LV_DISPINFOA *)lParam)->item);
2166 }
2167 else // LVN_ENDLABELEDITW
2168 {
2169 item.Init(((LV_DISPINFOW *)lParam)->item);
c546974f 2170 }
8c21905b 2171
d2ed74b9
VZ
2172 // was editing cancelled?
2173 const LV_ITEM& lvi = (LV_ITEM)item;
2174 if ( !lvi.pszText || lvi.iItem == -1 )
c546974f 2175 {
5cd4cb75
VZ
2176 // EDIT control will be deleted by the list control
2177 // itself so prevent us from deleting it as well
2178 DeleteEditControl();
d2ed74b9
VZ
2179
2180 event.SetEditCanceled(true);
c546974f 2181 }
8c21905b 2182
d2ed74b9
VZ
2183 eventType = wxEVT_COMMAND_LIST_END_LABEL_EDIT;
2184 wxConvertFromMSWListItem(NULL, event.m_item, item);
11358d39
VZ
2185 event.m_itemIndex = event.m_item.m_itemId;
2186 }
2187 break;
edccf428 2188
11358d39
VZ
2189 case LVN_COLUMNCLICK:
2190 eventType = wxEVT_COMMAND_LIST_COL_CLICK;
2191 event.m_itemIndex = -1;
2192 event.m_col = nmLV->iSubItem;
2193 break;
bdc72a22 2194
11358d39
VZ
2195 case LVN_DELETEALLITEMS:
2196 eventType = wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS;
2197 event.m_itemIndex = -1;
11358d39
VZ
2198 break;
2199
2200 case LVN_DELETEITEM:
07763c99
VZ
2201 if ( m_count == 0 )
2202 {
2203 // this should be prevented by the post-processing code
2204 // below, but "just in case"
598ddd96 2205 return false;
07763c99 2206 }
68c124a1 2207
11358d39 2208 eventType = wxEVT_COMMAND_LIST_DELETE_ITEM;
2b5f62a0 2209 event.m_itemIndex = iItem;
7cf46fdb 2210 // delete the assoicated internal data
2b5f62a0 2211 wxDeleteInternalData(this, iItem);
11358d39
VZ
2212 break;
2213
11358d39
VZ
2214 case LVN_INSERTITEM:
2215 eventType = wxEVT_COMMAND_LIST_INSERT_ITEM;
2b5f62a0 2216 event.m_itemIndex = iItem;
11358d39 2217 break;
edccf428 2218
11358d39 2219 case LVN_ITEMCHANGED:
648bec3e 2220 // we translate this catch all message into more interesting
77ffb593 2221 // (and more easy to process) wxWidgets events
648bec3e 2222
2b5f62a0
VZ
2223 // first of all, we deal with the state change events only and
2224 // only for valid items (item == -1 for the virtual list
2225 // control)
2226 if ( nmLV->uChanged & LVIF_STATE && iItem != -1 )
11358d39 2227 {
648bec3e
VZ
2228 // temp vars for readability
2229 const UINT stOld = nmLV->uOldState;
2230 const UINT stNew = nmLV->uNewState;
2231
2b5f62a0
VZ
2232 event.m_item.SetId(iItem);
2233 event.m_item.SetMask(wxLIST_MASK_TEXT |
2234 wxLIST_MASK_IMAGE |
2235 wxLIST_MASK_DATA);
2236 GetItem(event.m_item);
2237
648bec3e
VZ
2238 // has the focus changed?
2239 if ( !(stOld & LVIS_FOCUSED) && (stNew & LVIS_FOCUSED) )
2240 {
2241 eventType = wxEVT_COMMAND_LIST_ITEM_FOCUSED;
2b5f62a0 2242 event.m_itemIndex = iItem;
648bec3e
VZ
2243 }
2244
2245 if ( (stNew & LVIS_SELECTED) != (stOld & LVIS_SELECTED) )
2246 {
2247 if ( eventType != wxEVT_NULL )
2248 {
2249 // focus and selection have both changed: send the
2250 // focus event from here and the selection one
2251 // below
2252 event.SetEventType(eventType);
937013e0 2253 (void)HandleWindowEvent(event);
648bec3e
VZ
2254 }
2255 else // no focus event to send
2256 {
2257 // then need to set m_itemIndex as it wasn't done
2258 // above
2b5f62a0 2259 event.m_itemIndex = iItem;
648bec3e
VZ
2260 }
2261
2262 eventType = stNew & LVIS_SELECTED
2263 ? wxEVT_COMMAND_LIST_ITEM_SELECTED
2264 : wxEVT_COMMAND_LIST_ITEM_DESELECTED;
2265 }
edccf428 2266 }
648bec3e
VZ
2267
2268 if ( eventType == wxEVT_NULL )
edccf428 2269 {
648bec3e 2270 // not an interesting event for us
598ddd96 2271 return false;
edccf428 2272 }
648bec3e 2273
11358d39 2274 break;
225fe9d6 2275
11358d39
VZ
2276 case LVN_KEYDOWN:
2277 {
2278 LV_KEYDOWN *info = (LV_KEYDOWN *)lParam;
2279 WORD wVKey = info->wVKey;
2280
2281 // get the current selection
2282 long lItem = GetNextItem(-1,
2283 wxLIST_NEXT_ALL,
2284 wxLIST_STATE_SELECTED);
2285
2286 // <Enter> or <Space> activate the selected item if any (but
ec27ba21
VZ
2287 // not with any modifiers as they have a predefined meaning
2288 // then)
11358d39
VZ
2289 if ( lItem != -1 &&
2290 (wVKey == VK_RETURN || wVKey == VK_SPACE) &&
ec27ba21 2291 !wxIsAnyModifierDown() )
11358d39
VZ
2292 {
2293 eventType = wxEVT_COMMAND_LIST_ITEM_ACTIVATED;
2294 }
2295 else
2296 {
2297 eventType = wxEVT_COMMAND_LIST_KEY_DOWN;
185d0094
VZ
2298
2299 // wxCharCodeMSWToWX() returns 0 if the key is an ASCII
2300 // value which should be used as is
2301 int code = wxCharCodeMSWToWX(wVKey);
2302 event.m_code = code ? code : wVKey;
11358d39 2303 }
7db91489 2304
11358d39
VZ
2305 event.m_itemIndex =
2306 event.m_item.m_itemId = lItem;
2307
2308 if ( lItem != -1 )
2309 {
2310 // fill the other fields too
2311 event.m_item.m_text = GetItemText(lItem);
2312 event.m_item.m_data = GetItemData(lItem);
2313 }
2314 }
2315 break;
2316
2317 case NM_DBLCLK:
2318 // if the user processes it in wxEVT_COMMAND_LEFT_CLICK(), don't do
2319 // anything else
2320 if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
f6bcfd97 2321 {
598ddd96 2322 return true;
f6bcfd97 2323 }
edccf428 2324
11358d39
VZ
2325 // else translate it into wxEVT_COMMAND_LIST_ITEM_ACTIVATED event
2326 // if it happened on an item (and not on empty place)
2b5f62a0 2327 if ( iItem == -1 )
11358d39
VZ
2328 {
2329 // not on item
598ddd96 2330 return false;
11358d39 2331 }
edccf428 2332
11358d39 2333 eventType = wxEVT_COMMAND_LIST_ITEM_ACTIVATED;
2b5f62a0
VZ
2334 event.m_itemIndex = iItem;
2335 event.m_item.m_text = GetItemText(iItem);
2336 event.m_item.m_data = GetItemData(iItem);
11358d39 2337 break;
225fe9d6 2338
781a24e8 2339#if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
80a81a12 2340 case GN_CONTEXTMENU:
a61d4011 2341#endif //__WXWINCE__
11358d39 2342 case NM_RCLICK:
225fe9d6
VZ
2343 // if the user processes it in wxEVT_COMMAND_RIGHT_CLICK(),
2344 // don't do anything else
2345 if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
2346 {
598ddd96 2347 return true;
225fe9d6 2348 }
cb0f56f9 2349
225fe9d6
VZ
2350 // else translate it into wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK event
2351 LV_HITTESTINFO lvhti;
2352 wxZeroMemory(lvhti);
11c7d5b6 2353
781a24e8 2354#if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
37b53d2a
JS
2355 if(nmhdr->code == GN_CONTEXTMENU) {
2356 lvhti.pt = ((NMRGINFO*)nmhdr)->ptAction;
598ddd96 2357 } else
a61d4011 2358#endif //__WXWINCE__
225fe9d6
VZ
2359 ::GetCursorPos(&(lvhti.pt));
2360 ::ScreenToClient(GetHwnd(),&(lvhti.pt));
2361 if ( ListView_HitTest(GetHwnd(),&lvhti) != -1 )
cb0f56f9 2362 {
225fe9d6
VZ
2363 if ( lvhti.flags & LVHT_ONITEM )
2364 {
2365 eventType = wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK;
2366 event.m_itemIndex = lvhti.iItem;
a1f79c1e
VZ
2367 event.m_pointDrag.x = lvhti.pt.x;
2368 event.m_pointDrag.y = lvhti.pt.y;
225fe9d6 2369 }
cb0f56f9 2370 }
11358d39 2371 break;
bdc72a22 2372
5b59df83 2373#ifdef NM_CUSTOMDRAW
80c54c3d 2374 case NM_CUSTOMDRAW:
11358d39 2375 *result = OnCustomDraw(lParam);
63166611 2376
e6b1317b 2377 return *result != CDRF_DODEFAULT;
6ecfe2ac 2378#endif // _WIN32_IE >= 0x300
0b5efdc7 2379
11358d39
VZ
2380 case LVN_ODCACHEHINT:
2381 {
2382 const NM_CACHEHINT *cacheHint = (NM_CACHEHINT *)lParam;
614391dc 2383
11358d39 2384 eventType = wxEVT_COMMAND_LIST_CACHE_HINT;
e623926d 2385
0ea0359b
VZ
2386 // we get some really stupid cache hints like ones for
2387 // items in range 0..0 for an empty control or, after
2388 // deleting an item, for items in invalid range -- filter
2389 // this garbage out
2390 if ( cacheHint->iFrom > cacheHint->iTo )
598ddd96 2391 return false;
0ea0359b
VZ
2392
2393 event.m_oldItemIndex = cacheHint->iFrom;
2394
2395 const long iMax = GetItemCount();
2396 event.m_itemIndex = cacheHint->iTo < iMax ? cacheHint->iTo
2397 : iMax - 1;
e623926d 2398 }
11358d39 2399 break;
614391dc 2400
206391cb 2401#ifdef HAVE_NMLVFINDITEM
f0755097
VZ
2402 case LVN_ODFINDITEM:
2403 // this message is only used with the virtual list control but
2404 // even there we don't want to always use it: in a control with
2405 // sufficiently big number of items (defined as > 1000 here),
2406 // accidentally pressing a key could result in hanging an
2407 // application waiting while it performs linear search
2408 if ( IsVirtual() && GetItemCount() <= 1000 )
2409 {
2410 NMLVFINDITEM* pFindInfo = (NMLVFINDITEM*)lParam;
2411
2412 // no match by default
2413 *result = -1;
2414
2415 // we only handle string-based searches here
2416 //
2417 // TODO: what about LVFI_PARTIAL, should we handle this?
2418 if ( !(pFindInfo->lvfi.flags & LVFI_STRING) )
2419 {
2420 return false;
2421 }
2422
2423 const wxChar * const searchstr = pFindInfo->lvfi.psz;
2424 const size_t len = wxStrlen(searchstr);
2425
2426 // this is the first item we should examine, search from it
2427 // wrapping if necessary
2428 const int startPos = pFindInfo->iStart;
2429 const int maxPos = GetItemCount();
2430 wxCHECK_MSG( startPos <= maxPos, false,
2431 _T("bad starting position in LVN_ODFINDITEM") );
2432
2433 int currentPos = startPos;
2434 do
2435 {
2436 // wrap to the beginning if necessary
2437 if ( currentPos == maxPos )
2438 {
2439 // somewhat surprizingly, LVFI_WRAP isn't set in
2440 // flags but we still should wrap
2441 currentPos = 0;
2442 }
2443
2444 // does this item begin with searchstr?
2445 if ( wxStrnicmp(searchstr,
2446 GetItemText(currentPos), len) == 0 )
2447 {
2448 *result = currentPos;
2449 break;
2450 }
2451 }
2452 while ( ++currentPos != startPos );
2453
2454 if ( *result == -1 )
2455 {
2456 // not found
2457 return false;
2458 }
2459
2460 SetItemState(*result,
2461 wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED,
2462 wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED);
2463 EnsureVisible(*result);
2464 return true;
2465 }
2466 else
2467 {
2468 processed = false;
2469 }
2470 break;
206391cb 2471#endif // HAVE_NMLVFINDITEM
f0755097 2472
11358d39
VZ
2473 case LVN_GETDISPINFO:
2474 if ( IsVirtual() )
2475 {
2476 LV_DISPINFO *info = (LV_DISPINFO *)lParam;
98ec9dbe 2477
11358d39
VZ
2478 LV_ITEM& lvi = info->item;
2479 long item = lvi.iItem;
98ec9dbe 2480
11358d39
VZ
2481 if ( lvi.mask & LVIF_TEXT )
2482 {
2483 wxString text = OnGetItemText(item, lvi.iSubItem);
64accea5 2484 wxStrlcpy(lvi.pszText, text.c_str(), lvi.cchTextMax);
11358d39 2485 }
98ec9dbe 2486
5b59df83
VZ
2487 // see comment at the end of wxListCtrl::GetColumn()
2488#ifdef NM_CUSTOMDRAW
11358d39
VZ
2489 if ( lvi.mask & LVIF_IMAGE )
2490 {
208458a7 2491 lvi.iImage = OnGetItemColumnImage(item, lvi.iSubItem);
11358d39 2492 }
5b59df83 2493#endif // NM_CUSTOMDRAW
98ec9dbe 2494
19def5e7
VZ
2495 // even though we never use LVM_SETCALLBACKMASK, we still
2496 // can get messages with LVIF_STATE in lvi.mask under Vista
2497 if ( lvi.mask & LVIF_STATE )
2498 {
2499 // we don't have anything to return from here...
2500 lvi.stateMask = 0;
2501 }
98ec9dbe 2502
598ddd96 2503 return true;
11358d39
VZ
2504 }
2505 // fall through
98ec9dbe 2506
11358d39 2507 default:
f0755097 2508 processed = false;
11358d39 2509 }
f0755097
VZ
2510
2511 if ( !processed )
2512 return wxControl::MSWOnNotify(idCtrl, lParam, result);
11358d39
VZ
2513 }
2514 else
2515 {
2516 // where did this one come from?
598ddd96 2517 return false;
acb62b84
VZ
2518 }
2519
bdc72a22
VZ
2520 // process the event
2521 // -----------------
2522
0b5efdc7 2523 event.SetEventType(eventType);
acb62b84 2524
937013e0 2525 bool processed = HandleWindowEvent(event);
acb62b84 2526
bdc72a22
VZ
2527 // post processing
2528 // ---------------
225fe9d6 2529 switch ( nmhdr->code )
acb62b84 2530 {
6932a32c 2531 case LVN_DELETEALLITEMS:
598ddd96 2532 // always return true to suppress all additional LVN_DELETEITEM
6932a32c
VZ
2533 // notifications - this makes deleting all items from a list ctrl
2534 // much faster
2535 *result = TRUE;
f7df21aa
VZ
2536
2537 // also, we may free all user data now (couldn't do it before as
2538 // the user should have access to it in OnDeleteAllItems() handler)
2539 FreeAllInternalData();
07763c99
VZ
2540
2541 // the control is empty now, synchronize the cached number of items
2542 // with the real one
2543 m_count = 0;
598ddd96 2544 return true;
6932a32c 2545
8c21905b
VS
2546 case LVN_ENDLABELEDITA:
2547 case LVN_ENDLABELEDITW:
3103e8a9 2548 // logic here is inverted compared to all the other messages
614391dc
VZ
2549 *result = event.IsAllowed();
2550
5cd4cb75
VZ
2551 // EDIT control will be deleted by the list control itself so
2552 // prevent us from deleting it as well
2553 DeleteEditControl();
2b5f62a0 2554
598ddd96 2555 return true;
acb62b84 2556 }
acb62b84 2557
68c124a1
RD
2558 if ( processed )
2559 *result = !event.IsAllowed();
fd3f686c 2560
68c124a1 2561 return processed;
2bda0e17
KB
2562}
2563
e6b1317b
VZ
2564// ----------------------------------------------------------------------------
2565// custom draw stuff
2566// ----------------------------------------------------------------------------
2567
5b59df83
VZ
2568// see comment at the end of wxListCtrl::GetColumn()
2569#ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
63166611 2570
e6b1317b
VZ
2571static RECT GetCustomDrawnItemRect(const NMCUSTOMDRAW& nmcd)
2572{
2573 RECT rc;
89cafab0 2574 wxGetListCtrlItemRect(nmcd.hdr.hwndFrom, nmcd.dwItemSpec, LVIR_BOUNDS, rc);
e6b1317b
VZ
2575
2576 RECT rcIcon;
89cafab0 2577 wxGetListCtrlItemRect(nmcd.hdr.hwndFrom, nmcd.dwItemSpec, LVIR_ICON, rcIcon);
e6b1317b
VZ
2578
2579 // exclude the icon part, neither the selection background nor focus rect
2580 // should cover it
2581 rc.left = rcIcon.right;
2582
2583 return rc;
2584}
2585
0c1602b8
VZ
2586static
2587bool HandleSubItemPrepaint(LPNMLVCUSTOMDRAW pLVCD, HFONT hfont, int colCount)
e6b1317b
VZ
2588{
2589 NMCUSTOMDRAW& nmcd = pLVCD->nmcd;
2590
2591 HDC hdc = nmcd.hdc;
2592 HWND hwndList = nmcd.hdr.hwndFrom;
223b7504 2593 const int col = pLVCD->iSubItem;
e6b1317b
VZ
2594 const DWORD item = nmcd.dwItemSpec;
2595
e6b1317b
VZ
2596 // the font must be valid, otherwise we wouldn't be painting the item at all
2597 SelectInHDC selFont(hdc, hfont);
2598
2599 // get the rectangle to paint
89cafab0 2600 int subitem = colCount ? col + 1 : col;
e6b1317b 2601 RECT rc;
89cafab0
VZ
2602 wxGetListCtrlSubItemRect(hwndList, item, subitem, LVIR_BOUNDS, rc);
2603 rc.left += 6;
e6b1317b
VZ
2604
2605 // get the image and text to draw
2606 wxChar text[512];
2607 LV_ITEM it;
2608 wxZeroMemory(it);
2609 it.mask = LVIF_TEXT | LVIF_IMAGE;
2610 it.iItem = item;
223b7504 2611 it.iSubItem = col;
e6b1317b
VZ
2612 it.pszText = text;
2613 it.cchTextMax = WXSIZEOF(text);
2614 ListView_GetItem(hwndList, &it);
2615
25e6a4a6
VZ
2616 HIMAGELIST himl = ListView_GetImageList(hwndList, LVSIL_SMALL);
2617 if ( himl && ImageList_GetImageCount(himl) )
e6b1317b 2618 {
25e6a4a6
VZ
2619 if ( it.iImage != -1 )
2620 {
2621 ImageList_Draw(himl, it.iImage, hdc, rc.left, rc.top,
2622 nmcd.uItemState & CDIS_SELECTED ? ILD_SELECTED
2623 : ILD_TRANSPARENT);
2624 }
e6b1317b 2625
25e6a4a6 2626 // notice that even if this item doesn't have any image, the list
23535447
VZ
2627 // control still leaves space for the image in the first column if the
2628 // image list is not empty (presumably so that items with and without
2629 // images align?)
2630 if ( it.iImage != -1 || it.iSubItem == 0 )
2631 {
2632 int wImage, hImage;
2633 ImageList_GetIconSize(himl, &wImage, &hImage);
e6b1317b 2634
23535447
VZ
2635 rc.left += wImage + 2;
2636 }
e6b1317b
VZ
2637 }
2638
2639 ::SetBkMode(hdc, TRANSPARENT);
2640
223b7504 2641 UINT fmt = DT_SINGLELINE |
5cce8340
VZ
2642#ifndef __WXWINCE__
2643 DT_WORD_ELLIPSIS |
2644#endif // __WXWINCE__
223b7504
VZ
2645 DT_NOPREFIX |
2646 DT_VCENTER;
2647
2648 LV_COLUMN lvCol;
2649 wxZeroMemory(lvCol);
2650 lvCol.mask = LVCF_FMT;
2651 if ( ListView_GetColumn(hwndList, col, &lvCol) )
2652 {
2653 switch ( lvCol.fmt & LVCFMT_JUSTIFYMASK )
2654 {
2655 case LVCFMT_LEFT:
2656 fmt |= DT_LEFT;
2657 break;
2658
2659 case LVCFMT_CENTER:
2660 fmt |= DT_CENTER;
2661 break;
2662
2663 case LVCFMT_RIGHT:
2664 fmt |= DT_RIGHT;
2665 break;
2666 }
2667 }
2668 //else: failed to get alignment, assume it's DT_LEFT (default)
2669
2670 DrawText(hdc, text, -1, &rc, fmt);
2671
2672 return true;
e6b1317b
VZ
2673}
2674
2675static void HandleItemPostpaint(NMCUSTOMDRAW nmcd)
2676{
2677 if ( nmcd.uItemState & CDIS_FOCUS )
2678 {
2679 RECT rc = GetCustomDrawnItemRect(nmcd);
2680
2681 // don't use the provided HDC, it's in some strange state by now
2682 ::DrawFocusRect(WindowHDC(nmcd.hdr.hwndFrom), &rc);
2683 }
2684}
2685
2686// pLVCD->clrText and clrTextBk should contain the colours to use
2687static void HandleItemPaint(LPNMLVCUSTOMDRAW pLVCD, HFONT hfont)
2688{
2689 NMCUSTOMDRAW& nmcd = pLVCD->nmcd; // just a shortcut
2690
13845bd5
VZ
2691 const HWND hwndList = nmcd.hdr.hwndFrom;
2692 const int item = nmcd.dwItemSpec;
e6b1317b
VZ
2693
2694 // unfortunately we can't trust CDIS_SELECTED, it is often set even when
2695 // the item is not at all selected for some reason (comctl32 6), but we
2696 // also can't always trust ListView_GetItem() as it could return the old
2697 // item status if we're called just after the (de)selection, so remember
2698 // the last item to gain selection and also check for it here
2699 for ( int i = -1;; )
2700 {
2701 i = ListView_GetNextItem(hwndList, i, LVNI_SELECTED);
2702 if ( i == -1 )
2703 {
2704 nmcd.uItemState &= ~CDIS_SELECTED;
2705 break;
2706 }
2707
13845bd5 2708 if ( i == item )
e6b1317b
VZ
2709 {
2710 nmcd.uItemState |= CDIS_SELECTED;
2711 break;
2712 }
2713 }
2714
13845bd5 2715 // same thing for CDIS_FOCUS (except simpler as there is only one of them)
728f972b 2716 if ( ::GetFocus() == hwndList &&
77cfdec0 2717 ListView_GetNextItem(hwndList, -1, LVNI_FOCUSED) == item )
13845bd5
VZ
2718 {
2719 nmcd.uItemState |= CDIS_FOCUS;
2720 }
2721 else
2722 {
2723 nmcd.uItemState &= ~CDIS_FOCUS;
2724 }
2725
e6b1317b
VZ
2726 if ( nmcd.uItemState & CDIS_SELECTED )
2727 {
2728 int syscolFg, syscolBg;
2729 if ( ::GetFocus() == hwndList )
2730 {
2731 syscolFg = COLOR_HIGHLIGHTTEXT;
2732 syscolBg = COLOR_HIGHLIGHT;
2733 }
2734 else // selected but unfocused
2735 {
2736 syscolFg = COLOR_WINDOWTEXT;
2737 syscolBg = COLOR_BTNFACE;
2738
2739 // don't grey out the icon in this case neither
2740 nmcd.uItemState &= ~CDIS_SELECTED;
2741 }
2742
2743 pLVCD->clrText = ::GetSysColor(syscolFg);
2744 pLVCD->clrTextBk = ::GetSysColor(syscolBg);
2745 }
2746 //else: not selected, use normal colours from pLVCD
2747
2748 HDC hdc = nmcd.hdc;
2749 RECT rc = GetCustomDrawnItemRect(nmcd);
2750
2751 ::SetTextColor(hdc, pLVCD->clrText);
2752 ::FillRect(hdc, &rc, AutoHBRUSH(pLVCD->clrTextBk));
2753
2754 // we could use CDRF_NOTIFYSUBITEMDRAW here but it results in weird repaint
2755 // problems so just draw everything except the focus rect from here instead
2756 const int colCount = Header_GetItemCount(ListView_GetHeader(hwndList));
2757 for ( int col = 0; col < colCount; col++ )
2758 {
2759 pLVCD->iSubItem = col;
0c1602b8 2760 HandleSubItemPrepaint(pLVCD, hfont, colCount);
e6b1317b
VZ
2761 }
2762
2763 HandleItemPostpaint(nmcd);
2764}
2765
2766static WXLPARAM HandleItemPrepaint(wxListCtrl *listctrl,
2767 LPNMLVCUSTOMDRAW pLVCD,
2768 wxListItemAttr *attr)
2769{
2770 if ( !attr )
2771 {
2772 // nothing to do for this item
2773 return CDRF_DODEFAULT;
2774 }
2775
2776
2777 // set the colours to use for text drawing
3568f700
WS
2778 pLVCD->clrText = attr->HasTextColour()
2779 ? wxColourToRGB(attr->GetTextColour())
2780 : wxColourToRGB(listctrl->GetTextColour());
2781 pLVCD->clrTextBk = attr->HasBackgroundColour()
2782 ? wxColourToRGB(attr->GetBackgroundColour())
2783 : wxColourToRGB(listctrl->GetBackgroundColour());
e6b1317b
VZ
2784
2785 // select the font if non default one is specified
2786 if ( attr->HasFont() )
2787 {
2788 wxFont font = attr->GetFont();
2789 if ( font.GetEncoding() != wxFONTENCODING_SYSTEM )
2790 {
2791 // the standard control ignores the font encoding/charset, at least
2792 // with recent comctl32.dll versions (5 and 6, it uses to work with
2793 // 4.something) so we have to draw the item entirely ourselves in
2794 // this case
2795 HandleItemPaint(pLVCD, GetHfontOf(font));
2796 return CDRF_SKIPDEFAULT;
2797 }
2798
2799 ::SelectObject(pLVCD->nmcd.hdc, GetHfontOf(font));
2800
2801 return CDRF_NEWFONT;
2802 }
2803
2804 return CDRF_DODEFAULT;
2805}
2806
63166611
VZ
2807WXLPARAM wxListCtrl::OnCustomDraw(WXLPARAM lParam)
2808{
e6b1317b
VZ
2809 LPNMLVCUSTOMDRAW pLVCD = (LPNMLVCUSTOMDRAW)lParam;
2810 NMCUSTOMDRAW& nmcd = pLVCD->nmcd;
63166611
VZ
2811 switch ( nmcd.dwDrawStage )
2812 {
2813 case CDDS_PREPAINT:
2814 // if we've got any items with non standard attributes,
2815 // notify us before painting each item
2816 //
2817 // for virtual controls, always suppose that we have attributes as
2818 // there is no way to check for this
e6b1317b
VZ
2819 if ( IsVirtual() || m_hasAnyAttr )
2820 return CDRF_NOTIFYITEMDRAW;
2821 break;
63166611
VZ
2822
2823 case CDDS_ITEMPREPAINT:
eab1336c
VZ
2824 // get a message for each subitem
2825 return CDRF_NOTIFYITEMDRAW;
2826
2827 case CDDS_SUBITEM | CDDS_ITEMPREPAINT:
e6b1317b 2828 const int item = nmcd.dwItemSpec;
eab1336c 2829 const int column = pLVCD->iSubItem;
63166611 2830
e6b1317b
VZ
2831 // we get this message with item == 0 for an empty control, we
2832 // must ignore it as calling OnGetItemAttr() would be wrong
2833 if ( item < 0 || item >= GetItemCount() )
2834 break;
eab1336c
VZ
2835 // same for columns
2836 if ( column < 0 || column >= GetColumnCount() )
2837 break;
63166611 2838
eab1336c 2839 return HandleItemPrepaint(this, pLVCD, DoGetItemColumnAttr(item, column));
63166611 2840 }
e6b1317b
VZ
2841
2842 return CDRF_DODEFAULT;
63166611
VZ
2843}
2844
2845#endif // NM_CUSTOMDRAW supported
2846
2702ed5a
JS
2847// Necessary for drawing hrules and vrules, if specified
2848void wxListCtrl::OnPaint(wxPaintEvent& event)
2849{
99366b91 2850 const int itemCount = GetItemCount();
d3acc83a
VZ
2851 const bool drawHRules = HasFlag(wxLC_HRULES);
2852 const bool drawVRules = HasFlag(wxLC_VRULES);
2e6a9dad 2853
99366b91 2854 if (!InReportView() || !(drawHRules || drawVRules) || !itemCount)
2e6a9dad
VS
2855 {
2856 event.Skip();
2857 return;
2858 }
2859
2702ed5a
JS
2860 wxPaintDC dc(this);
2861
2862 wxControl::OnPaint(event);
2863
2864 // Reset the device origin since it may have been set
2865 dc.SetDeviceOrigin(0, 0);
2866
36c10aa1 2867 wxPen pen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT));
2702ed5a
JS
2868 dc.SetPen(pen);
2869 dc.SetBrush(* wxTRANSPARENT_BRUSH);
2870
2871 wxSize clientSize = GetClientSize();
2872 wxRect itemRect;
2702ed5a 2873
625cb8c0 2874 if (drawHRules)
2702ed5a 2875 {
99366b91
VZ
2876 const long top = GetTopItem();
2877 for ( int i = top; i < top + GetCountPerPage() + 1; i++ )
2702ed5a 2878 {
625cb8c0 2879 if (GetItemRect(i, itemRect))
ca286917 2880 {
5cb598ae 2881 int cy = itemRect.GetTop();
625cb8c0
RD
2882 if (i != 0) // Don't draw the first one
2883 {
2884 dc.DrawLine(0, cy, clientSize.x, cy);
2885 }
2886 // Draw last line
2cefcb34 2887 if (i == itemCount - 1)
625cb8c0
RD
2888 {
2889 cy = itemRect.GetBottom();
2890 dc.DrawLine(0, cy, clientSize.x, cy);
99366b91 2891 break;
625cb8c0 2892 }
2702ed5a
JS
2893 }
2894 }
2895 }
99366b91
VZ
2896
2897 if (drawVRules)
2702ed5a
JS
2898 {
2899 wxRect firstItemRect;
2900 GetItemRect(0, firstItemRect);
2901
99366b91 2902 if (GetItemRect(itemCount - 1, itemRect))
2702ed5a 2903 {
9eaba692
VZ
2904 // this is a fix for bug 673394: erase the pixels which we would
2905 // otherwise leave on the screen
2906 static const int gap = 2;
2907 dc.SetPen(*wxTRANSPARENT_PEN);
2908 dc.SetBrush(wxBrush(GetBackgroundColour()));
2909 dc.DrawRectangle(0, firstItemRect.GetY() - gap,
2910 clientSize.GetWidth(), gap);
2911
2912 dc.SetPen(pen);
2913 dc.SetBrush(*wxTRANSPARENT_BRUSH);
67d3fc49 2914
ceef3893
VZ
2915 const int numCols = GetColumnCount();
2916 wxVector<int> indexArray(numCols);
2917 if ( !ListView_GetColumnOrderArray(GetHwnd(),
2918 numCols,
2919 &indexArray[0]) )
7a8dce71
VZ
2920 {
2921 wxFAIL_MSG( _T("invalid column index array in OnPaint()") );
ceef3893 2922 return;
7a8dce71 2923 }
67d3fc49 2924
2702ed5a 2925 int x = itemRect.GetX();
67d3fc49 2926 for (int col = 0; col < numCols; col++)
2702ed5a 2927 {
67d3fc49 2928 int colWidth = GetColumnWidth(indexArray[col]);
2702ed5a 2929 x += colWidth ;
9eaba692
VZ
2930 dc.DrawLine(x-1, firstItemRect.GetY() - gap,
2931 x-1, itemRect.GetBottom());
2702ed5a
JS
2932 }
2933 }
2934 }
2935}
2936
4bd6ae0f
VZ
2937WXLRESULT
2938wxListCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
2939{
777f37e0 2940 switch ( nMsg )
4bd6ae0f 2941 {
777f37e0
VZ
2942#ifdef WM_PRINT
2943 case WM_PRINT:
2944 // we should bypass our own WM_PRINT handling as we don't handle
2945 // PRF_CHILDREN flag, so leave it to the native control itself
2946 return MSWDefWindowProc(nMsg, wParam, lParam);
4bd6ae0f
VZ
2947#endif // WM_PRINT
2948
777f37e0
VZ
2949 case WM_CONTEXTMENU:
2950 // because this message is propagated upwards the child-parent
2951 // chain, we get it for the right clicks on the header window but
2952 // this is confusing in wx as right clicking there already
2953 // generates a separate wxEVT_COMMAND_LIST_COL_RIGHT_CLICK event
2954 // so just ignore them
2955 if ( (HWND)wParam == ListView_GetHeader(GetHwnd()) )
2956 return 0;
2957 //else: break
2958 }
2959
4bd6ae0f
VZ
2960 return wxControl::MSWWindowProc(nMsg, wParam, lParam);
2961}
2962
98ec9dbe
VZ
2963// ----------------------------------------------------------------------------
2964// virtual list controls
2965// ----------------------------------------------------------------------------
2966
d699f48b 2967wxString wxListCtrl::OnGetItemText(long WXUNUSED(item), long WXUNUSED(col)) const
98ec9dbe
VZ
2968{
2969 // this is a pure virtual function, in fact - which is not really pure
2970 // because the controls which are not virtual don't need to implement it
271d1110 2971 wxFAIL_MSG( _T("wxListCtrl::OnGetItemText not supposed to be called") );
98ec9dbe
VZ
2972
2973 return wxEmptyString;
2974}
2975
d699f48b 2976int wxListCtrl::OnGetItemImage(long WXUNUSED(item)) const
98ec9dbe 2977{
611a725e
RD
2978 wxCHECK_MSG(!GetImageList(wxIMAGE_LIST_SMALL),
2979 -1,
208458a7
RD
2980 wxT("List control has an image list, OnGetItemImage or OnGetItemColumnImage should be overridden."));
2981 return -1;
2982}
2983
2984int wxListCtrl::OnGetItemColumnImage(long item, long column) const
2985{
2986 if (!column)
2987 return OnGetItemImage(item);
2988
98ec9dbe
VZ
2989 return -1;
2990}
2991
d699f48b 2992wxListItemAttr *wxListCtrl::OnGetItemAttr(long WXUNUSED_UNLESS_DEBUG(item)) const
6c02c329 2993{
63166611 2994 wxASSERT_MSG( item >= 0 && item < GetItemCount(),
6c02c329
VZ
2995 _T("invalid item index in OnGetItemAttr()") );
2996
2997 // no attributes by default
2998 return NULL;
2999}
3000
eab1336c 3001wxListItemAttr *wxListCtrl::DoGetItemColumnAttr(long item, long column) const
e6b1317b 3002{
eab1336c 3003 return IsVirtual() ? OnGetItemColumnAttr(item, column)
e6b1317b
VZ
3004 : wxGetInternalDataAttr(this, item);
3005}
3006
98ec9dbe
VZ
3007void wxListCtrl::SetItemCount(long count)
3008{
3009 wxASSERT_MSG( IsVirtual(), _T("this is for virtual controls only") );
3010
54759554
VZ
3011 if ( !::SendMessage(GetHwnd(), LVM_SETITEMCOUNT, (WPARAM)count,
3012 LVSICF_NOSCROLL | LVSICF_NOINVALIDATEALL) )
98ec9dbe
VZ
3013 {
3014 wxLogLastError(_T("ListView_SetItemCount"));
3015 }
68c124a1
RD
3016 m_count = count;
3017 wxASSERT_MSG( m_count == ListView_GetItemCount(GetHwnd()),
3018 wxT("m_count should match ListView_GetItemCount"));
98ec9dbe
VZ
3019}
3020
a7f560a2
VZ
3021void wxListCtrl::RefreshItem(long item)
3022{
ebc9b89d 3023 RefreshItems(item, item);
a7f560a2
VZ
3024}
3025
3026void wxListCtrl::RefreshItems(long itemFrom, long itemTo)
3027{
ebc9b89d 3028 ListView_RedrawItems(GetHwnd(), itemFrom, itemTo);
a7f560a2
VZ
3029}
3030
97c611f8
VZ
3031// ----------------------------------------------------------------------------
3032// internal data stuff
3033// ----------------------------------------------------------------------------
3034
6149de71 3035static wxListItemInternalData *wxGetInternalData(HWND hwnd, long itemId)
7cf46fdb
VZ
3036{
3037 LV_ITEM it;
3038 it.mask = LVIF_PARAM;
3039 it.iItem = itemId;
3040
97c611f8 3041 if ( !ListView_GetItem(hwnd, &it) )
7cf46fdb 3042 return NULL;
97c611f8
VZ
3043
3044 return (wxListItemInternalData *) it.lParam;
259c43f6 3045}
7cf46fdb 3046
97c611f8
VZ
3047static
3048wxListItemInternalData *wxGetInternalData(const wxListCtrl *ctl, long itemId)
7cf46fdb 3049{
97c611f8 3050 return wxGetInternalData(GetHwndOf(ctl), itemId);
259c43f6 3051}
7cf46fdb 3052
e6b1317b
VZ
3053static
3054wxListItemAttr *wxGetInternalDataAttr(const wxListCtrl *ctl, long itemId)
7cf46fdb 3055{
6149de71 3056 wxListItemInternalData *data = wxGetInternalData(ctl, itemId);
97c611f8
VZ
3057
3058 return data ? data->attr : NULL;
259c43f6 3059}
7cf46fdb 3060
6149de71
RD
3061static void wxDeleteInternalData(wxListCtrl* ctl, long itemId)
3062{
3063 wxListItemInternalData *data = wxGetInternalData(ctl, itemId);
3064 if (data)
3065 {
6149de71
RD
3066 LV_ITEM item;
3067 memset(&item, 0, sizeof(item));
3068 item.iItem = itemId;
3069 item.mask = LVIF_PARAM;
3070 item.lParam = (LPARAM) 0;
3071 ListView_SetItem((HWND)ctl->GetHWND(), &item);
cd01e364 3072 delete data;
6149de71
RD
3073 }
3074}
7cf46fdb 3075
97c611f8
VZ
3076// ----------------------------------------------------------------------------
3077// wxWin <-> MSW items conversions
3078// ----------------------------------------------------------------------------
3079
8dff2b5c
VZ
3080static void wxConvertFromMSWListItem(HWND hwndListCtrl,
3081 wxListItem& info,
3082 LV_ITEM& lvItem)
2bda0e17 3083{
73d8c5fd 3084 wxListItemInternalData *internaldata =
7cf46fdb
VZ
3085 (wxListItemInternalData *) lvItem.lParam;
3086
3087 if (internaldata)
3088 info.m_data = internaldata->lParam;
3089
0b5efdc7
VZ
3090 info.m_mask = 0;
3091 info.m_state = 0;
3092 info.m_stateMask = 0;
3093 info.m_itemId = lvItem.iItem;
acb62b84 3094
0b5efdc7 3095 long oldMask = lvItem.mask;
acb62b84 3096
598ddd96 3097 bool needText = false;
8dff2b5c 3098 if (hwndListCtrl != 0)
acb62b84 3099 {
0b5efdc7 3100 if ( lvItem.mask & LVIF_TEXT )
598ddd96 3101 needText = false;
0b5efdc7 3102 else
598ddd96 3103 needText = true;
acb62b84 3104
0b5efdc7
VZ
3105 if ( needText )
3106 {
837e5743 3107 lvItem.pszText = new wxChar[513];
0b5efdc7
VZ
3108 lvItem.cchTextMax = 512;
3109 }
edccf428 3110 lvItem.mask |= LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
8dff2b5c 3111 ::SendMessage(hwndListCtrl, LVM_GETITEM, 0, (LPARAM)& lvItem);
0b5efdc7 3112 }
acb62b84 3113
0b5efdc7 3114 if ( lvItem.mask & LVIF_STATE )
acb62b84 3115 {
0b5efdc7
VZ
3116 info.m_mask |= wxLIST_MASK_STATE;
3117
3118 if ( lvItem.stateMask & LVIS_CUT)
3119 {
edccf428 3120 info.m_stateMask |= wxLIST_STATE_CUT;
0b5efdc7 3121 if ( lvItem.state & LVIS_CUT )
edccf428 3122 info.m_state |= wxLIST_STATE_CUT;
0b5efdc7
VZ
3123 }
3124 if ( lvItem.stateMask & LVIS_DROPHILITED)
3125 {
edccf428 3126 info.m_stateMask |= wxLIST_STATE_DROPHILITED;
0b5efdc7 3127 if ( lvItem.state & LVIS_DROPHILITED )
edccf428 3128 info.m_state |= wxLIST_STATE_DROPHILITED;
0b5efdc7
VZ
3129 }
3130 if ( lvItem.stateMask & LVIS_FOCUSED)
3131 {
edccf428 3132 info.m_stateMask |= wxLIST_STATE_FOCUSED;
0b5efdc7 3133 if ( lvItem.state & LVIS_FOCUSED )
edccf428 3134 info.m_state |= wxLIST_STATE_FOCUSED;
0b5efdc7
VZ
3135 }
3136 if ( lvItem.stateMask & LVIS_SELECTED)
3137 {
edccf428 3138 info.m_stateMask |= wxLIST_STATE_SELECTED;
0b5efdc7 3139 if ( lvItem.state & LVIS_SELECTED )
edccf428 3140 info.m_state |= wxLIST_STATE_SELECTED;
0b5efdc7 3141 }
acb62b84 3142 }
0b5efdc7
VZ
3143
3144 if ( lvItem.mask & LVIF_TEXT )
acb62b84 3145 {
0b5efdc7
VZ
3146 info.m_mask |= wxLIST_MASK_TEXT;
3147 info.m_text = lvItem.pszText;
acb62b84 3148 }
0b5efdc7 3149 if ( lvItem.mask & LVIF_IMAGE )
acb62b84 3150 {
0b5efdc7
VZ
3151 info.m_mask |= wxLIST_MASK_IMAGE;
3152 info.m_image = lvItem.iImage;
acb62b84 3153 }
0b5efdc7
VZ
3154 if ( lvItem.mask & LVIF_PARAM )
3155 info.m_mask |= wxLIST_MASK_DATA;
3156 if ( lvItem.mask & LVIF_DI_SETITEM )
3157 info.m_mask |= wxLIST_SET_ITEM;
3158 info.m_col = lvItem.iSubItem;
3159
3160 if (needText)
acb62b84 3161 {
0b5efdc7
VZ
3162 if (lvItem.pszText)
3163 delete[] lvItem.pszText;
acb62b84 3164 }
edccf428 3165 lvItem.mask = oldMask;
2bda0e17
KB
3166}
3167
8dff2b5c
VZ
3168static void wxConvertToMSWFlags(long state, long stateMask, LV_ITEM& lvItem)
3169{
3170 if (stateMask & wxLIST_STATE_CUT)
3171 {
3172 lvItem.stateMask |= LVIS_CUT;
3173 if (state & wxLIST_STATE_CUT)
3174 lvItem.state |= LVIS_CUT;
3175 }
3176 if (stateMask & wxLIST_STATE_DROPHILITED)
3177 {
3178 lvItem.stateMask |= LVIS_DROPHILITED;
3179 if (state & wxLIST_STATE_DROPHILITED)
3180 lvItem.state |= LVIS_DROPHILITED;
3181 }
3182 if (stateMask & wxLIST_STATE_FOCUSED)
3183 {
3184 lvItem.stateMask |= LVIS_FOCUSED;
3185 if (state & wxLIST_STATE_FOCUSED)
3186 lvItem.state |= LVIS_FOCUSED;
3187 }
3188 if (stateMask & wxLIST_STATE_SELECTED)
3189 {
3190 lvItem.stateMask |= LVIS_SELECTED;
3191 if (state & wxLIST_STATE_SELECTED)
3192 lvItem.state |= LVIS_SELECTED;
3193 }
3194}
3195
3196static void wxConvertToMSWListItem(const wxListCtrl *ctrl,
3197 const wxListItem& info,
3198 LV_ITEM& lvItem)
2bda0e17 3199{
edccf428 3200 lvItem.iItem = (int) info.m_itemId;
acb62b84 3201
edccf428 3202 lvItem.iImage = info.m_image;
0b5efdc7
VZ
3203 lvItem.stateMask = 0;
3204 lvItem.state = 0;
3205 lvItem.mask = 0;
3206 lvItem.iSubItem = info.m_col;
acb62b84 3207
0b5efdc7 3208 if (info.m_mask & wxLIST_MASK_STATE)
acb62b84 3209 {
edccf428 3210 lvItem.mask |= LVIF_STATE;
8dff2b5c
VZ
3211
3212 wxConvertToMSWFlags(info.m_state, info.m_stateMask, lvItem);
acb62b84 3213 }
acb62b84 3214
0b5efdc7 3215 if (info.m_mask & wxLIST_MASK_TEXT)
acb62b84 3216 {
edccf428 3217 lvItem.mask |= LVIF_TEXT;
b5d43d1d 3218 if ( ctrl->HasFlag(wxLC_USER_TEXT) )
0b5efdc7
VZ
3219 {
3220 lvItem.pszText = LPSTR_TEXTCALLBACK;
3221 }
3222 else
3223 {
e421922f 3224 // pszText is not const, hence the cast
c9f78968 3225 lvItem.pszText = (wxChar *)info.m_text.wx_str();
0b5efdc7 3226 if ( lvItem.pszText )
8ecd5de2 3227 lvItem.cchTextMax = info.m_text.length();
0b5efdc7
VZ
3228 else
3229 lvItem.cchTextMax = 0;
3230 }
acb62b84 3231 }
0b5efdc7 3232 if (info.m_mask & wxLIST_MASK_IMAGE)
edccf428 3233 lvItem.mask |= LVIF_IMAGE;
2bda0e17
KB
3234}
3235
e64658ed
VZ
3236static void wxConvertToMSWListCol(HWND hwndList,
3237 int col,
3238 const wxListItem& item,
6f806543
VZ
3239 LV_COLUMN& lvCol)
3240{
3241 wxZeroMemory(lvCol);
3242
3243 if ( item.m_mask & wxLIST_MASK_TEXT )
3244 {
3245 lvCol.mask |= LVCF_TEXT;
c9f78968 3246 lvCol.pszText = (wxChar *)item.m_text.wx_str(); // cast is safe
6f806543
VZ
3247 }
3248
3249 if ( item.m_mask & wxLIST_MASK_FORMAT )
3250 {
3251 lvCol.mask |= LVCF_FMT;
3252
3253 if ( item.m_format == wxLIST_FORMAT_LEFT )
3254 lvCol.fmt = LVCFMT_LEFT;
3255 else if ( item.m_format == wxLIST_FORMAT_RIGHT )
3256 lvCol.fmt = LVCFMT_RIGHT;
3257 else if ( item.m_format == wxLIST_FORMAT_CENTRE )
3258 lvCol.fmt = LVCFMT_CENTER;
3259 }
3260
3261 if ( item.m_mask & wxLIST_MASK_WIDTH )
3262 {
3263 lvCol.mask |= LVCF_WIDTH;
3264 if ( item.m_width == wxLIST_AUTOSIZE)
3265 lvCol.cx = LVSCW_AUTOSIZE;
3266 else if ( item.m_width == wxLIST_AUTOSIZE_USEHEADER)
3267 lvCol.cx = LVSCW_AUTOSIZE_USEHEADER;
3268 else
3269 lvCol.cx = item.m_width;
3270 }
3271
5b59df83
VZ
3272 // see comment at the end of wxListCtrl::GetColumn()
3273#ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
6f806543
VZ
3274 if ( item.m_mask & wxLIST_MASK_IMAGE )
3275 {
5625d0d4 3276 if ( wxApp::GetComCtl32Version() >= 470 )
6f806543 3277 {
e64658ed 3278 lvCol.mask |= LVCF_IMAGE;
8b3a4016 3279
e64658ed 3280 // we use LVCFMT_BITMAP_ON_RIGHT because the images on the right
8b3a4016
VZ
3281 // seem to be generally nicer than on the left and the generic
3282 // version only draws them on the right (we don't have a flag to
3283 // specify the image location anyhow)
3284 //
3285 // we don't use LVCFMT_COL_HAS_IMAGES because it doesn't seem to
3286 // make any difference in my tests -- but maybe we should?
73bb5654 3287 if ( item.m_image != -1 )
e64658ed
VZ
3288 {
3289 // as we're going to overwrite the format field, get its
3290 // current value first -- unless we want to overwrite it anyhow
3291 if ( !(lvCol.mask & LVCF_FMT) )
3292 {
3293 LV_COLUMN lvColOld;
3294 wxZeroMemory(lvColOld);
3295 lvColOld.mask = LVCF_FMT;
3296 if ( ListView_GetColumn(hwndList, col, &lvColOld) )
3297 {
3298 lvCol.fmt = lvColOld.fmt;
3299 }
3300
3301 lvCol.mask |= LVCF_FMT;
3302 }
3303
73bb5654 3304 lvCol.fmt |= LVCFMT_BITMAP_ON_RIGHT | LVCFMT_IMAGE;
e64658ed 3305 }
8b3a4016 3306
6f806543
VZ
3307 lvCol.iImage = item.m_image;
3308 }
3309 //else: it doesn't support item images anyhow
3310 }
5b59df83 3311#endif // _WIN32_IE >= 0x0300
6f806543
VZ
3312}
3313
1e6feb95 3314#endif // wxUSE_LISTCTRL