1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/msw/listctrl.cpp
4 // Author: Julian Smart
5 // Modified by: Agron Selimaj
8 // Copyright: (c) Julian Smart
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
12 // ============================================================================
14 // ============================================================================
16 // ----------------------------------------------------------------------------
18 // ----------------------------------------------------------------------------
20 // For compilers that support precompilation, includes "wx.h".
21 #include "wx/wxprec.h"
29 #include "wx/listctrl.h"
32 #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
36 #include "wx/settings.h"
37 #include "wx/dcclient.h"
38 #include "wx/textctrl.h"
41 #include "wx/imaglist.h"
42 #include "wx/vector.h"
44 #include "wx/msw/private.h"
46 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__)
54 // Currently gcc and watcom don't define NMLVFINDITEM, and DMC only defines
55 // it by its old name NM_FINDTIEM.
57 #if defined(__VISUALC__) || defined(__BORLANDC__) || defined(NMLVFINDITEM)
58 #define HAVE_NMLVFINDITEM 1
59 #elif defined(__DMC__) || defined(NM_FINDITEM)
60 #define HAVE_NMLVFINDITEM 1
61 #define NMLVFINDITEM NM_FINDITEM
64 // ----------------------------------------------------------------------------
66 // ----------------------------------------------------------------------------
68 // convert our state and mask flags to LV_ITEM constants
69 static void wxConvertToMSWFlags(long state
, long mask
, LV_ITEM
& lvItem
);
71 // convert wxListItem to LV_ITEM
72 static void wxConvertToMSWListItem(const wxListCtrl
*ctrl
,
73 const wxListItem
& info
, LV_ITEM
& lvItem
);
75 // convert LV_ITEM to wxListItem
76 static void wxConvertFromMSWListItem(HWND hwndListCtrl
,
78 /* const */ LV_ITEM
& lvItem
);
80 // convert our wxListItem to LV_COLUMN
81 static void wxConvertToMSWListCol(HWND hwndList
,
83 const wxListItem
& item
,
89 // replacement for ListView_GetSubItemRect() which provokes warnings like
90 // "the address of 'rc' will always evaluate as 'true'" when used with mingw32
93 // this function does no error checking on item and subitem parameters, notice
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
98 wxGetListCtrlSubItemRect(HWND hwnd
, int item
, int subitem
, int flags
, RECT
& rect
)
102 return ::SendMessage(hwnd
, LVM_GETSUBITEMRECT
, item
, (LPARAM
)&rect
) != 0;
106 wxGetListCtrlItemRect(HWND hwnd
, int item
, int flags
, RECT
& rect
)
108 return wxGetListCtrlSubItemRect(hwnd
, item
, 0, flags
, rect
);
111 } // anonymous namespace
113 // ----------------------------------------------------------------------------
114 // private helper classes
115 // ----------------------------------------------------------------------------
117 // We have to handle both fooW and fooA notifications in several cases
118 // because of broken comctl32.dll and/or unicows.dll. This class is used to
119 // convert LV_ITEMA and LV_ITEMW to LV_ITEM (which is either LV_ITEMA or
120 // LV_ITEMW depending on wxUSE_UNICODE setting), so that it can be processed
121 // by wxConvertToMSWListItem().
123 #define LV_ITEM_NATIVE LV_ITEMW
124 #define LV_ITEM_OTHER LV_ITEMA
126 #define LV_CONV_TO_WX cMB2WX
127 #define LV_CONV_BUF wxMB2WXbuf
129 #define LV_ITEM_NATIVE LV_ITEMA
130 #define LV_ITEM_OTHER LV_ITEMW
132 #define LV_CONV_TO_WX cWC2WX
133 #define LV_CONV_BUF wxWC2WXbuf
134 #endif // Unicode/ANSI
139 // default ctor, use Init() later
140 wxLV_ITEM() { m_buf
= NULL
; m_pItem
= NULL
; }
142 // init without conversion
143 void Init(LV_ITEM_NATIVE
& item
)
145 wxASSERT_MSG( !m_pItem
, wxT("Init() called twice?") );
150 // init with conversion
151 void Init(const LV_ITEM_OTHER
& item
)
153 // avoid unnecessary dynamic memory allocation, jjust make m_pItem
154 // point to our own m_item
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
);
160 memcpy(&m_item
, &item
, sizeof(LV_ITEM_NATIVE
));
162 // convert text from ANSI to Unicod if necessary
163 if ( (item
.mask
& LVIF_TEXT
) && item
.pszText
)
165 m_buf
= new LV_CONV_BUF(wxConvLocal
.LV_CONV_TO_WX(item
.pszText
));
166 m_item
.pszText
= (wxChar
*)m_buf
->data();
170 // ctor without conversion
171 wxLV_ITEM(LV_ITEM_NATIVE
& item
) : m_buf(NULL
), m_pItem(&item
) { }
173 // ctor with conversion
174 wxLV_ITEM(LV_ITEM_OTHER
& item
) : m_buf(NULL
)
179 ~wxLV_ITEM() { delete m_buf
; }
181 // conversion to the real LV_ITEM
182 operator LV_ITEM_NATIVE
&() const { return *m_pItem
; }
187 LV_ITEM_NATIVE
*m_pItem
;
188 LV_ITEM_NATIVE m_item
;
190 wxDECLARE_NO_COPY_CLASS(wxLV_ITEM
);
193 ///////////////////////////////////////////////////////
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 text attributes (colour etc) for
199 // the following items were out of sync.
202 // Under MSW the only way to associate data with a List
203 // item independent of its position in the list is to
204 // store a pointer to it in its lParam attribute. However
205 // user programs are already using this (via the
206 // SetItemData() GetItemData() calls).
208 // However what we can do is store a pointer to a
209 // structure which contains the attributes we want *and*
210 // a lParam -- and this is what wxMSWListItemData does.
212 // To conserve memory, a wxMSWListItemData is
213 // only allocated for a LV_ITEM if text attributes or
214 // user data(lparam) are being set.
215 class wxMSWListItemData
218 wxMSWListItemData() : attr(NULL
), lParam(0) {}
219 ~wxMSWListItemData() { delete attr
; }
221 wxListItemAttr
*attr
;
222 LPARAM lParam
; // real user data
224 wxDECLARE_NO_COPY_CLASS(wxMSWListItemData
);
227 #if wxUSE_EXTENDED_RTTI
228 WX_DEFINE_FLAGS( wxListCtrlStyle
)
230 wxBEGIN_FLAGS( wxListCtrlStyle
)
231 // new style border flags, we put them first to
232 // use them for streaming out
233 wxFLAGS_MEMBER(wxBORDER_SIMPLE
)
234 wxFLAGS_MEMBER(wxBORDER_SUNKEN
)
235 wxFLAGS_MEMBER(wxBORDER_DOUBLE
)
236 wxFLAGS_MEMBER(wxBORDER_RAISED
)
237 wxFLAGS_MEMBER(wxBORDER_STATIC
)
238 wxFLAGS_MEMBER(wxBORDER_NONE
)
240 // old style border flags
241 wxFLAGS_MEMBER(wxSIMPLE_BORDER
)
242 wxFLAGS_MEMBER(wxSUNKEN_BORDER
)
243 wxFLAGS_MEMBER(wxDOUBLE_BORDER
)
244 wxFLAGS_MEMBER(wxRAISED_BORDER
)
245 wxFLAGS_MEMBER(wxSTATIC_BORDER
)
246 wxFLAGS_MEMBER(wxBORDER
)
248 // standard window styles
249 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
250 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
251 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
252 wxFLAGS_MEMBER(wxWANTS_CHARS
)
253 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
254 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
255 wxFLAGS_MEMBER(wxVSCROLL
)
256 wxFLAGS_MEMBER(wxHSCROLL
)
258 wxFLAGS_MEMBER(wxLC_LIST
)
259 wxFLAGS_MEMBER(wxLC_REPORT
)
260 wxFLAGS_MEMBER(wxLC_ICON
)
261 wxFLAGS_MEMBER(wxLC_SMALL_ICON
)
262 wxFLAGS_MEMBER(wxLC_ALIGN_TOP
)
263 wxFLAGS_MEMBER(wxLC_ALIGN_LEFT
)
264 wxFLAGS_MEMBER(wxLC_AUTOARRANGE
)
265 wxFLAGS_MEMBER(wxLC_USER_TEXT
)
266 wxFLAGS_MEMBER(wxLC_EDIT_LABELS
)
267 wxFLAGS_MEMBER(wxLC_NO_HEADER
)
268 wxFLAGS_MEMBER(wxLC_SINGLE_SEL
)
269 wxFLAGS_MEMBER(wxLC_SORT_ASCENDING
)
270 wxFLAGS_MEMBER(wxLC_SORT_DESCENDING
)
271 wxFLAGS_MEMBER(wxLC_VIRTUAL
)
273 wxEND_FLAGS( wxListCtrlStyle
)
275 IMPLEMENT_DYNAMIC_CLASS_XTI(wxListCtrl
, wxControl
,"wx/listctrl.h")
277 wxBEGIN_PROPERTIES_TABLE(wxListCtrl
)
278 wxEVENT_PROPERTY( TextUpdated
, wxEVT_COMMAND_TEXT_UPDATED
, wxCommandEvent
)
280 wxPROPERTY_FLAGS( WindowStyle
, wxListCtrlStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
281 wxEND_PROPERTIES_TABLE()
283 wxBEGIN_HANDLERS_TABLE(wxListCtrl
)
284 wxEND_HANDLERS_TABLE()
286 wxCONSTRUCTOR_5( wxListCtrl
, wxWindow
* , Parent
, wxWindowID
, Id
, wxPoint
, Position
, wxSize
, Size
, long , WindowStyle
)
289 TODO : Expose more information of a list's layout etc. via appropriate objects (a la NotebookPageInfo)
292 IMPLEMENT_DYNAMIC_CLASS(wxListCtrl
, wxControl
)
295 IMPLEMENT_DYNAMIC_CLASS(wxListView
, wxListCtrl
)
296 IMPLEMENT_DYNAMIC_CLASS(wxListItem
, wxObject
)
298 IMPLEMENT_DYNAMIC_CLASS(wxListEvent
, wxNotifyEvent
)
300 BEGIN_EVENT_TABLE(wxListCtrl
, wxControl
)
301 EVT_PAINT(wxListCtrl::OnPaint
)
304 // ============================================================================
306 // ============================================================================
308 // ----------------------------------------------------------------------------
309 // wxListCtrl construction
310 // ----------------------------------------------------------------------------
312 void wxListCtrl::Init()
316 m_imageListState
= NULL
;
317 m_ownsImageListNormal
=
318 m_ownsImageListSmall
=
319 m_ownsImageListState
= false;
325 m_hasAnyAttr
= false;
328 bool wxListCtrl::Create(wxWindow
*parent
,
333 const wxValidator
& validator
,
334 const wxString
& name
)
336 if ( !CreateControl(parent
, id
, pos
, size
, style
, validator
, name
) )
339 if ( !MSWCreateControl(WC_LISTVIEW
, wxEmptyString
, pos
, size
) )
342 // explicitly say that we want to use Unicode because otherwise we get ANSI
343 // versions of _some_ messages (notably LVN_GETDISPINFOA) in MSLU build
344 wxSetCCUnicodeFormat(GetHwnd());
346 // We must set the default text colour to the system/theme color, otherwise
347 // GetTextColour will always return black
348 SetTextColour(GetDefaultAttributes().colFg
);
350 if ( InReportView() )
351 MSWSetExListStyles();
356 void wxListCtrl::MSWSetExListStyles()
358 // for comctl32.dll v 4.70+ we want to have some non default extended
359 // styles because it's prettier (and also because wxGTK does it like this)
360 if ( wxApp::GetComCtl32Version() >= 470 )
364 GetHwnd(), LVM_SETEXTENDEDLISTVIEWSTYLE
, 0,
365 // LVS_EX_LABELTIP shouldn't be used under Windows CE where it's
366 // not defined in the SDK headers
367 #ifdef LVS_EX_LABELTIP
370 LVS_EX_FULLROWSELECT
|
371 LVS_EX_SUBITEMIMAGES
|
372 // normally this should be governed by a style as it's probably not
373 // always appropriate, but we don't have any free styles left and
374 // it seems better to enable it by default than disable
375 LVS_EX_HEADERDRAGDROP
380 WXDWORD
wxListCtrl::MSWGetStyle(long style
, WXDWORD
*exstyle
) const
382 WXDWORD wstyle
= wxControl::MSWGetStyle(style
, exstyle
);
384 wstyle
|= LVS_SHAREIMAGELISTS
| LVS_SHOWSELALWAYS
;
389 #define MAP_MODE_STYLE(wx, ms) \
390 if ( style & (wx) ) { wstyle |= (ms); nModes++; }
391 #else // !wxDEBUG_LEVEL
392 #define MAP_MODE_STYLE(wx, ms) \
393 if ( style & (wx) ) wstyle |= (ms);
394 #endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
396 MAP_MODE_STYLE(wxLC_ICON
, LVS_ICON
)
397 MAP_MODE_STYLE(wxLC_SMALL_ICON
, LVS_SMALLICON
)
398 MAP_MODE_STYLE(wxLC_LIST
, LVS_LIST
)
399 MAP_MODE_STYLE(wxLC_REPORT
, LVS_REPORT
)
401 wxASSERT_MSG( nModes
== 1,
402 wxT("wxListCtrl style should have exactly one mode bit set") );
404 #undef MAP_MODE_STYLE
406 if ( style
& wxLC_ALIGN_LEFT
)
407 wstyle
|= LVS_ALIGNLEFT
;
409 if ( style
& wxLC_ALIGN_TOP
)
410 wstyle
|= LVS_ALIGNTOP
;
412 if ( style
& wxLC_AUTOARRANGE
)
413 wstyle
|= LVS_AUTOARRANGE
;
415 if ( style
& wxLC_NO_SORT_HEADER
)
416 wstyle
|= LVS_NOSORTHEADER
;
418 if ( style
& wxLC_NO_HEADER
)
419 wstyle
|= LVS_NOCOLUMNHEADER
;
421 if ( style
& wxLC_EDIT_LABELS
)
422 wstyle
|= LVS_EDITLABELS
;
424 if ( style
& wxLC_SINGLE_SEL
)
425 wstyle
|= LVS_SINGLESEL
;
427 if ( style
& wxLC_SORT_ASCENDING
)
429 wstyle
|= LVS_SORTASCENDING
;
431 wxASSERT_MSG( !(style
& wxLC_SORT_DESCENDING
),
432 wxT("can't sort in ascending and descending orders at once") );
434 else if ( style
& wxLC_SORT_DESCENDING
)
435 wstyle
|= LVS_SORTDESCENDING
;
437 #if !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )
438 if ( style
& wxLC_VIRTUAL
)
440 int ver
= wxApp::GetComCtl32Version();
443 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."),
444 ver
/ 100, ver
% 100);
447 wstyle
|= LVS_OWNERDATA
;
449 #endif // ancient cygwin
454 void wxListCtrl::UpdateStyle()
458 // The new window view style
459 DWORD dwStyleNew
= MSWGetStyle(m_windowStyle
, NULL
);
461 // some styles are not returned by MSWGetStyle()
463 dwStyleNew
|= WS_VISIBLE
;
465 // Get the current window style.
466 DWORD dwStyleOld
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
468 // we don't have wxVSCROLL style, but the list control may have it,
469 // don't change it then
470 dwStyleNew
|= dwStyleOld
& (WS_HSCROLL
| WS_VSCROLL
);
472 // Only set the window style if the view bits have changed.
473 if ( dwStyleOld
!= dwStyleNew
)
475 ::SetWindowLong(GetHwnd(), GWL_STYLE
, dwStyleNew
);
477 // if we switched to the report view, set the extended styles for
479 if ( !(dwStyleOld
& LVS_REPORT
) && (dwStyleNew
& LVS_REPORT
) )
480 MSWSetExListStyles();
485 void wxListCtrl::FreeAllInternalData()
487 const unsigned count
= m_internalData
.size();
488 for ( unsigned n
= 0; n
< count
; n
++ )
489 delete m_internalData
[n
];
491 m_internalData
.clear();
494 void wxListCtrl::DeleteEditControl()
498 m_textCtrl
->UnsubclassWin();
499 m_textCtrl
->SetHWND(0);
505 wxListCtrl::~wxListCtrl()
507 FreeAllInternalData();
511 if (m_ownsImageListNormal
)
512 delete m_imageListNormal
;
513 if (m_ownsImageListSmall
)
514 delete m_imageListSmall
;
515 if (m_ownsImageListState
)
516 delete m_imageListState
;
519 // ----------------------------------------------------------------------------
520 // set/get/change style
521 // ----------------------------------------------------------------------------
523 // Add or remove a single window style
524 void wxListCtrl::SetSingleStyle(long style
, bool add
)
526 long flag
= GetWindowStyleFlag();
528 // Get rid of conflicting styles
531 if ( style
& wxLC_MASK_TYPE
)
532 flag
= flag
& ~wxLC_MASK_TYPE
;
533 if ( style
& wxLC_MASK_ALIGN
)
534 flag
= flag
& ~wxLC_MASK_ALIGN
;
535 if ( style
& wxLC_MASK_SORT
)
536 flag
= flag
& ~wxLC_MASK_SORT
;
544 SetWindowStyleFlag(flag
);
547 // Set the whole window style
548 void wxListCtrl::SetWindowStyleFlag(long flag
)
550 if ( flag
!= m_windowStyle
)
552 wxControl::SetWindowStyleFlag(flag
);
560 // ----------------------------------------------------------------------------
562 // ----------------------------------------------------------------------------
564 /* static */ wxVisualAttributes
565 wxListCtrl::GetClassDefaultAttributes(wxWindowVariant variant
)
567 wxVisualAttributes attrs
= GetCompositeControlsDefaultAttributes(variant
);
569 // common controls have their own default font
570 attrs
.font
= wxGetCCDefaultFont();
575 // Sets the foreground, i.e. text, colour
576 bool wxListCtrl::SetForegroundColour(const wxColour
& col
)
578 if ( !wxWindow::SetForegroundColour(col
) )
581 ListView_SetTextColor(GetHwnd(), wxColourToRGB(col
));
586 // Sets the background colour
587 bool wxListCtrl::SetBackgroundColour(const wxColour
& col
)
589 if ( !wxWindow::SetBackgroundColour(col
) )
592 // we set the same colour for both the "empty" background and the items
594 COLORREF color
= wxColourToRGB(col
);
595 ListView_SetBkColor(GetHwnd(), color
);
596 ListView_SetTextBkColor(GetHwnd(), color
);
601 // Gets information about this column
602 bool wxListCtrl::GetColumn(int col
, wxListItem
& item
) const
607 lvCol
.mask
= LVCF_WIDTH
;
609 if ( item
.m_mask
& wxLIST_MASK_TEXT
)
611 lvCol
.mask
|= LVCF_TEXT
;
612 lvCol
.pszText
= new wxChar
[513];
613 lvCol
.cchTextMax
= 512;
616 if ( item
.m_mask
& wxLIST_MASK_FORMAT
)
618 lvCol
.mask
|= LVCF_FMT
;
621 if ( item
.m_mask
& wxLIST_MASK_IMAGE
)
623 lvCol
.mask
|= LVCF_IMAGE
;
626 bool success
= ListView_GetColumn(GetHwnd(), col
, &lvCol
) != 0;
628 // item.m_subItem = lvCol.iSubItem;
629 item
.m_width
= lvCol
.cx
;
631 if ( (item
.m_mask
& wxLIST_MASK_TEXT
) && lvCol
.pszText
)
633 item
.m_text
= lvCol
.pszText
;
634 delete[] lvCol
.pszText
;
637 if ( item
.m_mask
& wxLIST_MASK_FORMAT
)
639 switch (lvCol
.fmt
& LVCFMT_JUSTIFYMASK
) {
641 item
.m_format
= wxLIST_FORMAT_LEFT
;
644 item
.m_format
= wxLIST_FORMAT_RIGHT
;
647 item
.m_format
= wxLIST_FORMAT_CENTRE
;
650 item
.m_format
= -1; // Unknown?
655 // the column images were not supported in older versions but how to check
656 // for this? we can't use _WIN32_IE because we always define it to a very
657 // high value, so see if another symbol which is only defined starting from
658 // comctl32.dll 4.70 is available
659 #ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
660 if ( item
.m_mask
& wxLIST_MASK_IMAGE
)
662 item
.m_image
= lvCol
.iImage
;
664 #endif // LVCOLUMN::iImage exists
669 // Sets information about this column
670 bool wxListCtrl::SetColumn(int col
, const wxListItem
& item
)
673 wxConvertToMSWListCol(GetHwnd(), col
, item
, lvCol
);
675 return ListView_SetColumn(GetHwnd(), col
, &lvCol
) != 0;
678 // Gets the column width
679 int wxListCtrl::GetColumnWidth(int col
) const
681 return ListView_GetColumnWidth(GetHwnd(), col
);
684 // Sets the column width
685 bool wxListCtrl::SetColumnWidth(int col
, int width
)
687 if ( m_windowStyle
& wxLC_LIST
)
690 if ( width
== wxLIST_AUTOSIZE
)
691 width
= LVSCW_AUTOSIZE
;
692 else if ( width
== wxLIST_AUTOSIZE_USEHEADER
)
693 width
= LVSCW_AUTOSIZE_USEHEADER
;
695 return ListView_SetColumnWidth(GetHwnd(), col
, width
) != 0;
698 // ----------------------------------------------------------------------------
700 // ----------------------------------------------------------------------------
702 int wxListCtrl::GetColumnIndexFromOrder(int order
) const
704 const int numCols
= GetColumnCount();
705 wxCHECK_MSG( order
>= 0 && order
< numCols
, -1,
706 wxT("Column position out of bounds") );
708 wxArrayInt
indexArray(numCols
);
709 if ( !ListView_GetColumnOrderArray(GetHwnd(), numCols
, &indexArray
[0]) )
712 return indexArray
[order
];
715 int wxListCtrl::GetColumnOrder(int col
) const
717 const int numCols
= GetColumnCount();
718 wxASSERT_MSG( col
>= 0 && col
< numCols
, wxT("Column index out of bounds") );
720 wxArrayInt
indexArray(numCols
);
721 if ( !ListView_GetColumnOrderArray(GetHwnd(), numCols
, &indexArray
[0]) )
724 for ( int pos
= 0; pos
< numCols
; pos
++ )
726 if ( indexArray
[pos
] == col
)
730 wxFAIL_MSG( wxT("no column with with given order?") );
735 // Gets the column order for all columns
736 wxArrayInt
wxListCtrl::GetColumnsOrder() const
738 const int numCols
= GetColumnCount();
740 wxArrayInt
orders(numCols
);
741 if ( !ListView_GetColumnOrderArray(GetHwnd(), numCols
, &orders
[0]) )
747 // Sets the column order for all columns
748 bool wxListCtrl::SetColumnsOrder(const wxArrayInt
& orders
)
750 const int numCols
= GetColumnCount();
752 wxCHECK_MSG( orders
.size() == (size_t)numCols
, false,
753 wxT("wrong number of elements in column orders array") );
755 return ListView_SetColumnOrderArray(GetHwnd(), numCols
, &orders
[0]) != 0;
759 // Gets the number of items that can fit vertically in the
760 // visible area of the list control (list or report view)
761 // or the total number of items in the list control (icon
762 // or small icon view)
763 int wxListCtrl::GetCountPerPage() const
765 return ListView_GetCountPerPage(GetHwnd());
768 // Gets the edit control for editing labels.
769 wxTextCtrl
* wxListCtrl::GetEditControl() const
771 // first check corresponds to the case when the label editing was started
772 // by user and hence m_textCtrl wasn't created by EditLabel() at all, while
773 // the second case corresponds to us being called from inside EditLabel()
774 // (e.g. from a user wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT handler): in this
775 // case EditLabel() did create the control but it didn't have an HWND to
776 // initialize it with yet
777 if ( !m_textCtrl
|| !m_textCtrl
->GetHWND() )
779 HWND hwndEdit
= ListView_GetEditControl(GetHwnd());
782 wxListCtrl
* const self
= const_cast<wxListCtrl
*>(this);
785 self
->m_textCtrl
= new wxTextCtrl
;
786 self
->InitEditControl((WXHWND
)hwndEdit
);
793 // Gets information about the item
794 bool wxListCtrl::GetItem(wxListItem
& info
) const
797 wxZeroMemory(lvItem
);
799 lvItem
.iItem
= info
.m_itemId
;
800 lvItem
.iSubItem
= info
.m_col
;
802 if ( info
.m_mask
& wxLIST_MASK_TEXT
)
804 lvItem
.mask
|= LVIF_TEXT
;
805 lvItem
.pszText
= new wxChar
[513];
806 lvItem
.cchTextMax
= 512;
810 lvItem
.pszText
= NULL
;
813 if (info
.m_mask
& wxLIST_MASK_DATA
)
814 lvItem
.mask
|= LVIF_PARAM
;
816 if (info
.m_mask
& wxLIST_MASK_IMAGE
)
817 lvItem
.mask
|= LVIF_IMAGE
;
819 if ( info
.m_mask
& wxLIST_MASK_STATE
)
821 lvItem
.mask
|= LVIF_STATE
;
822 wxConvertToMSWFlags(0, info
.m_stateMask
, lvItem
);
825 bool success
= ListView_GetItem((HWND
)GetHWND(), &lvItem
) != 0;
828 wxLogError(_("Couldn't retrieve information about list control item %d."),
833 // give NULL as hwnd as we already have everything we need
834 wxConvertFromMSWListItem(NULL
, info
, lvItem
);
838 delete[] lvItem
.pszText
;
843 // Sets information about the item
844 bool wxListCtrl::SetItem(wxListItem
& info
)
846 const long id
= info
.GetId();
847 wxCHECK_MSG( id
>= 0 && id
< GetItemCount(), false,
848 wxT("invalid item index in SetItem") );
851 wxConvertToMSWListItem(this, info
, item
);
853 // we never update the lParam if it contains our pointer
854 // to the wxMSWListItemData structure
855 item
.mask
&= ~LVIF_PARAM
;
857 // check if setting attributes or lParam
858 if ( info
.HasAttributes() || (info
.m_mask
& wxLIST_MASK_DATA
) )
860 // get internal item data
861 wxMSWListItemData
*data
= MSWGetItemData(id
);
865 // need to allocate the internal data object
866 data
= new wxMSWListItemData
;
867 m_internalData
.push_back(data
);
868 item
.lParam
= (LPARAM
) data
;
869 item
.mask
|= LVIF_PARAM
;
874 if ( info
.m_mask
& wxLIST_MASK_DATA
)
875 data
->lParam
= info
.m_data
;
878 if ( info
.HasAttributes() )
880 const wxListItemAttr
& attrNew
= *info
.GetAttributes();
882 // don't overwrite the already set attributes if we have them
884 data
->attr
->AssignFrom(attrNew
);
886 data
->attr
= new wxListItemAttr(attrNew
);
891 // we could be changing only the attribute in which case we don't need to
892 // call ListView_SetItem() at all
895 if ( !ListView_SetItem(GetHwnd(), &item
) )
897 wxLogDebug(wxT("ListView_SetItem() failed"));
903 // we need to update the item immediately to show the new image
904 bool updateNow
= (info
.m_mask
& wxLIST_MASK_IMAGE
) != 0;
906 // check whether it has any custom attributes
907 if ( info
.HasAttributes() )
911 // if the colour has changed, we must redraw the item
917 // we need this to make the change visible right now
918 RefreshItem(item
.iItem
);
924 long wxListCtrl::SetItem(long index
, int col
, const wxString
& label
, int imageId
)
928 info
.m_mask
= wxLIST_MASK_TEXT
;
929 info
.m_itemId
= index
;
933 info
.m_image
= imageId
;
934 info
.m_mask
|= wxLIST_MASK_IMAGE
;
936 return SetItem(info
);
940 // Gets the item state
941 int wxListCtrl::GetItemState(long item
, long stateMask
) const
945 info
.m_mask
= wxLIST_MASK_STATE
;
946 info
.m_stateMask
= stateMask
;
947 info
.m_itemId
= item
;
955 // Sets the item state
956 bool wxListCtrl::SetItemState(long item
, long state
, long stateMask
)
958 // NB: don't use SetItem() here as it doesn't work with the virtual list
961 wxZeroMemory(lvItem
);
963 wxConvertToMSWFlags(state
, stateMask
, lvItem
);
965 const bool changingFocus
= (stateMask
& wxLIST_STATE_FOCUSED
) &&
966 (state
& wxLIST_STATE_FOCUSED
);
968 // for the virtual list controls we need to refresh the previously focused
969 // item manually when changing focus without changing selection
970 // programmatically because otherwise it keeps its focus rectangle until
971 // next repaint (yet another comctl32 bug)
973 if ( IsVirtual() && changingFocus
)
975 focusOld
= GetNextItem(-1, wxLIST_NEXT_ALL
, wxLIST_STATE_FOCUSED
);
982 if ( !::SendMessage(GetHwnd(), LVM_SETITEMSTATE
,
983 (WPARAM
)item
, (LPARAM
)&lvItem
) )
985 wxLogLastError(wxT("ListView_SetItemState"));
990 if ( focusOld
!= -1 )
992 // no need to refresh the item if it was previously selected, it would
993 // only result in annoying flicker
994 if ( !(GetItemState(focusOld
,
995 wxLIST_STATE_SELECTED
) & wxLIST_STATE_SELECTED
) )
997 RefreshItem(focusOld
);
1001 // we expect the selection anchor, i.e. the item from which multiple
1002 // selection (such as performed with e.g. Shift-arrows) starts, to be the
1003 // same as the currently focused item but the native control doesn't update
1004 // it when we change focus and leaves at the last item it set itself focus
1005 // to, so do it explicitly
1006 if ( changingFocus
&& !HasFlag(wxLC_SINGLE_SEL
) )
1008 ListView_SetSelectionMark(GetHwnd(), item
);
1014 // Sets the item image
1015 bool wxListCtrl::SetItemImage(long item
, int image
, int WXUNUSED(selImage
))
1017 return SetItemColumnImage(item
, 0, image
);
1020 // Sets the item image
1021 bool wxListCtrl::SetItemColumnImage(long item
, long column
, int image
)
1025 info
.m_mask
= wxLIST_MASK_IMAGE
;
1026 info
.m_image
= image
;
1027 info
.m_itemId
= item
;
1028 info
.m_col
= column
;
1030 return SetItem(info
);
1033 // Gets the item text
1034 wxString
wxListCtrl::GetItemText(long item
) const
1038 info
.m_mask
= wxLIST_MASK_TEXT
;
1039 info
.m_itemId
= item
;
1042 return wxEmptyString
;
1046 // Sets the item text
1047 void wxListCtrl::SetItemText(long item
, const wxString
& str
)
1051 info
.m_mask
= wxLIST_MASK_TEXT
;
1052 info
.m_itemId
= item
;
1058 // Gets the internal item data
1059 wxMSWListItemData
*wxListCtrl::MSWGetItemData(long itemId
) const
1062 it
.mask
= LVIF_PARAM
;
1065 if ( !ListView_GetItem(GetHwnd(), &it
) )
1068 return (wxMSWListItemData
*) it
.lParam
;
1071 // Gets the item data
1072 wxUIntPtr
wxListCtrl::GetItemData(long item
) const
1076 info
.m_mask
= wxLIST_MASK_DATA
;
1077 info
.m_itemId
= item
;
1084 // Sets the item data
1085 bool wxListCtrl::SetItemPtrData(long item
, wxUIntPtr data
)
1089 info
.m_mask
= wxLIST_MASK_DATA
;
1090 info
.m_itemId
= item
;
1093 return SetItem(info
);
1096 wxRect
wxListCtrl::GetViewRect() const
1100 // ListView_GetViewRect() can only be used in icon and small icon views
1101 // (this is documented in MSDN and, indeed, it returns bogus results in
1102 // report view, at least with comctl32.dll v6 under Windows 2003)
1103 if ( HasFlag(wxLC_ICON
| wxLC_SMALL_ICON
) )
1106 if ( !ListView_GetViewRect(GetHwnd(), &rc
) )
1108 wxLogDebug(wxT("ListView_GetViewRect() failed."));
1113 wxCopyRECTToRect(rc
, rect
);
1115 else if ( HasFlag(wxLC_REPORT
) )
1117 const long count
= GetItemCount();
1120 GetItemRect(wxMin(GetTopItem() + GetCountPerPage(), count
- 1), rect
);
1122 // extend the rectangle to start at the top (we include the column
1123 // headers, if any, for compatibility with the generic version)
1124 rect
.height
+= rect
.y
;
1130 wxFAIL_MSG( wxT("not implemented in this mode") );
1136 // Gets the item rectangle
1137 bool wxListCtrl::GetItemRect(long item
, wxRect
& rect
, int code
) const
1139 return GetSubItemRect( item
, wxLIST_GETSUBITEMRECT_WHOLEITEM
, rect
, code
) ;
1142 bool wxListCtrl::GetSubItemRect(long item
, long subItem
, wxRect
& rect
, int code
) const
1144 // ListView_GetSubItemRect() doesn't do subItem error checking and returns
1145 // true even for the out of range values of it (even if the results are
1146 // completely bogus in this case), so we check item validity ourselves
1147 wxCHECK_MSG( subItem
== wxLIST_GETSUBITEMRECT_WHOLEITEM
||
1148 (subItem
>= 0 && subItem
< GetColumnCount()),
1149 false, wxT("invalid sub item index") );
1151 // use wxCHECK_MSG against "item" too, for coherency with the generic implementation:
1152 wxCHECK_MSG( item
>= 0 && item
< GetItemCount(), false,
1153 wxT("invalid item in GetSubItemRect") );
1156 if ( code
== wxLIST_RECT_BOUNDS
)
1157 codeWin
= LVIR_BOUNDS
;
1158 else if ( code
== wxLIST_RECT_ICON
)
1159 codeWin
= LVIR_ICON
;
1160 else if ( code
== wxLIST_RECT_LABEL
)
1161 codeWin
= LVIR_LABEL
;
1164 wxFAIL_MSG( wxT("incorrect code in GetItemRect() / GetSubItemRect()") );
1165 codeWin
= LVIR_BOUNDS
;
1169 if ( !wxGetListCtrlSubItemRect
1173 subItem
== wxLIST_GETSUBITEMRECT_WHOLEITEM
? 0 : subItem
,
1181 wxCopyRECTToRect(rectWin
, rect
);
1183 // there is no way to retrieve the first sub item bounding rectangle using
1184 // wxGetListCtrlSubItemRect() as 0 means the whole item, so we need to
1185 // truncate it at first column ourselves
1187 rect
.width
= GetColumnWidth(0);
1195 // Gets the item position
1196 bool wxListCtrl::GetItemPosition(long item
, wxPoint
& pos
) const
1200 bool success
= (ListView_GetItemPosition(GetHwnd(), (int) item
, &pt
) != 0);
1202 pos
.x
= pt
.x
; pos
.y
= pt
.y
;
1206 // Sets the item position.
1207 bool wxListCtrl::SetItemPosition(long item
, const wxPoint
& pos
)
1209 return (ListView_SetItemPosition(GetHwnd(), (int) item
, pos
.x
, pos
.y
) != 0);
1212 // Gets the number of items in the list control
1213 int wxListCtrl::GetItemCount() const
1218 wxSize
wxListCtrl::GetItemSpacing() const
1220 const int spacing
= ListView_GetItemSpacing(GetHwnd(), (BOOL
)HasFlag(wxLC_SMALL_ICON
));
1222 return wxSize(LOWORD(spacing
), HIWORD(spacing
));
1225 #if WXWIN_COMPATIBILITY_2_6
1227 int wxListCtrl::GetItemSpacing(bool isSmall
) const
1229 return ListView_GetItemSpacing(GetHwnd(), (BOOL
) isSmall
);
1232 #endif // WXWIN_COMPATIBILITY_2_6
1234 void wxListCtrl::SetItemTextColour( long item
, const wxColour
&col
)
1237 info
.m_itemId
= item
;
1238 info
.SetTextColour( col
);
1242 wxColour
wxListCtrl::GetItemTextColour( long item
) const
1245 wxMSWListItemData
*data
= MSWGetItemData(item
);
1246 if ( data
&& data
->attr
)
1247 col
= data
->attr
->GetTextColour();
1252 void wxListCtrl::SetItemBackgroundColour( long item
, const wxColour
&col
)
1255 info
.m_itemId
= item
;
1256 info
.SetBackgroundColour( col
);
1260 wxColour
wxListCtrl::GetItemBackgroundColour( long item
) const
1263 wxMSWListItemData
*data
= MSWGetItemData(item
);
1264 if ( data
&& data
->attr
)
1265 col
= data
->attr
->GetBackgroundColour();
1270 void wxListCtrl::SetItemFont( long item
, const wxFont
&f
)
1273 info
.m_itemId
= item
;
1278 wxFont
wxListCtrl::GetItemFont( long item
) const
1281 wxMSWListItemData
*data
= MSWGetItemData(item
);
1282 if ( data
&& data
->attr
)
1283 f
= data
->attr
->GetFont();
1288 // Gets the number of selected items in the list control
1289 int wxListCtrl::GetSelectedItemCount() const
1291 return ListView_GetSelectedCount(GetHwnd());
1294 // Gets the text colour of the listview
1295 wxColour
wxListCtrl::GetTextColour() const
1297 COLORREF ref
= ListView_GetTextColor(GetHwnd());
1298 wxColour
col(GetRValue(ref
), GetGValue(ref
), GetBValue(ref
));
1302 // Sets the text colour of the listview
1303 void wxListCtrl::SetTextColour(const wxColour
& col
)
1305 ListView_SetTextColor(GetHwnd(), PALETTERGB(col
.Red(), col
.Green(), col
.Blue()));
1308 // Gets the index of the topmost visible item when in
1309 // list or report view
1310 long wxListCtrl::GetTopItem() const
1312 return (long) ListView_GetTopIndex(GetHwnd());
1315 // Searches for an item, starting from 'item'.
1316 // 'geometry' is one of
1317 // wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT.
1318 // 'state' is a state bit flag, one or more of
1319 // wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT.
1320 // item can be -1 to find the first item that matches the
1322 // Returns the item or -1 if unsuccessful.
1323 long wxListCtrl::GetNextItem(long item
, int geom
, int state
) const
1327 if ( geom
== wxLIST_NEXT_ABOVE
)
1328 flags
|= LVNI_ABOVE
;
1329 if ( geom
== wxLIST_NEXT_ALL
)
1331 if ( geom
== wxLIST_NEXT_BELOW
)
1332 flags
|= LVNI_BELOW
;
1333 if ( geom
== wxLIST_NEXT_LEFT
)
1334 flags
|= LVNI_TOLEFT
;
1335 if ( geom
== wxLIST_NEXT_RIGHT
)
1336 flags
|= LVNI_TORIGHT
;
1338 if ( state
& wxLIST_STATE_CUT
)
1340 if ( state
& wxLIST_STATE_DROPHILITED
)
1341 flags
|= LVNI_DROPHILITED
;
1342 if ( state
& wxLIST_STATE_FOCUSED
)
1343 flags
|= LVNI_FOCUSED
;
1344 if ( state
& wxLIST_STATE_SELECTED
)
1345 flags
|= LVNI_SELECTED
;
1347 return (long) ListView_GetNextItem(GetHwnd(), item
, flags
);
1351 wxImageList
*wxListCtrl::GetImageList(int which
) const
1353 if ( which
== wxIMAGE_LIST_NORMAL
)
1355 return m_imageListNormal
;
1357 else if ( which
== wxIMAGE_LIST_SMALL
)
1359 return m_imageListSmall
;
1361 else if ( which
== wxIMAGE_LIST_STATE
)
1363 return m_imageListState
;
1368 void wxListCtrl::SetImageList(wxImageList
*imageList
, int which
)
1371 if ( which
== wxIMAGE_LIST_NORMAL
)
1373 flags
= LVSIL_NORMAL
;
1374 if (m_ownsImageListNormal
) delete m_imageListNormal
;
1375 m_imageListNormal
= imageList
;
1376 m_ownsImageListNormal
= false;
1378 else if ( which
== wxIMAGE_LIST_SMALL
)
1380 flags
= LVSIL_SMALL
;
1381 if (m_ownsImageListSmall
) delete m_imageListSmall
;
1382 m_imageListSmall
= imageList
;
1383 m_ownsImageListSmall
= false;
1385 else if ( which
== wxIMAGE_LIST_STATE
)
1387 flags
= LVSIL_STATE
;
1388 if (m_ownsImageListState
) delete m_imageListState
;
1389 m_imageListState
= imageList
;
1390 m_ownsImageListState
= false;
1392 (void) ListView_SetImageList(GetHwnd(), (HIMAGELIST
) imageList
? imageList
->GetHIMAGELIST() : 0, flags
);
1395 void wxListCtrl::AssignImageList(wxImageList
*imageList
, int which
)
1397 SetImageList(imageList
, which
);
1398 if ( which
== wxIMAGE_LIST_NORMAL
)
1399 m_ownsImageListNormal
= true;
1400 else if ( which
== wxIMAGE_LIST_SMALL
)
1401 m_ownsImageListSmall
= true;
1402 else if ( which
== wxIMAGE_LIST_STATE
)
1403 m_ownsImageListState
= true;
1406 // ----------------------------------------------------------------------------
1408 // ----------------------------------------------------------------------------
1410 // Arranges the items
1411 bool wxListCtrl::Arrange(int flag
)
1414 if ( flag
== wxLIST_ALIGN_LEFT
)
1415 code
= LVA_ALIGNLEFT
;
1416 else if ( flag
== wxLIST_ALIGN_TOP
)
1417 code
= LVA_ALIGNTOP
;
1418 else if ( flag
== wxLIST_ALIGN_DEFAULT
)
1420 else if ( flag
== wxLIST_ALIGN_SNAP_TO_GRID
)
1421 code
= LVA_SNAPTOGRID
;
1423 return (ListView_Arrange(GetHwnd(), code
) != 0);
1427 bool wxListCtrl::DeleteItem(long item
)
1429 if ( !ListView_DeleteItem(GetHwnd(), (int) item
) )
1431 wxLogLastError(wxT("ListView_DeleteItem"));
1436 wxASSERT_MSG( m_count
== ListView_GetItemCount(GetHwnd()),
1437 wxT("m_count should match ListView_GetItemCount"));
1439 // the virtual list control doesn't refresh itself correctly, help it
1442 // we need to refresh all the lines below the one which was deleted
1444 if ( item
> 0 && GetItemCount() )
1446 GetItemRect(item
- 1, rectItem
);
1451 rectItem
.height
= 0;
1454 wxRect rectWin
= GetRect();
1455 rectWin
.height
= rectWin
.GetBottom() - rectItem
.GetBottom();
1456 rectWin
.y
= rectItem
.GetBottom();
1458 RefreshRect(rectWin
);
1464 // Deletes all items
1465 bool wxListCtrl::DeleteAllItems()
1467 return ListView_DeleteAllItems(GetHwnd()) != 0;
1470 // Deletes all items
1471 bool wxListCtrl::DeleteAllColumns()
1473 while ( m_colCount
> 0 )
1475 if ( ListView_DeleteColumn(GetHwnd(), 0) == 0 )
1477 wxLogLastError(wxT("ListView_DeleteColumn"));
1485 wxASSERT_MSG( m_colCount
== 0, wxT("no columns should be left") );
1491 bool wxListCtrl::DeleteColumn(int col
)
1493 bool success
= (ListView_DeleteColumn(GetHwnd(), col
) != 0);
1495 if ( success
&& (m_colCount
> 0) )
1500 // Clears items, and columns if there are any.
1501 void wxListCtrl::ClearAll()
1504 if ( m_colCount
> 0 )
1508 void wxListCtrl::InitEditControl(WXHWND hWnd
)
1510 m_textCtrl
->SetHWND(hWnd
);
1511 m_textCtrl
->SubclassWin(hWnd
);
1512 m_textCtrl
->SetParent(this);
1514 // we must disallow TABbing away from the control while the edit contol is
1515 // shown because this leaves it in some strange state (just try removing
1516 // this line and then pressing TAB while editing an item in listctrl
1518 m_textCtrl
->SetWindowStyle(m_textCtrl
->GetWindowStyle() | wxTE_PROCESS_TAB
);
1521 wxTextCtrl
* wxListCtrl::EditLabel(long item
, wxClassInfo
* textControlClass
)
1523 wxCHECK_MSG( textControlClass
->IsKindOf(CLASSINFO(wxTextCtrl
)), NULL
,
1524 "control used for label editing must be a wxTextCtrl" );
1526 // ListView_EditLabel requires that the list has focus.
1529 // create m_textCtrl here before calling ListView_EditLabel() because it
1530 // generates wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT event from inside it and
1531 // the user handler for it can call GetEditControl() resulting in an on
1532 // demand creation of a stock wxTextCtrl instead of the control of a
1533 // (possibly) custom wxClassInfo
1534 DeleteEditControl();
1535 m_textCtrl
= (wxTextCtrl
*)textControlClass
->CreateObject();
1537 WXHWND hWnd
= (WXHWND
) ListView_EditLabel(GetHwnd(), item
);
1540 // failed to start editing
1547 // if GetEditControl() hasn't been called, we need to initialize the edit
1548 // control ourselves
1549 if ( !m_textCtrl
->GetHWND() )
1550 InitEditControl(hWnd
);
1555 // End label editing, optionally cancelling the edit
1556 bool wxListCtrl::EndEditLabel(bool cancel
)
1558 // m_textCtrl is not always ready, ie. in EVT_LIST_BEGIN_LABEL_EDIT
1559 HWND hwnd
= ListView_GetEditControl(GetHwnd());
1564 ::SetWindowText(hwnd
, wxEmptyString
); // dubious but better than nothing
1566 // we shouldn't destroy the control ourselves according to MSDN, which
1567 // proposes WM_CANCELMODE to do this, but it doesn't seem to work
1569 // posting WM_CLOSE to it does seem to work without any side effects
1570 ::PostMessage(hwnd
, WM_CLOSE
, 0, 0);
1575 // Ensures this item is visible
1576 bool wxListCtrl::EnsureVisible(long item
)
1578 return ListView_EnsureVisible(GetHwnd(), (int) item
, FALSE
) != FALSE
;
1581 // Find an item whose label matches this string, starting from the item after 'start'
1582 // or the beginning if 'start' is -1.
1583 long wxListCtrl::FindItem(long start
, const wxString
& str
, bool partial
)
1585 LV_FINDINFO findInfo
;
1587 findInfo
.flags
= LVFI_STRING
;
1589 findInfo
.flags
|= LVFI_PARTIAL
;
1590 findInfo
.psz
= str
.wx_str();
1592 // ListView_FindItem() excludes the first item from search and to look
1593 // through all the items you need to start from -1 which is unnatural and
1594 // inconsistent with the generic version - so we adjust the index
1597 return ListView_FindItem(GetHwnd(), start
, &findInfo
);
1600 // Find an item whose data matches this data, starting from the item after
1601 // 'start' or the beginning if 'start' is -1.
1602 long wxListCtrl::FindItem(long start
, wxUIntPtr data
)
1604 // we can't use ListView_FindItem() directly as we don't store the data
1605 // pointer itself in the control but rather our own internal data, so first
1606 // we need to find the right value to search for (and there can be several
1608 int idx
= wxNOT_FOUND
;
1609 const unsigned count
= m_internalData
.size();
1610 for ( unsigned n
= 0; n
< count
; n
++ )
1612 if ( m_internalData
[n
]->lParam
== (LPARAM
)data
)
1614 LV_FINDINFO findInfo
;
1615 findInfo
.flags
= LVFI_PARAM
;
1616 findInfo
.lParam
= (LPARAM
)wxPtrToUInt(m_internalData
[n
]);
1618 int rc
= ListView_FindItem(GetHwnd(), start
, &findInfo
);
1621 if ( idx
== wxNOT_FOUND
|| rc
< idx
)
1624 if ( idx
== start
+ 1 )
1626 // we can stop here, we don't risk finding a closer
1631 //else: this item is after the previously found one
1639 // Find an item nearest this position in the specified direction, starting from
1640 // the item after 'start' or the beginning if 'start' is -1.
1641 long wxListCtrl::FindItem(long start
, const wxPoint
& pt
, int direction
)
1643 LV_FINDINFO findInfo
;
1645 findInfo
.flags
= LVFI_NEARESTXY
;
1646 findInfo
.pt
.x
= pt
.x
;
1647 findInfo
.pt
.y
= pt
.y
;
1648 findInfo
.vkDirection
= VK_RIGHT
;
1650 if ( direction
== wxLIST_FIND_UP
)
1651 findInfo
.vkDirection
= VK_UP
;
1652 else if ( direction
== wxLIST_FIND_DOWN
)
1653 findInfo
.vkDirection
= VK_DOWN
;
1654 else if ( direction
== wxLIST_FIND_LEFT
)
1655 findInfo
.vkDirection
= VK_LEFT
;
1656 else if ( direction
== wxLIST_FIND_RIGHT
)
1657 findInfo
.vkDirection
= VK_RIGHT
;
1659 return ListView_FindItem(GetHwnd(), start
, &findInfo
);
1662 // Determines which item (if any) is at the specified point,
1663 // giving details in 'flags' (see wxLIST_HITTEST_... flags above)
1665 wxListCtrl::HitTest(const wxPoint
& point
, int& flags
, long *ptrSubItem
) const
1667 LV_HITTESTINFO hitTestInfo
;
1668 hitTestInfo
.pt
.x
= (int) point
.x
;
1669 hitTestInfo
.pt
.y
= (int) point
.y
;
1672 #ifdef LVM_SUBITEMHITTEST
1673 if ( ptrSubItem
&& wxApp::GetComCtl32Version() >= 470 )
1675 item
= ListView_SubItemHitTest(GetHwnd(), &hitTestInfo
);
1676 *ptrSubItem
= hitTestInfo
.iSubItem
;
1679 #endif // LVM_SUBITEMHITTEST
1681 item
= ListView_HitTest(GetHwnd(), &hitTestInfo
);
1686 if ( hitTestInfo
.flags
& LVHT_ABOVE
)
1687 flags
|= wxLIST_HITTEST_ABOVE
;
1688 if ( hitTestInfo
.flags
& LVHT_BELOW
)
1689 flags
|= wxLIST_HITTEST_BELOW
;
1690 if ( hitTestInfo
.flags
& LVHT_TOLEFT
)
1691 flags
|= wxLIST_HITTEST_TOLEFT
;
1692 if ( hitTestInfo
.flags
& LVHT_TORIGHT
)
1693 flags
|= wxLIST_HITTEST_TORIGHT
;
1695 if ( hitTestInfo
.flags
& LVHT_NOWHERE
)
1696 flags
|= wxLIST_HITTEST_NOWHERE
;
1698 // note a bug or at least a very strange feature of comtl32.dll (tested
1699 // with version 4.0 under Win95 and 6.0 under Win 2003): if you click to
1700 // the right of the item label, ListView_HitTest() returns a combination of
1701 // LVHT_ONITEMICON, LVHT_ONITEMLABEL and LVHT_ONITEMSTATEICON -- filter out
1702 // the bits which don't make sense
1703 if ( hitTestInfo
.flags
& LVHT_ONITEMLABEL
)
1705 flags
|= wxLIST_HITTEST_ONITEMLABEL
;
1707 // do not translate LVHT_ONITEMICON here, as per above
1711 if ( hitTestInfo
.flags
& LVHT_ONITEMICON
)
1712 flags
|= wxLIST_HITTEST_ONITEMICON
;
1713 if ( hitTestInfo
.flags
& LVHT_ONITEMSTATEICON
)
1714 flags
|= wxLIST_HITTEST_ONITEMSTATEICON
;
1721 // Inserts an item, returning the index of the new item if successful,
1723 long wxListCtrl::InsertItem(const wxListItem
& info
)
1725 wxASSERT_MSG( !IsVirtual(), wxT("can't be used with virtual controls") );
1728 wxConvertToMSWListItem(this, info
, item
);
1729 item
.mask
&= ~LVIF_PARAM
;
1731 // check whether we need to allocate our internal data
1732 bool needInternalData
= (info
.m_mask
& wxLIST_MASK_DATA
) ||
1733 info
.HasAttributes();
1734 if ( needInternalData
)
1736 item
.mask
|= LVIF_PARAM
;
1738 wxMSWListItemData
* const data
= new wxMSWListItemData
;
1739 m_internalData
.push_back(data
);
1740 item
.lParam
= (LPARAM
)data
;
1742 if ( info
.m_mask
& wxLIST_MASK_DATA
)
1743 data
->lParam
= info
.m_data
;
1745 // check whether it has any custom attributes
1746 if ( info
.HasAttributes() )
1748 // take copy of attributes
1749 data
->attr
= new wxListItemAttr(*info
.GetAttributes());
1751 // and remember that we have some now...
1752 m_hasAnyAttr
= true;
1756 const long rv
= ListView_InsertItem(GetHwnd(), & item
);
1758 // failing to insert the item is really unexpected
1759 wxCHECK_MSG( rv
!= -1, rv
, "failed to insert an item in wxListCtrl" );
1762 wxASSERT_MSG( m_count
== ListView_GetItemCount(GetHwnd()),
1763 wxT("m_count should match ListView_GetItemCount"));
1768 long wxListCtrl::InsertItem(long index
, const wxString
& label
)
1771 info
.m_text
= label
;
1772 info
.m_mask
= wxLIST_MASK_TEXT
;
1773 info
.m_itemId
= index
;
1774 return InsertItem(info
);
1777 // Inserts an image item
1778 long wxListCtrl::InsertItem(long index
, int imageIndex
)
1781 info
.m_image
= imageIndex
;
1782 info
.m_mask
= wxLIST_MASK_IMAGE
;
1783 info
.m_itemId
= index
;
1784 return InsertItem(info
);
1787 // Inserts an image/string item
1788 long wxListCtrl::InsertItem(long index
, const wxString
& label
, int imageIndex
)
1791 info
.m_image
= imageIndex
;
1792 info
.m_text
= label
;
1793 info
.m_mask
= wxLIST_MASK_IMAGE
| wxLIST_MASK_TEXT
;
1794 info
.m_itemId
= index
;
1795 return InsertItem(info
);
1798 // For list view mode (only), inserts a column.
1799 long wxListCtrl::InsertColumn(long col
, const wxListItem
& item
)
1802 wxConvertToMSWListCol(GetHwnd(), col
, item
, lvCol
);
1804 if ( !(lvCol
.mask
& LVCF_WIDTH
) )
1806 // always give some width to the new column: this one is compatible
1807 // with the generic version
1808 lvCol
.mask
|= LVCF_WIDTH
;
1812 long n
= ListView_InsertColumn(GetHwnd(), col
, &lvCol
);
1817 else // failed to insert?
1819 wxLogDebug(wxT("Failed to insert the column '%s' into listview!"),
1826 long wxListCtrl::InsertColumn(long col
,
1827 const wxString
& heading
,
1832 item
.m_mask
= wxLIST_MASK_TEXT
| wxLIST_MASK_FORMAT
;
1833 item
.m_text
= heading
;
1836 item
.m_mask
|= wxLIST_MASK_WIDTH
;
1837 item
.m_width
= width
;
1839 item
.m_format
= format
;
1841 return InsertColumn(col
, item
);
1844 // scroll the control by the given number of pixels (exception: in list view,
1845 // dx is interpreted as number of columns)
1846 bool wxListCtrl::ScrollList(int dx
, int dy
)
1848 if ( !ListView_Scroll(GetHwnd(), dx
, dy
) )
1850 wxLogDebug(wxT("ListView_Scroll(%d, %d) failed"), dx
, dy
);
1860 // fn is a function which takes 3 long arguments: item1, item2, data.
1861 // item1 is the long data associated with a first item (NOT the index).
1862 // item2 is the long data associated with a second item (NOT the index).
1863 // data is the same value as passed to SortItems.
1864 // The return value is a negative number if the first item should precede the second
1865 // item, a positive number of the second item should precede the first,
1866 // or zero if the two items are equivalent.
1868 // data is arbitrary data to be passed to the sort function.
1870 // Internal structures for proxying the user compare function
1871 // so that we can pass it the *real* user data
1873 // translate lParam data and call user func
1874 struct wxInternalDataSort
1876 wxListCtrlCompare user_fn
;
1880 int CALLBACK
wxInternalDataCompareFunc(LPARAM lParam1
, LPARAM lParam2
, LPARAM lParamSort
)
1882 wxInternalDataSort
* const internalData
= (wxInternalDataSort
*) lParamSort
;
1884 wxMSWListItemData
*data1
= (wxMSWListItemData
*) lParam1
;
1885 wxMSWListItemData
*data2
= (wxMSWListItemData
*) lParam2
;
1887 long d1
= (data1
== NULL
? 0 : data1
->lParam
);
1888 long d2
= (data2
== NULL
? 0 : data2
->lParam
);
1890 return internalData
->user_fn(d1
, d2
, internalData
->data
);
1894 bool wxListCtrl::SortItems(wxListCtrlCompare fn
, wxIntPtr data
)
1896 wxInternalDataSort internalData
;
1897 internalData
.user_fn
= fn
;
1898 internalData
.data
= data
;
1900 // WPARAM cast is needed for mingw/cygwin
1901 if ( !ListView_SortItems(GetHwnd(),
1902 wxInternalDataCompareFunc
,
1903 (WPARAM
) &internalData
) )
1905 wxLogDebug(wxT("ListView_SortItems() failed"));
1915 // ----------------------------------------------------------------------------
1916 // message processing
1917 // ----------------------------------------------------------------------------
1919 bool wxListCtrl::MSWShouldPreProcessMessage(WXMSG
* msg
)
1921 if ( msg
->message
== WM_KEYDOWN
)
1923 // Only eat VK_RETURN if not being used by the application in
1924 // conjunction with modifiers
1925 if ( msg
->wParam
== VK_RETURN
&& !wxIsAnyModifierDown() )
1927 // we need VK_RETURN to generate wxEVT_COMMAND_LIST_ITEM_ACTIVATED
1931 return wxControl::MSWShouldPreProcessMessage(msg
);
1934 bool wxListCtrl::MSWCommand(WXUINT cmd
, WXWORD id_
)
1936 const int id
= (signed short)id_
;
1937 if (cmd
== EN_UPDATE
)
1939 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, id
);
1940 event
.SetEventObject( this );
1941 ProcessCommand(event
);
1944 else if (cmd
== EN_KILLFOCUS
)
1946 wxCommandEvent
event(wxEVT_KILL_FOCUS
, id
);
1947 event
.SetEventObject( this );
1948 ProcessCommand(event
);
1955 // utility used by wxListCtrl::MSWOnNotify and by wxDataViewHeaderWindowMSW::MSWOnNotify
1956 int WXDLLIMPEXP_CORE
wxMSWGetColumnClicked(NMHDR
*nmhdr
, POINT
*ptClick
)
1958 // find the column clicked: we have to search for it ourselves as the
1959 // notification message doesn't provide this info
1961 // where did the click occur?
1962 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
1963 if ( nmhdr
->code
== GN_CONTEXTMENU
)
1965 *ptClick
= ((NMRGINFO
*)nmhdr
)->ptAction
;
1968 #endif //__WXWINCE__
1969 if ( !::GetCursorPos(ptClick
) )
1971 wxLogLastError(wxT("GetCursorPos"));
1974 // we need to use listctrl coordinates for the event point so this is what
1975 // we return in ptClick, but for comparison with Header_GetItemRect()
1976 // result below we need to use header window coordinates
1977 POINT ptClickHeader
= *ptClick
;
1978 if ( !::ScreenToClient(nmhdr
->hwndFrom
, &ptClickHeader
) )
1980 wxLogLastError(wxT("ScreenToClient(listctrl header)"));
1983 if ( !::ScreenToClient(::GetParent(nmhdr
->hwndFrom
), ptClick
) )
1985 wxLogLastError(wxT("ScreenToClient(listctrl)"));
1988 const int colCount
= Header_GetItemCount(nmhdr
->hwndFrom
);
1989 for ( int col
= 0; col
< colCount
; col
++ )
1992 if ( Header_GetItemRect(nmhdr
->hwndFrom
, col
, &rect
) )
1994 if ( ::PtInRect(&rect
, ptClickHeader
) )
2004 bool wxListCtrl::MSWOnNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
2007 // prepare the event
2008 // -----------------
2010 wxListEvent
event(wxEVT_NULL
, m_windowId
);
2011 event
.SetEventObject(this);
2013 wxEventType eventType
= wxEVT_NULL
;
2015 NMHDR
*nmhdr
= (NMHDR
*)lParam
;
2017 // if your compiler is as broken as this, you should really change it: this
2018 // code is needed for normal operation! #ifdef below is only useful for
2019 // automatic rebuilds which are done with a very old compiler version
2020 #ifdef HDN_BEGINTRACKA
2022 // check for messages from the header (in report view)
2023 HWND hwndHdr
= ListView_GetHeader(GetHwnd());
2025 // is it a message from the header?
2026 if ( nmhdr
->hwndFrom
== hwndHdr
)
2028 HD_NOTIFY
*nmHDR
= (HD_NOTIFY
*)nmhdr
;
2030 event
.m_itemIndex
= -1;
2032 switch ( nmhdr
->code
)
2034 // yet another comctl32.dll bug: under NT/W2K it sends Unicode
2035 // TRACK messages even to ANSI programs: on my system I get
2036 // HDN_BEGINTRACKW and HDN_ENDTRACKA and no HDN_TRACK at all!
2038 // work around is to simply catch both versions and hope that it
2039 // works (why should this message exist in ANSI and Unicode is
2040 // beyond me as it doesn't deal with strings at all...)
2042 // note that fr HDN_TRACK another possibility could be to use
2043 // HDN_ITEMCHANGING but it is sent even after HDN_ENDTRACK and when
2044 // something other than the item width changes so we'd have to
2045 // filter out the unwanted events then
2046 case HDN_BEGINTRACKA
:
2047 case HDN_BEGINTRACKW
:
2048 eventType
= wxEVT_COMMAND_LIST_COL_BEGIN_DRAG
;
2053 if ( eventType
== wxEVT_NULL
)
2054 eventType
= wxEVT_COMMAND_LIST_COL_DRAGGING
;
2059 if ( eventType
== wxEVT_NULL
)
2060 eventType
= wxEVT_COMMAND_LIST_COL_END_DRAG
;
2062 event
.m_item
.m_width
= nmHDR
->pitem
->cxy
;
2063 event
.m_col
= nmHDR
->iItem
;
2066 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
2067 case GN_CONTEXTMENU
:
2068 #endif //__WXWINCE__
2073 eventType
= wxEVT_COMMAND_LIST_COL_RIGHT_CLICK
;
2074 event
.m_col
= wxMSWGetColumnClicked(nmhdr
, &ptClick
);
2075 event
.m_pointDrag
.x
= ptClick
.x
;
2076 event
.m_pointDrag
.y
= ptClick
.y
;
2080 case HDN_GETDISPINFOW
:
2081 // letting Windows XP handle this message results in mysterious
2082 // crashes in comctl32.dll seemingly because of bad message
2085 // I have no idea what is the real cause of the bug (which is,
2086 // just to make things interesting, impossible to reproduce
2087 // reliably) but ignoring all these messages does fix it and
2088 // doesn't seem to have any negative consequences
2092 return wxControl::MSWOnNotify(idCtrl
, lParam
, result
);
2096 #endif // defined(HDN_BEGINTRACKA)
2097 if ( nmhdr
->hwndFrom
== GetHwnd() )
2099 // almost all messages use NM_LISTVIEW
2100 NM_LISTVIEW
*nmLV
= (NM_LISTVIEW
*)nmhdr
;
2102 const int iItem
= nmLV
->iItem
;
2105 // If we have a valid item then check if there is a data value
2106 // associated with it and put it in the event.
2107 if ( iItem
>= 0 && iItem
< GetItemCount() )
2109 wxMSWListItemData
*internaldata
=
2110 MSWGetItemData(iItem
);
2113 event
.m_item
.m_data
= internaldata
->lParam
;
2116 bool processed
= true;
2117 switch ( nmhdr
->code
)
2119 case LVN_BEGINRDRAG
:
2120 eventType
= wxEVT_COMMAND_LIST_BEGIN_RDRAG
;
2124 if ( eventType
== wxEVT_NULL
)
2126 eventType
= wxEVT_COMMAND_LIST_BEGIN_DRAG
;
2129 event
.m_itemIndex
= iItem
;
2130 event
.m_pointDrag
.x
= nmLV
->ptAction
.x
;
2131 event
.m_pointDrag
.y
= nmLV
->ptAction
.y
;
2134 // NB: we have to handle both *A and *W versions here because some
2135 // versions of comctl32.dll send ANSI messages even to the
2137 case LVN_BEGINLABELEDITA
:
2138 case LVN_BEGINLABELEDITW
:
2141 if ( nmhdr
->code
== LVN_BEGINLABELEDITA
)
2143 item
.Init(((LV_DISPINFOA
*)lParam
)->item
);
2145 else // LVN_BEGINLABELEDITW
2147 item
.Init(((LV_DISPINFOW
*)lParam
)->item
);
2150 eventType
= wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT
;
2151 wxConvertFromMSWListItem(GetHwnd(), event
.m_item
, item
);
2152 event
.m_itemIndex
= event
.m_item
.m_itemId
;
2156 case LVN_ENDLABELEDITA
:
2157 case LVN_ENDLABELEDITW
:
2160 if ( nmhdr
->code
== LVN_ENDLABELEDITA
)
2162 item
.Init(((LV_DISPINFOA
*)lParam
)->item
);
2164 else // LVN_ENDLABELEDITW
2166 item
.Init(((LV_DISPINFOW
*)lParam
)->item
);
2169 // was editing cancelled?
2170 const LV_ITEM
& lvi
= (LV_ITEM
)item
;
2171 if ( !lvi
.pszText
|| lvi
.iItem
== -1 )
2173 // EDIT control will be deleted by the list control
2174 // itself so prevent us from deleting it as well
2175 DeleteEditControl();
2177 event
.SetEditCanceled(true);
2180 eventType
= wxEVT_COMMAND_LIST_END_LABEL_EDIT
;
2181 wxConvertFromMSWListItem(NULL
, event
.m_item
, item
);
2182 event
.m_itemIndex
= event
.m_item
.m_itemId
;
2186 case LVN_COLUMNCLICK
:
2187 eventType
= wxEVT_COMMAND_LIST_COL_CLICK
;
2188 event
.m_itemIndex
= -1;
2189 event
.m_col
= nmLV
->iSubItem
;
2192 case LVN_DELETEALLITEMS
:
2193 eventType
= wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS
;
2194 event
.m_itemIndex
= -1;
2197 case LVN_DELETEITEM
:
2200 // this should be prevented by the post-processing code
2201 // below, but "just in case"
2205 eventType
= wxEVT_COMMAND_LIST_DELETE_ITEM
;
2206 event
.m_itemIndex
= iItem
;
2208 // delete the associated internal data
2209 if ( wxMSWListItemData
*data
= MSWGetItemData(iItem
) )
2211 const unsigned count
= m_internalData
.size();
2212 for ( unsigned n
= 0; n
< count
; n
++ )
2214 if ( m_internalData
[n
] == data
)
2216 m_internalData
.erase(m_internalData
.begin() + n
);
2223 wxASSERT_MSG( !data
, "invalid internal data pointer?" );
2227 case LVN_INSERTITEM
:
2228 eventType
= wxEVT_COMMAND_LIST_INSERT_ITEM
;
2229 event
.m_itemIndex
= iItem
;
2232 case LVN_ITEMCHANGED
:
2233 // we translate this catch all message into more interesting
2234 // (and more easy to process) wxWidgets events
2236 // first of all, we deal with the state change events only and
2237 // only for valid items (item == -1 for the virtual list
2239 if ( nmLV
->uChanged
& LVIF_STATE
&& iItem
!= -1 )
2241 // temp vars for readability
2242 const UINT stOld
= nmLV
->uOldState
;
2243 const UINT stNew
= nmLV
->uNewState
;
2245 event
.m_item
.SetId(iItem
);
2246 event
.m_item
.SetMask(wxLIST_MASK_TEXT
|
2249 GetItem(event
.m_item
);
2251 // has the focus changed?
2252 if ( !(stOld
& LVIS_FOCUSED
) && (stNew
& LVIS_FOCUSED
) )
2254 eventType
= wxEVT_COMMAND_LIST_ITEM_FOCUSED
;
2255 event
.m_itemIndex
= iItem
;
2258 if ( (stNew
& LVIS_SELECTED
) != (stOld
& LVIS_SELECTED
) )
2260 if ( eventType
!= wxEVT_NULL
)
2262 // focus and selection have both changed: send the
2263 // focus event from here and the selection one
2265 event
.SetEventType(eventType
);
2266 (void)HandleWindowEvent(event
);
2268 else // no focus event to send
2270 // then need to set m_itemIndex as it wasn't done
2272 event
.m_itemIndex
= iItem
;
2275 eventType
= stNew
& LVIS_SELECTED
2276 ? wxEVT_COMMAND_LIST_ITEM_SELECTED
2277 : wxEVT_COMMAND_LIST_ITEM_DESELECTED
;
2281 if ( eventType
== wxEVT_NULL
)
2283 // not an interesting event for us
2291 LV_KEYDOWN
*info
= (LV_KEYDOWN
*)lParam
;
2292 WORD wVKey
= info
->wVKey
;
2294 // get the current selection
2295 long lItem
= GetNextItem(-1,
2297 wxLIST_STATE_SELECTED
);
2299 // <Enter> or <Space> activate the selected item if any (but
2300 // not with any modifiers as they have a predefined meaning
2303 (wVKey
== VK_RETURN
|| wVKey
== VK_SPACE
) &&
2304 !wxIsAnyModifierDown() )
2306 eventType
= wxEVT_COMMAND_LIST_ITEM_ACTIVATED
;
2310 eventType
= wxEVT_COMMAND_LIST_KEY_DOWN
;
2312 // wxCharCodeMSWToWX() returns 0 if the key is an ASCII
2313 // value which should be used as is
2314 int code
= wxCharCodeMSWToWX(wVKey
);
2315 event
.m_code
= code
? code
: wVKey
;
2319 event
.m_item
.m_itemId
= lItem
;
2323 // fill the other fields too
2324 event
.m_item
.m_text
= GetItemText(lItem
);
2325 event
.m_item
.m_data
= GetItemData(lItem
);
2331 // if the user processes it in wxEVT_COMMAND_LEFT_CLICK(), don't do
2333 if ( wxControl::MSWOnNotify(idCtrl
, lParam
, result
) )
2338 // else translate it into wxEVT_COMMAND_LIST_ITEM_ACTIVATED event
2339 // if it happened on an item (and not on empty place)
2346 eventType
= wxEVT_COMMAND_LIST_ITEM_ACTIVATED
;
2347 event
.m_itemIndex
= iItem
;
2348 event
.m_item
.m_text
= GetItemText(iItem
);
2349 event
.m_item
.m_data
= GetItemData(iItem
);
2352 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
2353 case GN_CONTEXTMENU
:
2354 #endif //__WXWINCE__
2356 // if the user processes it in wxEVT_COMMAND_RIGHT_CLICK(),
2357 // don't do anything else
2358 if ( wxControl::MSWOnNotify(idCtrl
, lParam
, result
) )
2363 // else translate it into wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK event
2364 LV_HITTESTINFO lvhti
;
2365 wxZeroMemory(lvhti
);
2367 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
2368 if ( nmhdr
->code
== GN_CONTEXTMENU
)
2370 lvhti
.pt
= ((NMRGINFO
*)nmhdr
)->ptAction
;
2373 #endif //__WXWINCE__
2375 ::GetCursorPos(&(lvhti
.pt
));
2378 ::ScreenToClient(GetHwnd(), &lvhti
.pt
);
2379 if ( ListView_HitTest(GetHwnd(), &lvhti
) != -1 )
2381 if ( lvhti
.flags
& LVHT_ONITEM
)
2383 eventType
= wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
;
2384 event
.m_itemIndex
= lvhti
.iItem
;
2385 event
.m_pointDrag
.x
= lvhti
.pt
.x
;
2386 event
.m_pointDrag
.y
= lvhti
.pt
.y
;
2391 #ifdef NM_CUSTOMDRAW
2393 *result
= OnCustomDraw(lParam
);
2395 return *result
!= CDRF_DODEFAULT
;
2396 #endif // _WIN32_IE >= 0x300
2398 case LVN_ODCACHEHINT
:
2400 const NM_CACHEHINT
*cacheHint
= (NM_CACHEHINT
*)lParam
;
2402 eventType
= wxEVT_COMMAND_LIST_CACHE_HINT
;
2404 // we get some really stupid cache hints like ones for
2405 // items in range 0..0 for an empty control or, after
2406 // deleting an item, for items in invalid range -- filter
2408 if ( cacheHint
->iFrom
> cacheHint
->iTo
)
2411 event
.m_oldItemIndex
= cacheHint
->iFrom
;
2413 const long iMax
= GetItemCount();
2414 event
.m_itemIndex
= cacheHint
->iTo
< iMax
? cacheHint
->iTo
2419 #ifdef HAVE_NMLVFINDITEM
2420 case LVN_ODFINDITEM
:
2421 // this message is only used with the virtual list control but
2422 // even there we don't want to always use it: in a control with
2423 // sufficiently big number of items (defined as > 1000 here),
2424 // accidentally pressing a key could result in hanging an
2425 // application waiting while it performs linear search
2426 if ( IsVirtual() && GetItemCount() <= 1000 )
2428 NMLVFINDITEM
* pFindInfo
= (NMLVFINDITEM
*)lParam
;
2430 // no match by default
2433 // we only handle string-based searches here
2435 // TODO: what about LVFI_PARTIAL, should we handle this?
2436 if ( !(pFindInfo
->lvfi
.flags
& LVFI_STRING
) )
2441 const wxChar
* const searchstr
= pFindInfo
->lvfi
.psz
;
2442 const size_t len
= wxStrlen(searchstr
);
2444 // this is the first item we should examine, search from it
2445 // wrapping if necessary
2446 const int startPos
= pFindInfo
->iStart
;
2447 const int maxPos
= GetItemCount();
2448 wxCHECK_MSG( startPos
<= maxPos
, false,
2449 wxT("bad starting position in LVN_ODFINDITEM") );
2451 int currentPos
= startPos
;
2454 // wrap to the beginning if necessary
2455 if ( currentPos
== maxPos
)
2457 // somewhat surprizingly, LVFI_WRAP isn't set in
2458 // flags but we still should wrap
2462 // does this item begin with searchstr?
2463 if ( wxStrnicmp(searchstr
,
2464 GetItemText(currentPos
), len
) == 0 )
2466 *result
= currentPos
;
2470 while ( ++currentPos
!= startPos
);
2472 if ( *result
== -1 )
2478 SetItemState(*result
,
2479 wxLIST_STATE_SELECTED
| wxLIST_STATE_FOCUSED
,
2480 wxLIST_STATE_SELECTED
| wxLIST_STATE_FOCUSED
);
2481 EnsureVisible(*result
);
2489 #endif // HAVE_NMLVFINDITEM
2491 case LVN_GETDISPINFO
:
2494 LV_DISPINFO
*info
= (LV_DISPINFO
*)lParam
;
2496 LV_ITEM
& lvi
= info
->item
;
2497 long item
= lvi
.iItem
;
2499 if ( lvi
.mask
& LVIF_TEXT
)
2501 wxString text
= OnGetItemText(item
, lvi
.iSubItem
);
2502 wxStrlcpy(lvi
.pszText
, text
.c_str(), lvi
.cchTextMax
);
2505 // see comment at the end of wxListCtrl::GetColumn()
2506 #ifdef NM_CUSTOMDRAW
2507 if ( lvi
.mask
& LVIF_IMAGE
)
2509 lvi
.iImage
= OnGetItemColumnImage(item
, lvi
.iSubItem
);
2511 #endif // NM_CUSTOMDRAW
2513 // even though we never use LVM_SETCALLBACKMASK, we still
2514 // can get messages with LVIF_STATE in lvi.mask under Vista
2515 if ( lvi
.mask
& LVIF_STATE
)
2517 // we don't have anything to return from here...
2530 return wxControl::MSWOnNotify(idCtrl
, lParam
, result
);
2534 // where did this one come from?
2538 // process the event
2539 // -----------------
2541 event
.SetEventType(eventType
);
2543 // fill in the item before passing it to the event handler if we do have a
2544 // valid item index and haven't filled it yet (e.g. for LVN_ITEMCHANGED)
2545 if ( event
.m_itemIndex
!= -1 && !event
.m_item
.GetMask() )
2547 wxListItem
& item
= event
.m_item
;
2549 item
.SetId(event
.m_itemIndex
);
2550 item
.SetMask(wxLIST_MASK_TEXT
| wxLIST_MASK_IMAGE
| wxLIST_MASK_DATA
);
2554 bool processed
= HandleWindowEvent(event
);
2558 switch ( nmhdr
->code
)
2560 case LVN_DELETEALLITEMS
:
2561 // always return true to suppress all additional LVN_DELETEITEM
2562 // notifications - this makes deleting all items from a list ctrl
2566 // also, we may free all user data now (couldn't do it before as
2567 // the user should have access to it in OnDeleteAllItems() handler)
2568 FreeAllInternalData();
2570 // the control is empty now, synchronize the cached number of items
2571 // with the real one
2575 case LVN_ENDLABELEDITA
:
2576 case LVN_ENDLABELEDITW
:
2577 // logic here is inverted compared to all the other messages
2578 *result
= event
.IsAllowed();
2580 // EDIT control will be deleted by the list control itself so
2581 // prevent us from deleting it as well
2582 DeleteEditControl();
2588 *result
= !event
.IsAllowed();
2593 // ----------------------------------------------------------------------------
2594 // custom draw stuff
2595 // ----------------------------------------------------------------------------
2597 // see comment at the end of wxListCtrl::GetColumn()
2598 #ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
2600 static RECT
GetCustomDrawnItemRect(const NMCUSTOMDRAW
& nmcd
)
2603 wxGetListCtrlItemRect(nmcd
.hdr
.hwndFrom
, nmcd
.dwItemSpec
, LVIR_BOUNDS
, rc
);
2606 wxGetListCtrlItemRect(nmcd
.hdr
.hwndFrom
, nmcd
.dwItemSpec
, LVIR_ICON
, rcIcon
);
2608 // exclude the icon part, neither the selection background nor focus rect
2610 rc
.left
= rcIcon
.right
;
2616 bool HandleSubItemPrepaint(LPNMLVCUSTOMDRAW pLVCD
, HFONT hfont
, int colCount
)
2618 NMCUSTOMDRAW
& nmcd
= pLVCD
->nmcd
;
2621 HWND hwndList
= nmcd
.hdr
.hwndFrom
;
2622 const int col
= pLVCD
->iSubItem
;
2623 const DWORD item
= nmcd
.dwItemSpec
;
2625 // the font must be valid, otherwise we wouldn't be painting the item at all
2626 SelectInHDC
selFont(hdc
, hfont
);
2628 // get the rectangle to paint
2629 int subitem
= colCount
? col
+ 1 : col
;
2631 wxGetListCtrlSubItemRect(hwndList
, item
, subitem
, LVIR_BOUNDS
, rc
);
2634 // get the image and text to draw
2638 it
.mask
= LVIF_TEXT
| LVIF_IMAGE
;
2642 it
.cchTextMax
= WXSIZEOF(text
);
2643 ListView_GetItem(hwndList
, &it
);
2645 HIMAGELIST himl
= ListView_GetImageList(hwndList
, LVSIL_SMALL
);
2646 if ( himl
&& ImageList_GetImageCount(himl
) )
2648 if ( it
.iImage
!= -1 )
2650 ImageList_Draw(himl
, it
.iImage
, hdc
, rc
.left
, rc
.top
,
2651 nmcd
.uItemState
& CDIS_SELECTED
? ILD_SELECTED
2655 // notice that even if this item doesn't have any image, the list
2656 // control still leaves space for the image in the first column if the
2657 // image list is not empty (presumably so that items with and without
2659 if ( it
.iImage
!= -1 || it
.iSubItem
== 0 )
2662 ImageList_GetIconSize(himl
, &wImage
, &hImage
);
2664 rc
.left
+= wImage
+ 2;
2668 ::SetBkMode(hdc
, TRANSPARENT
);
2670 UINT fmt
= DT_SINGLELINE
|
2673 #endif // __WXWINCE__
2678 wxZeroMemory(lvCol
);
2679 lvCol
.mask
= LVCF_FMT
;
2680 if ( ListView_GetColumn(hwndList
, col
, &lvCol
) )
2682 switch ( lvCol
.fmt
& LVCFMT_JUSTIFYMASK
)
2697 //else: failed to get alignment, assume it's DT_LEFT (default)
2699 DrawText(hdc
, text
, -1, &rc
, fmt
);
2704 static void HandleItemPostpaint(NMCUSTOMDRAW nmcd
)
2706 if ( nmcd
.uItemState
& CDIS_FOCUS
)
2708 RECT rc
= GetCustomDrawnItemRect(nmcd
);
2710 // don't use the provided HDC, it's in some strange state by now
2711 ::DrawFocusRect(WindowHDC(nmcd
.hdr
.hwndFrom
), &rc
);
2715 // pLVCD->clrText and clrTextBk should contain the colours to use
2716 static void HandleItemPaint(LPNMLVCUSTOMDRAW pLVCD
, HFONT hfont
)
2718 NMCUSTOMDRAW
& nmcd
= pLVCD
->nmcd
; // just a shortcut
2720 const HWND hwndList
= nmcd
.hdr
.hwndFrom
;
2721 const int item
= nmcd
.dwItemSpec
;
2723 // unfortunately we can't trust CDIS_SELECTED, it is often set even when
2724 // the item is not at all selected for some reason (comctl32 6), but we
2725 // also can't always trust ListView_GetItem() as it could return the old
2726 // item status if we're called just after the (de)selection, so remember
2727 // the last item to gain selection and also check for it here
2728 for ( int i
= -1;; )
2730 i
= ListView_GetNextItem(hwndList
, i
, LVNI_SELECTED
);
2733 nmcd
.uItemState
&= ~CDIS_SELECTED
;
2739 nmcd
.uItemState
|= CDIS_SELECTED
;
2744 // same thing for CDIS_FOCUS (except simpler as there is only one of them)
2746 // NB: cast is needed to work around the bug in mingw32 headers which don't
2747 // have it inside ListView_GetNextItem() itself (unlike SDK ones)
2748 if ( ::GetFocus() == hwndList
&&
2749 ListView_GetNextItem(
2750 hwndList
, static_cast<WPARAM
>(-1), LVNI_FOCUSED
) == item
)
2752 nmcd
.uItemState
|= CDIS_FOCUS
;
2756 nmcd
.uItemState
&= ~CDIS_FOCUS
;
2759 if ( nmcd
.uItemState
& CDIS_SELECTED
)
2761 int syscolFg
, syscolBg
;
2762 if ( ::GetFocus() == hwndList
)
2764 syscolFg
= COLOR_HIGHLIGHTTEXT
;
2765 syscolBg
= COLOR_HIGHLIGHT
;
2767 else // selected but unfocused
2769 syscolFg
= COLOR_WINDOWTEXT
;
2770 syscolBg
= COLOR_BTNFACE
;
2772 // don't grey out the icon in this case neither
2773 nmcd
.uItemState
&= ~CDIS_SELECTED
;
2776 pLVCD
->clrText
= ::GetSysColor(syscolFg
);
2777 pLVCD
->clrTextBk
= ::GetSysColor(syscolBg
);
2779 //else: not selected, use normal colours from pLVCD
2782 RECT rc
= GetCustomDrawnItemRect(nmcd
);
2784 ::SetTextColor(hdc
, pLVCD
->clrText
);
2785 ::FillRect(hdc
, &rc
, AutoHBRUSH(pLVCD
->clrTextBk
));
2787 // we could use CDRF_NOTIFYSUBITEMDRAW here but it results in weird repaint
2788 // problems so just draw everything except the focus rect from here instead
2789 const int colCount
= Header_GetItemCount(ListView_GetHeader(hwndList
));
2790 for ( int col
= 0; col
< colCount
; col
++ )
2792 pLVCD
->iSubItem
= col
;
2793 HandleSubItemPrepaint(pLVCD
, hfont
, colCount
);
2796 HandleItemPostpaint(nmcd
);
2799 static WXLPARAM
HandleItemPrepaint(wxListCtrl
*listctrl
,
2800 LPNMLVCUSTOMDRAW pLVCD
,
2801 wxListItemAttr
*attr
)
2805 // nothing to do for this item
2806 return CDRF_DODEFAULT
;
2810 // set the colours to use for text drawing
2811 pLVCD
->clrText
= attr
->HasTextColour()
2812 ? wxColourToRGB(attr
->GetTextColour())
2813 : wxColourToRGB(listctrl
->GetTextColour());
2814 pLVCD
->clrTextBk
= attr
->HasBackgroundColour()
2815 ? wxColourToRGB(attr
->GetBackgroundColour())
2816 : wxColourToRGB(listctrl
->GetBackgroundColour());
2818 // select the font if non default one is specified
2819 if ( attr
->HasFont() )
2821 wxFont font
= attr
->GetFont();
2822 if ( font
.GetEncoding() != wxFONTENCODING_SYSTEM
)
2824 // the standard control ignores the font encoding/charset, at least
2825 // with recent comctl32.dll versions (5 and 6, it uses to work with
2826 // 4.something) so we have to draw the item entirely ourselves in
2828 HandleItemPaint(pLVCD
, GetHfontOf(font
));
2829 return CDRF_SKIPDEFAULT
;
2832 ::SelectObject(pLVCD
->nmcd
.hdc
, GetHfontOf(font
));
2834 return CDRF_NEWFONT
;
2837 return CDRF_DODEFAULT
;
2840 WXLPARAM
wxListCtrl::OnCustomDraw(WXLPARAM lParam
)
2842 LPNMLVCUSTOMDRAW pLVCD
= (LPNMLVCUSTOMDRAW
)lParam
;
2843 NMCUSTOMDRAW
& nmcd
= pLVCD
->nmcd
;
2844 switch ( nmcd
.dwDrawStage
)
2847 // if we've got any items with non standard attributes,
2848 // notify us before painting each item
2850 // for virtual controls, always suppose that we have attributes as
2851 // there is no way to check for this
2852 if ( IsVirtual() || m_hasAnyAttr
)
2853 return CDRF_NOTIFYITEMDRAW
;
2856 case CDDS_ITEMPREPAINT
:
2857 // get a message for each subitem
2858 return CDRF_NOTIFYITEMDRAW
;
2860 case CDDS_SUBITEM
| CDDS_ITEMPREPAINT
:
2861 const int item
= nmcd
.dwItemSpec
;
2862 const int column
= pLVCD
->iSubItem
;
2864 // we get this message with item == 0 for an empty control, we
2865 // must ignore it as calling OnGetItemAttr() would be wrong
2866 if ( item
< 0 || item
>= GetItemCount() )
2869 if ( column
< 0 || column
>= GetColumnCount() )
2872 return HandleItemPrepaint(this, pLVCD
, DoGetItemColumnAttr(item
, column
));
2875 return CDRF_DODEFAULT
;
2878 #endif // NM_CUSTOMDRAW supported
2880 // Necessary for drawing hrules and vrules, if specified
2881 void wxListCtrl::OnPaint(wxPaintEvent
& event
)
2883 const int itemCount
= GetItemCount();
2884 const bool drawHRules
= HasFlag(wxLC_HRULES
);
2885 const bool drawVRules
= HasFlag(wxLC_VRULES
);
2887 if (!InReportView() || !(drawHRules
|| drawVRules
) || !itemCount
)
2895 wxControl::OnPaint(event
);
2897 // Reset the device origin since it may have been set
2898 dc
.SetDeviceOrigin(0, 0);
2900 wxPen
pen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT
));
2902 dc
.SetBrush(* wxTRANSPARENT_BRUSH
);
2904 wxSize clientSize
= GetClientSize();
2909 const long top
= GetTopItem();
2910 for ( int i
= top
; i
< top
+ GetCountPerPage() + 1; i
++ )
2912 if (GetItemRect(i
, itemRect
))
2914 int cy
= itemRect
.GetTop();
2915 if (i
!= 0) // Don't draw the first one
2917 dc
.DrawLine(0, cy
, clientSize
.x
, cy
);
2920 if (i
== itemCount
- 1)
2922 cy
= itemRect
.GetBottom();
2923 dc
.DrawLine(0, cy
, clientSize
.x
, cy
);
2932 wxRect firstItemRect
;
2933 GetItemRect(0, firstItemRect
);
2935 if (GetItemRect(itemCount
- 1, itemRect
))
2937 // this is a fix for bug 673394: erase the pixels which we would
2938 // otherwise leave on the screen
2939 static const int gap
= 2;
2940 dc
.SetPen(*wxTRANSPARENT_PEN
);
2941 dc
.SetBrush(wxBrush(GetBackgroundColour()));
2942 dc
.DrawRectangle(0, firstItemRect
.GetY() - gap
,
2943 clientSize
.GetWidth(), gap
);
2946 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
2948 const int numCols
= GetColumnCount();
2949 wxVector
<int> indexArray(numCols
);
2950 if ( !ListView_GetColumnOrderArray(GetHwnd(),
2954 wxFAIL_MSG( wxT("invalid column index array in OnPaint()") );
2958 int x
= itemRect
.GetX();
2959 for (int col
= 0; col
< numCols
; col
++)
2961 int colWidth
= GetColumnWidth(indexArray
[col
]);
2963 dc
.DrawLine(x
-1, firstItemRect
.GetY() - gap
,
2964 x
-1, itemRect
.GetBottom());
2971 wxListCtrl::MSWWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2977 // we should bypass our own WM_PRINT handling as we don't handle
2978 // PRF_CHILDREN flag, so leave it to the native control itself
2979 return MSWDefWindowProc(nMsg
, wParam
, lParam
);
2982 case WM_CONTEXTMENU
:
2983 // because this message is propagated upwards the child-parent
2984 // chain, we get it for the right clicks on the header window but
2985 // this is confusing in wx as right clicking there already
2986 // generates a separate wxEVT_COMMAND_LIST_COL_RIGHT_CLICK event
2987 // so just ignore them
2988 if ( (HWND
)wParam
== ListView_GetHeader(GetHwnd()) )
2993 return wxControl::MSWWindowProc(nMsg
, wParam
, lParam
);
2996 // ----------------------------------------------------------------------------
2997 // virtual list controls
2998 // ----------------------------------------------------------------------------
3000 wxString
wxListCtrl::OnGetItemText(long WXUNUSED(item
), long WXUNUSED(col
)) const
3002 // this is a pure virtual function, in fact - which is not really pure
3003 // because the controls which are not virtual don't need to implement it
3004 wxFAIL_MSG( wxT("wxListCtrl::OnGetItemText not supposed to be called") );
3006 return wxEmptyString
;
3009 int wxListCtrl::OnGetItemImage(long WXUNUSED(item
)) const
3011 wxCHECK_MSG(!GetImageList(wxIMAGE_LIST_SMALL
),
3013 wxT("List control has an image list, OnGetItemImage or OnGetItemColumnImage should be overridden."));
3017 int wxListCtrl::OnGetItemColumnImage(long item
, long column
) const
3020 return OnGetItemImage(item
);
3025 wxListItemAttr
*wxListCtrl::OnGetItemAttr(long WXUNUSED_UNLESS_DEBUG(item
)) const
3027 wxASSERT_MSG( item
>= 0 && item
< GetItemCount(),
3028 wxT("invalid item index in OnGetItemAttr()") );
3030 // no attributes by default
3034 wxListItemAttr
*wxListCtrl::DoGetItemColumnAttr(long item
, long column
) const
3037 return OnGetItemColumnAttr(item
, column
);
3039 wxMSWListItemData
* const data
= MSWGetItemData(item
);
3040 return data
? data
->attr
: NULL
;
3043 void wxListCtrl::SetItemCount(long count
)
3045 wxASSERT_MSG( IsVirtual(), wxT("this is for virtual controls only") );
3047 if ( !::SendMessage(GetHwnd(), LVM_SETITEMCOUNT
, (WPARAM
)count
,
3048 LVSICF_NOSCROLL
| LVSICF_NOINVALIDATEALL
) )
3050 wxLogLastError(wxT("ListView_SetItemCount"));
3053 wxASSERT_MSG( m_count
== ListView_GetItemCount(GetHwnd()),
3054 wxT("m_count should match ListView_GetItemCount"));
3057 void wxListCtrl::RefreshItem(long item
)
3059 RefreshItems(item
, item
);
3062 void wxListCtrl::RefreshItems(long itemFrom
, long itemTo
)
3064 ListView_RedrawItems(GetHwnd(), itemFrom
, itemTo
);
3067 // ----------------------------------------------------------------------------
3068 // wxWin <-> MSW items conversions
3069 // ----------------------------------------------------------------------------
3071 static void wxConvertFromMSWListItem(HWND hwndListCtrl
,
3075 wxMSWListItemData
*internaldata
=
3076 (wxMSWListItemData
*) lvItem
.lParam
;
3079 info
.m_data
= internaldata
->lParam
;
3083 info
.m_stateMask
= 0;
3084 info
.m_itemId
= lvItem
.iItem
;
3086 long oldMask
= lvItem
.mask
;
3088 bool needText
= false;
3089 if (hwndListCtrl
!= 0)
3091 if ( lvItem
.mask
& LVIF_TEXT
)
3098 lvItem
.pszText
= new wxChar
[513];
3099 lvItem
.cchTextMax
= 512;
3101 lvItem
.mask
|= LVIF_TEXT
| LVIF_IMAGE
| LVIF_PARAM
;
3102 ::SendMessage(hwndListCtrl
, LVM_GETITEM
, 0, (LPARAM
)& lvItem
);
3105 if ( lvItem
.mask
& LVIF_STATE
)
3107 info
.m_mask
|= wxLIST_MASK_STATE
;
3109 if ( lvItem
.stateMask
& LVIS_CUT
)
3111 info
.m_stateMask
|= wxLIST_STATE_CUT
;
3112 if ( lvItem
.state
& LVIS_CUT
)
3113 info
.m_state
|= wxLIST_STATE_CUT
;
3115 if ( lvItem
.stateMask
& LVIS_DROPHILITED
)
3117 info
.m_stateMask
|= wxLIST_STATE_DROPHILITED
;
3118 if ( lvItem
.state
& LVIS_DROPHILITED
)
3119 info
.m_state
|= wxLIST_STATE_DROPHILITED
;
3121 if ( lvItem
.stateMask
& LVIS_FOCUSED
)
3123 info
.m_stateMask
|= wxLIST_STATE_FOCUSED
;
3124 if ( lvItem
.state
& LVIS_FOCUSED
)
3125 info
.m_state
|= wxLIST_STATE_FOCUSED
;
3127 if ( lvItem
.stateMask
& LVIS_SELECTED
)
3129 info
.m_stateMask
|= wxLIST_STATE_SELECTED
;
3130 if ( lvItem
.state
& LVIS_SELECTED
)
3131 info
.m_state
|= wxLIST_STATE_SELECTED
;
3135 if ( lvItem
.mask
& LVIF_TEXT
)
3137 info
.m_mask
|= wxLIST_MASK_TEXT
;
3138 info
.m_text
= lvItem
.pszText
;
3140 if ( lvItem
.mask
& LVIF_IMAGE
)
3142 info
.m_mask
|= wxLIST_MASK_IMAGE
;
3143 info
.m_image
= lvItem
.iImage
;
3145 if ( lvItem
.mask
& LVIF_PARAM
)
3146 info
.m_mask
|= wxLIST_MASK_DATA
;
3147 if ( lvItem
.mask
& LVIF_DI_SETITEM
)
3148 info
.m_mask
|= wxLIST_SET_ITEM
;
3149 info
.m_col
= lvItem
.iSubItem
;
3154 delete[] lvItem
.pszText
;
3156 lvItem
.mask
= oldMask
;
3159 static void wxConvertToMSWFlags(long state
, long stateMask
, LV_ITEM
& lvItem
)
3161 if (stateMask
& wxLIST_STATE_CUT
)
3163 lvItem
.stateMask
|= LVIS_CUT
;
3164 if (state
& wxLIST_STATE_CUT
)
3165 lvItem
.state
|= LVIS_CUT
;
3167 if (stateMask
& wxLIST_STATE_DROPHILITED
)
3169 lvItem
.stateMask
|= LVIS_DROPHILITED
;
3170 if (state
& wxLIST_STATE_DROPHILITED
)
3171 lvItem
.state
|= LVIS_DROPHILITED
;
3173 if (stateMask
& wxLIST_STATE_FOCUSED
)
3175 lvItem
.stateMask
|= LVIS_FOCUSED
;
3176 if (state
& wxLIST_STATE_FOCUSED
)
3177 lvItem
.state
|= LVIS_FOCUSED
;
3179 if (stateMask
& wxLIST_STATE_SELECTED
)
3181 lvItem
.stateMask
|= LVIS_SELECTED
;
3182 if (state
& wxLIST_STATE_SELECTED
)
3183 lvItem
.state
|= LVIS_SELECTED
;
3187 static void wxConvertToMSWListItem(const wxListCtrl
*ctrl
,
3188 const wxListItem
& info
,
3191 if ( ctrl
->InReportView() )
3193 wxASSERT_MSG( 0 <= info
.m_col
&& info
.m_col
< ctrl
->GetColumnCount(),
3194 "wxListCtrl column index out of bounds" );
3196 else // not in report view
3198 wxASSERT_MSG( info
.m_col
== 0, "columns only exist in report view" );
3201 lvItem
.iItem
= (int) info
.m_itemId
;
3203 lvItem
.iImage
= info
.m_image
;
3204 lvItem
.stateMask
= 0;
3207 lvItem
.iSubItem
= info
.m_col
;
3209 if (info
.m_mask
& wxLIST_MASK_STATE
)
3211 lvItem
.mask
|= LVIF_STATE
;
3213 wxConvertToMSWFlags(info
.m_state
, info
.m_stateMask
, lvItem
);
3216 if (info
.m_mask
& wxLIST_MASK_TEXT
)
3218 lvItem
.mask
|= LVIF_TEXT
;
3219 if ( ctrl
->HasFlag(wxLC_USER_TEXT
) )
3221 lvItem
.pszText
= LPSTR_TEXTCALLBACK
;
3225 // pszText is not const, hence the cast
3226 lvItem
.pszText
= (wxChar
*)info
.m_text
.wx_str();
3227 if ( lvItem
.pszText
)
3228 lvItem
.cchTextMax
= info
.m_text
.length();
3230 lvItem
.cchTextMax
= 0;
3233 if (info
.m_mask
& wxLIST_MASK_IMAGE
)
3234 lvItem
.mask
|= LVIF_IMAGE
;
3237 static void wxConvertToMSWListCol(HWND hwndList
,
3239 const wxListItem
& item
,
3242 wxZeroMemory(lvCol
);
3244 if ( item
.m_mask
& wxLIST_MASK_TEXT
)
3246 lvCol
.mask
|= LVCF_TEXT
;
3247 lvCol
.pszText
= (wxChar
*)item
.m_text
.wx_str(); // cast is safe
3250 if ( item
.m_mask
& wxLIST_MASK_FORMAT
)
3252 lvCol
.mask
|= LVCF_FMT
;
3254 if ( item
.m_format
== wxLIST_FORMAT_LEFT
)
3255 lvCol
.fmt
= LVCFMT_LEFT
;
3256 else if ( item
.m_format
== wxLIST_FORMAT_RIGHT
)
3257 lvCol
.fmt
= LVCFMT_RIGHT
;
3258 else if ( item
.m_format
== wxLIST_FORMAT_CENTRE
)
3259 lvCol
.fmt
= LVCFMT_CENTER
;
3262 if ( item
.m_mask
& wxLIST_MASK_WIDTH
)
3264 lvCol
.mask
|= LVCF_WIDTH
;
3265 if ( item
.m_width
== wxLIST_AUTOSIZE
)
3266 lvCol
.cx
= LVSCW_AUTOSIZE
;
3267 else if ( item
.m_width
== wxLIST_AUTOSIZE_USEHEADER
)
3268 lvCol
.cx
= LVSCW_AUTOSIZE_USEHEADER
;
3270 lvCol
.cx
= item
.m_width
;
3273 // see comment at the end of wxListCtrl::GetColumn()
3274 #ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
3275 if ( item
.m_mask
& wxLIST_MASK_IMAGE
)
3277 if ( wxApp::GetComCtl32Version() >= 470 )
3279 lvCol
.mask
|= LVCF_IMAGE
;
3281 // we use LVCFMT_BITMAP_ON_RIGHT because the images on the right
3282 // seem to be generally nicer than on the left and the generic
3283 // version only draws them on the right (we don't have a flag to
3284 // specify the image location anyhow)
3286 // we don't use LVCFMT_COL_HAS_IMAGES because it doesn't seem to
3287 // make any difference in my tests -- but maybe we should?
3288 if ( item
.m_image
!= -1 )
3290 // as we're going to overwrite the format field, get its
3291 // current value first -- unless we want to overwrite it anyhow
3292 if ( !(lvCol
.mask
& LVCF_FMT
) )
3295 wxZeroMemory(lvColOld
);
3296 lvColOld
.mask
= LVCF_FMT
;
3297 if ( ListView_GetColumn(hwndList
, col
, &lvColOld
) )
3299 lvCol
.fmt
= lvColOld
.fmt
;
3302 lvCol
.mask
|= LVCF_FMT
;
3305 lvCol
.fmt
|= LVCFMT_BITMAP_ON_RIGHT
| LVCFMT_IMAGE
;
3308 lvCol
.iImage
= item
.m_image
;
3310 //else: it doesn't support item images anyhow
3312 #endif // _WIN32_IE >= 0x0300
3315 #endif // wxUSE_LISTCTRL