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
, _T("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 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 for the users data, e.g.
212 // class wxListItemInternalData
215 // wxListItemAttr *attr;
216 // long lParam; // user data
219 // To conserve memory, a wxListItemInternalData is
220 // only allocated for a LV_ITEM if text attributes or
221 // user data(lparam) are being set.
224 // class wxListItemInternalData
225 class wxListItemInternalData
228 wxListItemAttr
*attr
;
229 LPARAM lParam
; // user data
231 wxListItemInternalData() : attr(NULL
), lParam(0) {}
232 ~wxListItemInternalData()
238 wxDECLARE_NO_COPY_CLASS(wxListItemInternalData
);
241 // Get the internal data structure
242 static wxListItemInternalData
*wxGetInternalData(HWND hwnd
, long itemId
);
243 static wxListItemInternalData
*wxGetInternalData(const wxListCtrl
*ctl
, long itemId
);
244 static wxListItemAttr
*wxGetInternalDataAttr(const wxListCtrl
*ctl
, long itemId
);
245 static void wxDeleteInternalData(wxListCtrl
* ctl
, long itemId
);
248 #if wxUSE_EXTENDED_RTTI
249 WX_DEFINE_FLAGS( wxListCtrlStyle
)
251 wxBEGIN_FLAGS( wxListCtrlStyle
)
252 // new style border flags, we put them first to
253 // use them for streaming out
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
)
261 // old style border flags
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
)
267 wxFLAGS_MEMBER(wxBORDER
)
269 // standard window styles
270 wxFLAGS_MEMBER(wxTAB_TRAVERSAL
)
271 wxFLAGS_MEMBER(wxCLIP_CHILDREN
)
272 wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW
)
273 wxFLAGS_MEMBER(wxWANTS_CHARS
)
274 wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE
)
275 wxFLAGS_MEMBER(wxALWAYS_SHOW_SB
)
276 wxFLAGS_MEMBER(wxVSCROLL
)
277 wxFLAGS_MEMBER(wxHSCROLL
)
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
)
294 wxEND_FLAGS( wxListCtrlStyle
)
296 IMPLEMENT_DYNAMIC_CLASS_XTI(wxListCtrl
, wxControl
,"wx/listctrl.h")
298 wxBEGIN_PROPERTIES_TABLE(wxListCtrl
)
299 wxEVENT_PROPERTY( TextUpdated
, wxEVT_COMMAND_TEXT_UPDATED
, wxCommandEvent
)
301 wxPROPERTY_FLAGS( WindowStyle
, wxListCtrlStyle
, long , SetWindowStyleFlag
, GetWindowStyleFlag
, EMPTY_MACROVALUE
, 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
302 wxEND_PROPERTIES_TABLE()
304 wxBEGIN_HANDLERS_TABLE(wxListCtrl
)
305 wxEND_HANDLERS_TABLE()
307 wxCONSTRUCTOR_5( wxListCtrl
, wxWindow
* , Parent
, wxWindowID
, Id
, wxPoint
, Position
, wxSize
, Size
, long , WindowStyle
)
310 TODO : Expose more information of a list's layout etc. via appropriate objects (a la NotebookPageInfo)
313 IMPLEMENT_DYNAMIC_CLASS(wxListCtrl
, wxControl
)
316 IMPLEMENT_DYNAMIC_CLASS(wxListView
, wxListCtrl
)
317 IMPLEMENT_DYNAMIC_CLASS(wxListItem
, wxObject
)
319 IMPLEMENT_DYNAMIC_CLASS(wxListEvent
, wxNotifyEvent
)
321 BEGIN_EVENT_TABLE(wxListCtrl
, wxControl
)
322 EVT_PAINT(wxListCtrl::OnPaint
)
325 // ============================================================================
327 // ============================================================================
329 // ----------------------------------------------------------------------------
330 // wxListCtrl construction
331 // ----------------------------------------------------------------------------
333 void wxListCtrl::Init()
335 m_imageListNormal
= NULL
;
336 m_imageListSmall
= NULL
;
337 m_imageListState
= NULL
;
338 m_ownsImageListNormal
= m_ownsImageListSmall
= m_ownsImageListState
= false;
341 m_ignoreChangeMessages
= false;
343 m_AnyInternalData
= false;
344 m_hasAnyAttr
= false;
347 bool wxListCtrl::Create(wxWindow
*parent
,
352 const wxValidator
& validator
,
353 const wxString
& name
)
355 if ( !CreateControl(parent
, id
, pos
, size
, style
, validator
, name
) )
358 if ( !MSWCreateControl(WC_LISTVIEW
, wxEmptyString
, pos
, size
) )
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
363 wxSetCCUnicodeFormat(GetHwnd());
365 // We must set the default text colour to the system/theme color, otherwise
366 // GetTextColour will always return black
367 SetTextColour(GetDefaultAttributes().colFg
);
369 if ( InReportView() )
370 MSWSetExListStyles();
375 void wxListCtrl::MSWSetExListStyles()
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)
379 if ( wxApp::GetComCtl32Version() >= 470 )
383 GetHwnd(), LVM_SETEXTENDEDLISTVIEWSTYLE
, 0,
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
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
399 WXDWORD
wxListCtrl::MSWGetStyle(long style
, WXDWORD
*exstyle
) const
401 WXDWORD wstyle
= wxControl::MSWGetStyle(style
, exstyle
);
403 wstyle
|= LVS_SHAREIMAGELISTS
| LVS_SHOWSELALWAYS
;
408 #define MAP_MODE_STYLE(wx, ms) \
409 if ( style & (wx) ) { wstyle |= (ms); nModes++; }
410 #else // !wxDEBUG_LEVEL
411 #define MAP_MODE_STYLE(wx, ms) \
412 if ( style & (wx) ) wstyle |= (ms);
413 #endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
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
)
420 wxASSERT_MSG( nModes
== 1,
421 _T("wxListCtrl style should have exactly one mode bit set") );
423 #undef MAP_MODE_STYLE
425 if ( style
& wxLC_ALIGN_LEFT
)
426 wstyle
|= LVS_ALIGNLEFT
;
428 if ( style
& wxLC_ALIGN_TOP
)
429 wstyle
|= LVS_ALIGNTOP
;
431 if ( style
& wxLC_AUTOARRANGE
)
432 wstyle
|= LVS_AUTOARRANGE
;
434 if ( style
& wxLC_NO_SORT_HEADER
)
435 wstyle
|= LVS_NOSORTHEADER
;
437 if ( style
& wxLC_NO_HEADER
)
438 wstyle
|= LVS_NOCOLUMNHEADER
;
440 if ( style
& wxLC_EDIT_LABELS
)
441 wstyle
|= LVS_EDITLABELS
;
443 if ( style
& wxLC_SINGLE_SEL
)
444 wstyle
|= LVS_SINGLESEL
;
446 if ( style
& wxLC_SORT_ASCENDING
)
448 wstyle
|= LVS_SORTASCENDING
;
450 wxASSERT_MSG( !(style
& wxLC_SORT_DESCENDING
),
451 _T("can't sort in ascending and descending orders at once") );
453 else if ( style
& wxLC_SORT_DESCENDING
)
454 wstyle
|= LVS_SORTDESCENDING
;
456 #if !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )
457 if ( style
& wxLC_VIRTUAL
)
459 int ver
= wxApp::GetComCtl32Version();
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);
466 wstyle
|= LVS_OWNERDATA
;
468 #endif // ancient cygwin
473 void wxListCtrl::UpdateStyle()
477 // The new window view style
478 DWORD dwStyleNew
= MSWGetStyle(m_windowStyle
, NULL
);
480 // some styles are not returned by MSWGetStyle()
482 dwStyleNew
|= WS_VISIBLE
;
484 // Get the current window style.
485 DWORD dwStyleOld
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
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
);
491 // Only set the window style if the view bits have changed.
492 if ( dwStyleOld
!= dwStyleNew
)
494 ::SetWindowLong(GetHwnd(), GWL_STYLE
, dwStyleNew
);
496 // if we switched to the report view, set the extended styles for
498 if ( !(dwStyleOld
& LVS_REPORT
) && (dwStyleNew
& LVS_REPORT
) )
499 MSWSetExListStyles();
504 void wxListCtrl::FreeAllInternalData()
506 if (m_AnyInternalData
)
508 int n
= GetItemCount();
510 m_ignoreChangeMessages
= true;
511 for (int i
= 0; i
< n
; i
++)
512 wxDeleteInternalData(this, i
);
513 m_ignoreChangeMessages
= false;
515 m_AnyInternalData
= false;
519 void wxListCtrl::DeleteEditControl()
523 m_textCtrl
->UnsubclassWin();
524 m_textCtrl
->SetHWND(0);
530 wxListCtrl::~wxListCtrl()
532 FreeAllInternalData();
536 if (m_ownsImageListNormal
)
537 delete m_imageListNormal
;
538 if (m_ownsImageListSmall
)
539 delete m_imageListSmall
;
540 if (m_ownsImageListState
)
541 delete m_imageListState
;
544 // ----------------------------------------------------------------------------
545 // set/get/change style
546 // ----------------------------------------------------------------------------
548 // Add or remove a single window style
549 void wxListCtrl::SetSingleStyle(long style
, bool add
)
551 long flag
= GetWindowStyleFlag();
553 // Get rid of conflicting styles
556 if ( style
& wxLC_MASK_TYPE
)
557 flag
= flag
& ~wxLC_MASK_TYPE
;
558 if ( style
& wxLC_MASK_ALIGN
)
559 flag
= flag
& ~wxLC_MASK_ALIGN
;
560 if ( style
& wxLC_MASK_SORT
)
561 flag
= flag
& ~wxLC_MASK_SORT
;
569 SetWindowStyleFlag(flag
);
572 // Set the whole window style
573 void wxListCtrl::SetWindowStyleFlag(long flag
)
575 if ( flag
!= m_windowStyle
)
577 wxControl::SetWindowStyleFlag(flag
);
585 // ----------------------------------------------------------------------------
587 // ----------------------------------------------------------------------------
589 /* static */ wxVisualAttributes
590 wxListCtrl::GetClassDefaultAttributes(wxWindowVariant variant
)
592 wxVisualAttributes attrs
= GetCompositeControlsDefaultAttributes(variant
);
594 // common controls have their own default font
595 attrs
.font
= wxGetCCDefaultFont();
600 // Sets the foreground, i.e. text, colour
601 bool wxListCtrl::SetForegroundColour(const wxColour
& col
)
603 if ( !wxWindow::SetForegroundColour(col
) )
606 ListView_SetTextColor(GetHwnd(), wxColourToRGB(col
));
611 // Sets the background colour
612 bool wxListCtrl::SetBackgroundColour(const wxColour
& col
)
614 if ( !wxWindow::SetBackgroundColour(col
) )
617 // we set the same colour for both the "empty" background and the items
619 COLORREF color
= wxColourToRGB(col
);
620 ListView_SetBkColor(GetHwnd(), color
);
621 ListView_SetTextBkColor(GetHwnd(), color
);
626 // Gets information about this column
627 bool wxListCtrl::GetColumn(int col
, wxListItem
& item
) const
632 lvCol
.mask
= LVCF_WIDTH
;
634 if ( item
.m_mask
& wxLIST_MASK_TEXT
)
636 lvCol
.mask
|= LVCF_TEXT
;
637 lvCol
.pszText
= new wxChar
[513];
638 lvCol
.cchTextMax
= 512;
641 if ( item
.m_mask
& wxLIST_MASK_FORMAT
)
643 lvCol
.mask
|= LVCF_FMT
;
646 if ( item
.m_mask
& wxLIST_MASK_IMAGE
)
648 lvCol
.mask
|= LVCF_IMAGE
;
651 bool success
= ListView_GetColumn(GetHwnd(), col
, &lvCol
) != 0;
653 // item.m_subItem = lvCol.iSubItem;
654 item
.m_width
= lvCol
.cx
;
656 if ( (item
.m_mask
& wxLIST_MASK_TEXT
) && lvCol
.pszText
)
658 item
.m_text
= lvCol
.pszText
;
659 delete[] lvCol
.pszText
;
662 if ( item
.m_mask
& wxLIST_MASK_FORMAT
)
664 switch (lvCol
.fmt
& LVCFMT_JUSTIFYMASK
) {
666 item
.m_format
= wxLIST_FORMAT_LEFT
;
669 item
.m_format
= wxLIST_FORMAT_RIGHT
;
672 item
.m_format
= wxLIST_FORMAT_CENTRE
;
675 item
.m_format
= -1; // Unknown?
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
685 if ( item
.m_mask
& wxLIST_MASK_IMAGE
)
687 item
.m_image
= lvCol
.iImage
;
689 #endif // LVCOLUMN::iImage exists
694 // Sets information about this column
695 bool wxListCtrl::SetColumn(int col
, const wxListItem
& item
)
698 wxConvertToMSWListCol(GetHwnd(), col
, item
, lvCol
);
700 return ListView_SetColumn(GetHwnd(), col
, &lvCol
) != 0;
703 // Gets the column width
704 int wxListCtrl::GetColumnWidth(int col
) const
706 return ListView_GetColumnWidth(GetHwnd(), col
);
709 // Sets the column width
710 bool wxListCtrl::SetColumnWidth(int col
, int width
)
712 if ( m_windowStyle
& wxLC_LIST
)
715 if ( width
== wxLIST_AUTOSIZE
)
716 width
= LVSCW_AUTOSIZE
;
717 else if ( width
== wxLIST_AUTOSIZE_USEHEADER
)
718 width
= LVSCW_AUTOSIZE_USEHEADER
;
720 return ListView_SetColumnWidth(GetHwnd(), col
, width
) != 0;
723 // ----------------------------------------------------------------------------
725 // ----------------------------------------------------------------------------
727 int wxListCtrl::GetColumnIndexFromOrder(int order
) const
729 const int numCols
= GetColumnCount();
730 wxCHECK_MSG( order
>= 0 && order
< numCols
, -1,
731 _T("Column position out of bounds") );
733 wxArrayInt
indexArray(numCols
);
734 if ( !ListView_GetColumnOrderArray(GetHwnd(), numCols
, &indexArray
[0]) )
737 return indexArray
[order
];
740 int wxListCtrl::GetColumnOrder(int col
) const
742 const int numCols
= GetColumnCount();
743 wxASSERT_MSG( col
>= 0 && col
< numCols
, _T("Column index out of bounds") );
745 wxArrayInt
indexArray(numCols
);
746 if ( !ListView_GetColumnOrderArray(GetHwnd(), numCols
, &indexArray
[0]) )
749 for ( int pos
= 0; pos
< numCols
; pos
++ )
751 if ( indexArray
[pos
] == col
)
755 wxFAIL_MSG( _T("no column with with given order?") );
760 // Gets the column order for all columns
761 wxArrayInt
wxListCtrl::GetColumnsOrder() const
763 const int numCols
= GetColumnCount();
765 wxArrayInt
orders(numCols
);
766 if ( !ListView_GetColumnOrderArray(GetHwnd(), numCols
, &orders
[0]) )
772 // Sets the column order for all columns
773 bool wxListCtrl::SetColumnsOrder(const wxArrayInt
& orders
)
775 const int numCols
= GetColumnCount();
777 wxCHECK_MSG( orders
.size() == (size_t)numCols
, false,
778 _T("wrong number of elements in column orders array") );
780 return ListView_SetColumnOrderArray(GetHwnd(), numCols
, &orders
[0]) != 0;
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)
788 int wxListCtrl::GetCountPerPage() const
790 return ListView_GetCountPerPage(GetHwnd());
793 // Gets the edit control for editing labels.
794 wxTextCtrl
* wxListCtrl::GetEditControl() const
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() )
804 HWND hwndEdit
= ListView_GetEditControl(GetHwnd());
807 wxListCtrl
* const self
= const_cast<wxListCtrl
*>(this);
810 self
->m_textCtrl
= new wxTextCtrl
;
811 self
->InitEditControl((WXHWND
)hwndEdit
);
818 // Gets information about the item
819 bool wxListCtrl::GetItem(wxListItem
& info
) const
822 wxZeroMemory(lvItem
);
824 lvItem
.iItem
= info
.m_itemId
;
825 lvItem
.iSubItem
= info
.m_col
;
827 if ( info
.m_mask
& wxLIST_MASK_TEXT
)
829 lvItem
.mask
|= LVIF_TEXT
;
830 lvItem
.pszText
= new wxChar
[513];
831 lvItem
.cchTextMax
= 512;
835 lvItem
.pszText
= NULL
;
838 if (info
.m_mask
& wxLIST_MASK_DATA
)
839 lvItem
.mask
|= LVIF_PARAM
;
841 if (info
.m_mask
& wxLIST_MASK_IMAGE
)
842 lvItem
.mask
|= LVIF_IMAGE
;
844 if ( info
.m_mask
& wxLIST_MASK_STATE
)
846 lvItem
.mask
|= LVIF_STATE
;
847 wxConvertToMSWFlags(0, info
.m_stateMask
, lvItem
);
850 bool success
= ListView_GetItem((HWND
)GetHWND(), &lvItem
) != 0;
853 wxLogError(_("Couldn't retrieve information about list control item %d."),
858 // give NULL as hwnd as we already have everything we need
859 wxConvertFromMSWListItem(NULL
, info
, lvItem
);
863 delete[] lvItem
.pszText
;
868 // Sets information about the item
869 bool wxListCtrl::SetItem(wxListItem
& info
)
871 const long id
= info
.GetId();
872 wxCHECK_MSG( id
>= 0 && id
< GetItemCount(), false,
873 _T("invalid item index in SetItem") );
876 wxConvertToMSWListItem(this, info
, item
);
878 // we never update the lParam if it contains our pointer
879 // to the wxListItemInternalData structure
880 item
.mask
&= ~LVIF_PARAM
;
882 // check if setting attributes or lParam
883 if (info
.HasAttributes() || (info
.m_mask
& wxLIST_MASK_DATA
))
885 // get internal item data
886 // perhaps a cache here ?
887 wxListItemInternalData
*data
= wxGetInternalData(this, id
);
892 m_AnyInternalData
= true;
893 data
= new wxListItemInternalData();
894 item
.lParam
= (LPARAM
) data
;
895 item
.mask
|= LVIF_PARAM
;
900 if (info
.m_mask
& wxLIST_MASK_DATA
)
901 data
->lParam
= info
.m_data
;
904 if ( info
.HasAttributes() )
906 const wxListItemAttr
& attrNew
= *info
.GetAttributes();
908 // don't overwrite the already set attributes if we have them
910 data
->attr
->AssignFrom(attrNew
);
912 data
->attr
= new wxListItemAttr(attrNew
);
917 // we could be changing only the attribute in which case we don't need to
918 // call ListView_SetItem() at all
921 if ( !ListView_SetItem(GetHwnd(), &item
) )
923 wxLogDebug(_T("ListView_SetItem() failed"));
929 // we need to update the item immediately to show the new image
930 bool updateNow
= (info
.m_mask
& wxLIST_MASK_IMAGE
) != 0;
932 // check whether it has any custom attributes
933 if ( info
.HasAttributes() )
937 // if the colour has changed, we must redraw the item
943 // we need this to make the change visible right now
944 RefreshItem(item
.iItem
);
950 long wxListCtrl::SetItem(long index
, int col
, const wxString
& label
, int imageId
)
954 info
.m_mask
= wxLIST_MASK_TEXT
;
955 info
.m_itemId
= index
;
959 info
.m_image
= imageId
;
960 info
.m_mask
|= wxLIST_MASK_IMAGE
;
962 return SetItem(info
);
966 // Gets the item state
967 int wxListCtrl::GetItemState(long item
, long stateMask
) const
971 info
.m_mask
= wxLIST_MASK_STATE
;
972 info
.m_stateMask
= stateMask
;
973 info
.m_itemId
= item
;
981 // Sets the item state
982 bool wxListCtrl::SetItemState(long item
, long state
, long stateMask
)
984 // NB: don't use SetItem() here as it doesn't work with the virtual list
987 wxZeroMemory(lvItem
);
989 wxConvertToMSWFlags(state
, stateMask
, lvItem
);
991 const bool changingFocus
= (stateMask
& wxLIST_STATE_FOCUSED
) &&
992 (state
& wxLIST_STATE_FOCUSED
);
994 // for the virtual list controls we need to refresh the previously focused
995 // item manually when changing focus without changing selection
996 // programmatically because otherwise it keeps its focus rectangle until
997 // next repaint (yet another comctl32 bug)
999 if ( IsVirtual() && changingFocus
)
1001 focusOld
= GetNextItem(-1, wxLIST_NEXT_ALL
, wxLIST_STATE_FOCUSED
);
1008 if ( !::SendMessage(GetHwnd(), LVM_SETITEMSTATE
,
1009 (WPARAM
)item
, (LPARAM
)&lvItem
) )
1011 wxLogLastError(_T("ListView_SetItemState"));
1016 if ( focusOld
!= -1 )
1018 // no need to refresh the item if it was previously selected, it would
1019 // only result in annoying flicker
1020 if ( !(GetItemState(focusOld
,
1021 wxLIST_STATE_SELECTED
) & wxLIST_STATE_SELECTED
) )
1023 RefreshItem(focusOld
);
1027 // we expect the selection anchor, i.e. the item from which multiple
1028 // selection (such as performed with e.g. Shift-arrows) starts, to be the
1029 // same as the currently focused item but the native control doesn't update
1030 // it when we change focus and leaves at the last item it set itself focus
1031 // to, so do it explicitly
1032 if ( changingFocus
&& !HasFlag(wxLC_SINGLE_SEL
) )
1034 ListView_SetSelectionMark(GetHwnd(), item
);
1040 // Sets the item image
1041 bool wxListCtrl::SetItemImage(long item
, int image
, int WXUNUSED(selImage
))
1043 return SetItemColumnImage(item
, 0, image
);
1046 // Sets the item image
1047 bool wxListCtrl::SetItemColumnImage(long item
, long column
, int image
)
1051 info
.m_mask
= wxLIST_MASK_IMAGE
;
1052 info
.m_image
= image
;
1053 info
.m_itemId
= item
;
1054 info
.m_col
= column
;
1056 return SetItem(info
);
1059 // Gets the item text
1060 wxString
wxListCtrl::GetItemText(long item
) const
1064 info
.m_mask
= wxLIST_MASK_TEXT
;
1065 info
.m_itemId
= item
;
1068 return wxEmptyString
;
1072 // Sets the item text
1073 void wxListCtrl::SetItemText(long item
, const wxString
& str
)
1077 info
.m_mask
= wxLIST_MASK_TEXT
;
1078 info
.m_itemId
= item
;
1084 // Gets the item data
1085 wxUIntPtr
wxListCtrl::GetItemData(long item
) const
1089 info
.m_mask
= wxLIST_MASK_DATA
;
1090 info
.m_itemId
= item
;
1097 // Sets the item data
1098 bool wxListCtrl::SetItemPtrData(long item
, wxUIntPtr data
)
1102 info
.m_mask
= wxLIST_MASK_DATA
;
1103 info
.m_itemId
= item
;
1106 return SetItem(info
);
1109 wxRect
wxListCtrl::GetViewRect() const
1113 // ListView_GetViewRect() can only be used in icon and small icon views
1114 // (this is documented in MSDN and, indeed, it returns bogus results in
1115 // report view, at least with comctl32.dll v6 under Windows 2003)
1116 if ( HasFlag(wxLC_ICON
| wxLC_SMALL_ICON
) )
1119 if ( !ListView_GetViewRect(GetHwnd(), &rc
) )
1121 wxLogDebug(_T("ListView_GetViewRect() failed."));
1126 wxCopyRECTToRect(rc
, rect
);
1128 else if ( HasFlag(wxLC_REPORT
) )
1130 const long count
= GetItemCount();
1133 GetItemRect(wxMin(GetTopItem() + GetCountPerPage(), count
- 1), rect
);
1135 // extend the rectangle to start at the top (we include the column
1136 // headers, if any, for compatibility with the generic version)
1137 rect
.height
+= rect
.y
;
1143 wxFAIL_MSG( _T("not implemented in this mode") );
1149 // Gets the item rectangle
1150 bool wxListCtrl::GetItemRect(long item
, wxRect
& rect
, int code
) const
1152 return GetSubItemRect( item
, wxLIST_GETSUBITEMRECT_WHOLEITEM
, rect
, code
) ;
1155 bool wxListCtrl::GetSubItemRect(long item
, long subItem
, wxRect
& rect
, int code
) const
1157 // ListView_GetSubItemRect() doesn't do subItem error checking and returns
1158 // true even for the out of range values of it (even if the results are
1159 // completely bogus in this case), so we check item validity ourselves
1160 wxCHECK_MSG( subItem
== wxLIST_GETSUBITEMRECT_WHOLEITEM
||
1161 (subItem
>= 0 && subItem
< GetColumnCount()),
1162 false, _T("invalid sub item index") );
1164 // use wxCHECK_MSG against "item" too, for coherency with the generic implementation:
1165 wxCHECK_MSG( item
>= 0 && item
< GetItemCount(), false,
1166 _T("invalid item in GetSubItemRect") );
1169 if ( code
== wxLIST_RECT_BOUNDS
)
1170 codeWin
= LVIR_BOUNDS
;
1171 else if ( code
== wxLIST_RECT_ICON
)
1172 codeWin
= LVIR_ICON
;
1173 else if ( code
== wxLIST_RECT_LABEL
)
1174 codeWin
= LVIR_LABEL
;
1177 wxFAIL_MSG( _T("incorrect code in GetItemRect() / GetSubItemRect()") );
1178 codeWin
= LVIR_BOUNDS
;
1182 if ( !wxGetListCtrlSubItemRect
1186 subItem
== wxLIST_GETSUBITEMRECT_WHOLEITEM
? 0 : subItem
,
1194 wxCopyRECTToRect(rectWin
, rect
);
1196 // there is no way to retrieve the first sub item bounding rectangle using
1197 // wxGetListCtrlSubItemRect() as 0 means the whole item, so we need to
1198 // truncate it at first column ourselves
1200 rect
.width
= GetColumnWidth(0);
1208 // Gets the item position
1209 bool wxListCtrl::GetItemPosition(long item
, wxPoint
& pos
) const
1213 bool success
= (ListView_GetItemPosition(GetHwnd(), (int) item
, &pt
) != 0);
1215 pos
.x
= pt
.x
; pos
.y
= pt
.y
;
1219 // Sets the item position.
1220 bool wxListCtrl::SetItemPosition(long item
, const wxPoint
& pos
)
1222 return (ListView_SetItemPosition(GetHwnd(), (int) item
, pos
.x
, pos
.y
) != 0);
1225 // Gets the number of items in the list control
1226 int wxListCtrl::GetItemCount() const
1231 wxSize
wxListCtrl::GetItemSpacing() const
1233 const int spacing
= ListView_GetItemSpacing(GetHwnd(), (BOOL
)HasFlag(wxLC_SMALL_ICON
));
1235 return wxSize(LOWORD(spacing
), HIWORD(spacing
));
1238 #if WXWIN_COMPATIBILITY_2_6
1240 int wxListCtrl::GetItemSpacing(bool isSmall
) const
1242 return ListView_GetItemSpacing(GetHwnd(), (BOOL
) isSmall
);
1245 #endif // WXWIN_COMPATIBILITY_2_6
1247 void wxListCtrl::SetItemTextColour( long item
, const wxColour
&col
)
1250 info
.m_itemId
= item
;
1251 info
.SetTextColour( col
);
1255 wxColour
wxListCtrl::GetItemTextColour( long item
) const
1258 wxListItemInternalData
*data
= wxGetInternalData(this, item
);
1259 if ( data
&& data
->attr
)
1260 col
= data
->attr
->GetTextColour();
1265 void wxListCtrl::SetItemBackgroundColour( long item
, const wxColour
&col
)
1268 info
.m_itemId
= item
;
1269 info
.SetBackgroundColour( col
);
1273 wxColour
wxListCtrl::GetItemBackgroundColour( long item
) const
1276 wxListItemInternalData
*data
= wxGetInternalData(this, item
);
1277 if ( data
&& data
->attr
)
1278 col
= data
->attr
->GetBackgroundColour();
1283 void wxListCtrl::SetItemFont( long item
, const wxFont
&f
)
1286 info
.m_itemId
= item
;
1291 wxFont
wxListCtrl::GetItemFont( long item
) const
1294 wxListItemInternalData
*data
= wxGetInternalData(this, item
);
1295 if ( data
&& data
->attr
)
1296 f
= data
->attr
->GetFont();
1301 // Gets the number of selected items in the list control
1302 int wxListCtrl::GetSelectedItemCount() const
1304 return ListView_GetSelectedCount(GetHwnd());
1307 // Gets the text colour of the listview
1308 wxColour
wxListCtrl::GetTextColour() const
1310 COLORREF ref
= ListView_GetTextColor(GetHwnd());
1311 wxColour
col(GetRValue(ref
), GetGValue(ref
), GetBValue(ref
));
1315 // Sets the text colour of the listview
1316 void wxListCtrl::SetTextColour(const wxColour
& col
)
1318 ListView_SetTextColor(GetHwnd(), PALETTERGB(col
.Red(), col
.Green(), col
.Blue()));
1321 // Gets the index of the topmost visible item when in
1322 // list or report view
1323 long wxListCtrl::GetTopItem() const
1325 return (long) ListView_GetTopIndex(GetHwnd());
1328 // Searches for an item, starting from 'item'.
1329 // 'geometry' is one of
1330 // wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT.
1331 // 'state' is a state bit flag, one or more of
1332 // wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT.
1333 // item can be -1 to find the first item that matches the
1335 // Returns the item or -1 if unsuccessful.
1336 long wxListCtrl::GetNextItem(long item
, int geom
, int state
) const
1340 if ( geom
== wxLIST_NEXT_ABOVE
)
1341 flags
|= LVNI_ABOVE
;
1342 if ( geom
== wxLIST_NEXT_ALL
)
1344 if ( geom
== wxLIST_NEXT_BELOW
)
1345 flags
|= LVNI_BELOW
;
1346 if ( geom
== wxLIST_NEXT_LEFT
)
1347 flags
|= LVNI_TOLEFT
;
1348 if ( geom
== wxLIST_NEXT_RIGHT
)
1349 flags
|= LVNI_TORIGHT
;
1351 if ( state
& wxLIST_STATE_CUT
)
1353 if ( state
& wxLIST_STATE_DROPHILITED
)
1354 flags
|= LVNI_DROPHILITED
;
1355 if ( state
& wxLIST_STATE_FOCUSED
)
1356 flags
|= LVNI_FOCUSED
;
1357 if ( state
& wxLIST_STATE_SELECTED
)
1358 flags
|= LVNI_SELECTED
;
1360 return (long) ListView_GetNextItem(GetHwnd(), item
, flags
);
1364 wxImageList
*wxListCtrl::GetImageList(int which
) const
1366 if ( which
== wxIMAGE_LIST_NORMAL
)
1368 return m_imageListNormal
;
1370 else if ( which
== wxIMAGE_LIST_SMALL
)
1372 return m_imageListSmall
;
1374 else if ( which
== wxIMAGE_LIST_STATE
)
1376 return m_imageListState
;
1381 void wxListCtrl::SetImageList(wxImageList
*imageList
, int which
)
1384 if ( which
== wxIMAGE_LIST_NORMAL
)
1386 flags
= LVSIL_NORMAL
;
1387 if (m_ownsImageListNormal
) delete m_imageListNormal
;
1388 m_imageListNormal
= imageList
;
1389 m_ownsImageListNormal
= false;
1391 else if ( which
== wxIMAGE_LIST_SMALL
)
1393 flags
= LVSIL_SMALL
;
1394 if (m_ownsImageListSmall
) delete m_imageListSmall
;
1395 m_imageListSmall
= imageList
;
1396 m_ownsImageListSmall
= false;
1398 else if ( which
== wxIMAGE_LIST_STATE
)
1400 flags
= LVSIL_STATE
;
1401 if (m_ownsImageListState
) delete m_imageListState
;
1402 m_imageListState
= imageList
;
1403 m_ownsImageListState
= false;
1405 (void) ListView_SetImageList(GetHwnd(), (HIMAGELIST
) imageList
? imageList
->GetHIMAGELIST() : 0, flags
);
1408 void wxListCtrl::AssignImageList(wxImageList
*imageList
, int which
)
1410 SetImageList(imageList
, which
);
1411 if ( which
== wxIMAGE_LIST_NORMAL
)
1412 m_ownsImageListNormal
= true;
1413 else if ( which
== wxIMAGE_LIST_SMALL
)
1414 m_ownsImageListSmall
= true;
1415 else if ( which
== wxIMAGE_LIST_STATE
)
1416 m_ownsImageListState
= true;
1419 // ----------------------------------------------------------------------------
1421 // ----------------------------------------------------------------------------
1423 // Arranges the items
1424 bool wxListCtrl::Arrange(int flag
)
1427 if ( flag
== wxLIST_ALIGN_LEFT
)
1428 code
= LVA_ALIGNLEFT
;
1429 else if ( flag
== wxLIST_ALIGN_TOP
)
1430 code
= LVA_ALIGNTOP
;
1431 else if ( flag
== wxLIST_ALIGN_DEFAULT
)
1433 else if ( flag
== wxLIST_ALIGN_SNAP_TO_GRID
)
1434 code
= LVA_SNAPTOGRID
;
1436 return (ListView_Arrange(GetHwnd(), code
) != 0);
1440 bool wxListCtrl::DeleteItem(long item
)
1442 if ( !ListView_DeleteItem(GetHwnd(), (int) item
) )
1444 wxLogLastError(_T("ListView_DeleteItem"));
1449 wxASSERT_MSG( m_count
== ListView_GetItemCount(GetHwnd()),
1450 wxT("m_count should match ListView_GetItemCount"));
1452 // the virtual list control doesn't refresh itself correctly, help it
1455 // we need to refresh all the lines below the one which was deleted
1457 if ( item
> 0 && GetItemCount() )
1459 GetItemRect(item
- 1, rectItem
);
1464 rectItem
.height
= 0;
1467 wxRect rectWin
= GetRect();
1468 rectWin
.height
= rectWin
.GetBottom() - rectItem
.GetBottom();
1469 rectWin
.y
= rectItem
.GetBottom();
1471 RefreshRect(rectWin
);
1477 // Deletes all items
1478 bool wxListCtrl::DeleteAllItems()
1480 return ListView_DeleteAllItems(GetHwnd()) != 0;
1483 // Deletes all items
1484 bool wxListCtrl::DeleteAllColumns()
1486 while ( m_colCount
> 0 )
1488 if ( ListView_DeleteColumn(GetHwnd(), 0) == 0 )
1490 wxLogLastError(wxT("ListView_DeleteColumn"));
1498 wxASSERT_MSG( m_colCount
== 0, wxT("no columns should be left") );
1504 bool wxListCtrl::DeleteColumn(int col
)
1506 bool success
= (ListView_DeleteColumn(GetHwnd(), col
) != 0);
1508 if ( success
&& (m_colCount
> 0) )
1513 // Clears items, and columns if there are any.
1514 void wxListCtrl::ClearAll()
1517 if ( m_colCount
> 0 )
1521 void wxListCtrl::InitEditControl(WXHWND hWnd
)
1523 m_textCtrl
->SetHWND(hWnd
);
1524 m_textCtrl
->SubclassWin(hWnd
);
1525 m_textCtrl
->SetParent(this);
1527 // we must disallow TABbing away from the control while the edit contol is
1528 // shown because this leaves it in some strange state (just try removing
1529 // this line and then pressing TAB while editing an item in listctrl
1531 m_textCtrl
->SetWindowStyle(m_textCtrl
->GetWindowStyle() | wxTE_PROCESS_TAB
);
1534 wxTextCtrl
* wxListCtrl::EditLabel(long item
, wxClassInfo
* textControlClass
)
1536 wxCHECK_MSG( textControlClass
->IsKindOf(CLASSINFO(wxTextCtrl
)), NULL
,
1537 "control used for label editing must be a wxTextCtrl" );
1539 // ListView_EditLabel requires that the list has focus.
1542 // create m_textCtrl here before calling ListView_EditLabel() because it
1543 // generates wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT event from inside it and
1544 // the user handler for it can call GetEditControl() resulting in an on
1545 // demand creation of a stock wxTextCtrl instead of the control of a
1546 // (possibly) custom wxClassInfo
1547 DeleteEditControl();
1548 m_textCtrl
= (wxTextCtrl
*)textControlClass
->CreateObject();
1550 WXHWND hWnd
= (WXHWND
) ListView_EditLabel(GetHwnd(), item
);
1553 // failed to start editing
1560 // if GetEditControl() hasn't been called, we need to initialize the edit
1561 // control ourselves
1562 if ( !m_textCtrl
->GetHWND() )
1563 InitEditControl(hWnd
);
1568 // End label editing, optionally cancelling the edit
1569 bool wxListCtrl::EndEditLabel(bool cancel
)
1571 // m_textCtrl is not always ready, ie. in EVT_LIST_BEGIN_LABEL_EDIT
1572 HWND hwnd
= ListView_GetEditControl(GetHwnd());
1577 ::SetWindowText(hwnd
, wxEmptyString
); // dubious but better than nothing
1579 // we shouldn't destroy the control ourselves according to MSDN, which
1580 // proposes WM_CANCELMODE to do this, but it doesn't seem to work
1582 // posting WM_CLOSE to it does seem to work without any side effects
1583 ::PostMessage(hwnd
, WM_CLOSE
, 0, 0);
1588 // Ensures this item is visible
1589 bool wxListCtrl::EnsureVisible(long item
)
1591 return ListView_EnsureVisible(GetHwnd(), (int) item
, FALSE
) != FALSE
;
1594 // Find an item whose label matches this string, starting from the item after 'start'
1595 // or the beginning if 'start' is -1.
1596 long wxListCtrl::FindItem(long start
, const wxString
& str
, bool partial
)
1598 LV_FINDINFO findInfo
;
1600 findInfo
.flags
= LVFI_STRING
;
1602 findInfo
.flags
|= LVFI_PARTIAL
;
1603 findInfo
.psz
= str
.wx_str();
1605 // ListView_FindItem() excludes the first item from search and to look
1606 // through all the items you need to start from -1 which is unnatural and
1607 // inconsistent with the generic version - so we adjust the index
1610 return ListView_FindItem(GetHwnd(), (int) start
, &findInfo
);
1613 // Find an item whose data matches this data, starting from the item after 'start'
1614 // or the beginning if 'start' is -1.
1615 // NOTE : Lindsay Mathieson - 14-July-2002
1616 // No longer use ListView_FindItem as the data attribute is now stored
1617 // in a wxListItemInternalData structure refernced by the actual lParam
1618 long wxListCtrl::FindItem(long start
, wxUIntPtr data
)
1620 long idx
= start
+ 1;
1621 long count
= GetItemCount();
1625 if (GetItemData(idx
) == data
)
1633 // Find an item nearest this position in the specified direction, starting from
1634 // the item after 'start' or the beginning if 'start' is -1.
1635 long wxListCtrl::FindItem(long start
, const wxPoint
& pt
, int direction
)
1637 LV_FINDINFO findInfo
;
1639 findInfo
.flags
= LVFI_NEARESTXY
;
1640 findInfo
.pt
.x
= pt
.x
;
1641 findInfo
.pt
.y
= pt
.y
;
1642 findInfo
.vkDirection
= VK_RIGHT
;
1644 if ( direction
== wxLIST_FIND_UP
)
1645 findInfo
.vkDirection
= VK_UP
;
1646 else if ( direction
== wxLIST_FIND_DOWN
)
1647 findInfo
.vkDirection
= VK_DOWN
;
1648 else if ( direction
== wxLIST_FIND_LEFT
)
1649 findInfo
.vkDirection
= VK_LEFT
;
1650 else if ( direction
== wxLIST_FIND_RIGHT
)
1651 findInfo
.vkDirection
= VK_RIGHT
;
1653 return ListView_FindItem(GetHwnd(), (int) start
, & findInfo
);
1656 // Determines which item (if any) is at the specified point,
1657 // giving details in 'flags' (see wxLIST_HITTEST_... flags above)
1659 wxListCtrl::HitTest(const wxPoint
& point
, int& flags
, long *ptrSubItem
) const
1661 LV_HITTESTINFO hitTestInfo
;
1662 hitTestInfo
.pt
.x
= (int) point
.x
;
1663 hitTestInfo
.pt
.y
= (int) point
.y
;
1666 #ifdef LVM_SUBITEMHITTEST
1667 if ( ptrSubItem
&& wxApp::GetComCtl32Version() >= 470 )
1669 item
= ListView_SubItemHitTest(GetHwnd(), &hitTestInfo
);
1670 *ptrSubItem
= hitTestInfo
.iSubItem
;
1673 #endif // LVM_SUBITEMHITTEST
1675 item
= ListView_HitTest(GetHwnd(), &hitTestInfo
);
1680 if ( hitTestInfo
.flags
& LVHT_ABOVE
)
1681 flags
|= wxLIST_HITTEST_ABOVE
;
1682 if ( hitTestInfo
.flags
& LVHT_BELOW
)
1683 flags
|= wxLIST_HITTEST_BELOW
;
1684 if ( hitTestInfo
.flags
& LVHT_TOLEFT
)
1685 flags
|= wxLIST_HITTEST_TOLEFT
;
1686 if ( hitTestInfo
.flags
& LVHT_TORIGHT
)
1687 flags
|= wxLIST_HITTEST_TORIGHT
;
1689 if ( hitTestInfo
.flags
& LVHT_NOWHERE
)
1690 flags
|= wxLIST_HITTEST_NOWHERE
;
1692 // note a bug or at least a very strange feature of comtl32.dll (tested
1693 // with version 4.0 under Win95 and 6.0 under Win 2003): if you click to
1694 // the right of the item label, ListView_HitTest() returns a combination of
1695 // LVHT_ONITEMICON, LVHT_ONITEMLABEL and LVHT_ONITEMSTATEICON -- filter out
1696 // the bits which don't make sense
1697 if ( hitTestInfo
.flags
& LVHT_ONITEMLABEL
)
1699 flags
|= wxLIST_HITTEST_ONITEMLABEL
;
1701 // do not translate LVHT_ONITEMICON here, as per above
1705 if ( hitTestInfo
.flags
& LVHT_ONITEMICON
)
1706 flags
|= wxLIST_HITTEST_ONITEMICON
;
1707 if ( hitTestInfo
.flags
& LVHT_ONITEMSTATEICON
)
1708 flags
|= wxLIST_HITTEST_ONITEMSTATEICON
;
1715 // Inserts an item, returning the index of the new item if successful,
1717 long wxListCtrl::InsertItem(const wxListItem
& info
)
1719 wxASSERT_MSG( !IsVirtual(), _T("can't be used with virtual controls") );
1722 wxConvertToMSWListItem(this, info
, item
);
1723 item
.mask
&= ~LVIF_PARAM
;
1725 // check wether we need to allocate our internal data
1726 bool needInternalData
= ((info
.m_mask
& wxLIST_MASK_DATA
) || info
.HasAttributes());
1727 if (needInternalData
)
1729 m_AnyInternalData
= true;
1730 item
.mask
|= LVIF_PARAM
;
1732 // internal stucture that manages data
1733 wxListItemInternalData
*data
= new wxListItemInternalData();
1734 item
.lParam
= (LPARAM
) data
;
1736 if (info
.m_mask
& wxLIST_MASK_DATA
)
1737 data
->lParam
= info
.m_data
;
1739 // check whether it has any custom attributes
1740 if ( info
.HasAttributes() )
1742 // take copy of attributes
1743 data
->attr
= new wxListItemAttr(*info
.GetAttributes());
1745 // and remember that we have some now...
1746 m_hasAnyAttr
= true;
1750 long rv
= ListView_InsertItem(GetHwnd(), & item
);
1753 wxASSERT_MSG( m_count
== ListView_GetItemCount(GetHwnd()),
1754 wxT("m_count should match ListView_GetItemCount"));
1759 long wxListCtrl::InsertItem(long index
, const wxString
& label
)
1762 info
.m_text
= label
;
1763 info
.m_mask
= wxLIST_MASK_TEXT
;
1764 info
.m_itemId
= index
;
1765 return InsertItem(info
);
1768 // Inserts an image item
1769 long wxListCtrl::InsertItem(long index
, int imageIndex
)
1772 info
.m_image
= imageIndex
;
1773 info
.m_mask
= wxLIST_MASK_IMAGE
;
1774 info
.m_itemId
= index
;
1775 return InsertItem(info
);
1778 // Inserts an image/string item
1779 long wxListCtrl::InsertItem(long index
, const wxString
& label
, int imageIndex
)
1782 info
.m_image
= imageIndex
;
1783 info
.m_text
= label
;
1784 info
.m_mask
= wxLIST_MASK_IMAGE
| wxLIST_MASK_TEXT
;
1785 info
.m_itemId
= index
;
1786 return InsertItem(info
);
1789 // For list view mode (only), inserts a column.
1790 long wxListCtrl::InsertColumn(long col
, const wxListItem
& item
)
1793 wxConvertToMSWListCol(GetHwnd(), col
, item
, lvCol
);
1795 if ( !(lvCol
.mask
& LVCF_WIDTH
) )
1797 // always give some width to the new column: this one is compatible
1798 // with the generic version
1799 lvCol
.mask
|= LVCF_WIDTH
;
1803 long n
= ListView_InsertColumn(GetHwnd(), col
, &lvCol
);
1808 else // failed to insert?
1810 wxLogDebug(wxT("Failed to insert the column '%s' into listview!"),
1817 long wxListCtrl::InsertColumn(long col
,
1818 const wxString
& heading
,
1823 item
.m_mask
= wxLIST_MASK_TEXT
| wxLIST_MASK_FORMAT
;
1824 item
.m_text
= heading
;
1827 item
.m_mask
|= wxLIST_MASK_WIDTH
;
1828 item
.m_width
= width
;
1830 item
.m_format
= format
;
1832 return InsertColumn(col
, item
);
1835 // scroll the control by the given number of pixels (exception: in list view,
1836 // dx is interpreted as number of columns)
1837 bool wxListCtrl::ScrollList(int dx
, int dy
)
1839 if ( !ListView_Scroll(GetHwnd(), dx
, dy
) )
1841 wxLogDebug(_T("ListView_Scroll(%d, %d) failed"), dx
, dy
);
1851 // fn is a function which takes 3 long arguments: item1, item2, data.
1852 // item1 is the long data associated with a first item (NOT the index).
1853 // item2 is the long data associated with a second item (NOT the index).
1854 // data is the same value as passed to SortItems.
1855 // The return value is a negative number if the first item should precede the second
1856 // item, a positive number of the second item should precede the first,
1857 // or zero if the two items are equivalent.
1859 // data is arbitrary data to be passed to the sort function.
1861 // Internal structures for proxying the user compare function
1862 // so that we can pass it the *real* user data
1864 // translate lParam data and call user func
1865 struct wxInternalDataSort
1867 wxListCtrlCompare user_fn
;
1871 int CALLBACK
wxInternalDataCompareFunc(LPARAM lParam1
, LPARAM lParam2
, LPARAM lParamSort
)
1873 wxInternalDataSort
* const internalData
= (wxInternalDataSort
*) lParamSort
;
1875 wxListItemInternalData
*data1
= (wxListItemInternalData
*) lParam1
;
1876 wxListItemInternalData
*data2
= (wxListItemInternalData
*) lParam2
;
1878 long d1
= (data1
== NULL
? 0 : data1
->lParam
);
1879 long d2
= (data2
== NULL
? 0 : data2
->lParam
);
1881 return internalData
->user_fn(d1
, d2
, internalData
->data
);
1885 bool wxListCtrl::SortItems(wxListCtrlCompare fn
, wxIntPtr data
)
1887 wxInternalDataSort internalData
;
1888 internalData
.user_fn
= fn
;
1889 internalData
.data
= data
;
1891 // WPARAM cast is needed for mingw/cygwin
1892 if ( !ListView_SortItems(GetHwnd(),
1893 wxInternalDataCompareFunc
,
1894 (WPARAM
) &internalData
) )
1896 wxLogDebug(_T("ListView_SortItems() failed"));
1906 // ----------------------------------------------------------------------------
1907 // message processing
1908 // ----------------------------------------------------------------------------
1910 bool wxListCtrl::MSWShouldPreProcessMessage(WXMSG
* msg
)
1912 if ( msg
->message
== WM_KEYDOWN
)
1914 // Only eat VK_RETURN if not being used by the application in
1915 // conjunction with modifiers
1916 if ( msg
->wParam
== VK_RETURN
&& !wxIsAnyModifierDown() )
1918 // we need VK_RETURN to generate wxEVT_COMMAND_LIST_ITEM_ACTIVATED
1922 return wxControl::MSWShouldPreProcessMessage(msg
);
1925 bool wxListCtrl::MSWCommand(WXUINT cmd
, WXWORD id_
)
1927 const int id
= (signed short)id_
;
1928 if (cmd
== EN_UPDATE
)
1930 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, id
);
1931 event
.SetEventObject( this );
1932 ProcessCommand(event
);
1935 else if (cmd
== EN_KILLFOCUS
)
1937 wxCommandEvent
event(wxEVT_KILL_FOCUS
, id
);
1938 event
.SetEventObject( this );
1939 ProcessCommand(event
);
1946 // utility used by wxListCtrl::MSWOnNotify and by wxDataViewHeaderWindowMSW::MSWOnNotify
1947 int WXDLLIMPEXP_CORE
wxMSWGetColumnClicked(NMHDR
*nmhdr
, POINT
*ptClick
)
1949 // find the column clicked: we have to search for it ourselves as the
1950 // notification message doesn't provide this info
1952 // where did the click occur?
1953 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
1954 if ( nmhdr
->code
== GN_CONTEXTMENU
)
1956 *ptClick
= ((NMRGINFO
*)nmhdr
)->ptAction
;
1959 #endif //__WXWINCE__
1960 if ( !::GetCursorPos(ptClick
) )
1962 wxLogLastError(_T("GetCursorPos"));
1965 // we need to use listctrl coordinates for the event point so this is what
1966 // we return in ptClick, but for comparison with Header_GetItemRect()
1967 // result below we need to use header window coordinates
1968 POINT ptClickHeader
= *ptClick
;
1969 if ( !::ScreenToClient(nmhdr
->hwndFrom
, &ptClickHeader
) )
1971 wxLogLastError(_T("ScreenToClient(listctrl header)"));
1974 if ( !::ScreenToClient(::GetParent(nmhdr
->hwndFrom
), ptClick
) )
1976 wxLogLastError(_T("ScreenToClient(listctrl)"));
1979 const int colCount
= Header_GetItemCount(nmhdr
->hwndFrom
);
1980 for ( int col
= 0; col
< colCount
; col
++ )
1983 if ( Header_GetItemRect(nmhdr
->hwndFrom
, col
, &rect
) )
1985 if ( ::PtInRect(&rect
, ptClickHeader
) )
1995 bool wxListCtrl::MSWOnNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
1998 // prepare the event
1999 // -----------------
2001 wxListEvent
event(wxEVT_NULL
, m_windowId
);
2002 event
.SetEventObject(this);
2004 wxEventType eventType
= wxEVT_NULL
;
2006 NMHDR
*nmhdr
= (NMHDR
*)lParam
;
2008 // if your compiler is as broken as this, you should really change it: this
2009 // code is needed for normal operation! #ifdef below is only useful for
2010 // automatic rebuilds which are done with a very old compiler version
2011 #ifdef HDN_BEGINTRACKA
2013 // check for messages from the header (in report view)
2014 HWND hwndHdr
= ListView_GetHeader(GetHwnd());
2016 // is it a message from the header?
2017 if ( nmhdr
->hwndFrom
== hwndHdr
)
2019 HD_NOTIFY
*nmHDR
= (HD_NOTIFY
*)nmhdr
;
2021 event
.m_itemIndex
= -1;
2023 switch ( nmhdr
->code
)
2025 // yet another comctl32.dll bug: under NT/W2K it sends Unicode
2026 // TRACK messages even to ANSI programs: on my system I get
2027 // HDN_BEGINTRACKW and HDN_ENDTRACKA and no HDN_TRACK at all!
2029 // work around is to simply catch both versions and hope that it
2030 // works (why should this message exist in ANSI and Unicode is
2031 // beyond me as it doesn't deal with strings at all...)
2033 // note that fr HDN_TRACK another possibility could be to use
2034 // HDN_ITEMCHANGING but it is sent even after HDN_ENDTRACK and when
2035 // something other than the item width changes so we'd have to
2036 // filter out the unwanted events then
2037 case HDN_BEGINTRACKA
:
2038 case HDN_BEGINTRACKW
:
2039 eventType
= wxEVT_COMMAND_LIST_COL_BEGIN_DRAG
;
2044 if ( eventType
== wxEVT_NULL
)
2045 eventType
= wxEVT_COMMAND_LIST_COL_DRAGGING
;
2050 if ( eventType
== wxEVT_NULL
)
2051 eventType
= wxEVT_COMMAND_LIST_COL_END_DRAG
;
2053 event
.m_item
.m_width
= nmHDR
->pitem
->cxy
;
2054 event
.m_col
= nmHDR
->iItem
;
2057 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
2058 case GN_CONTEXTMENU
:
2059 #endif //__WXWINCE__
2064 eventType
= wxEVT_COMMAND_LIST_COL_RIGHT_CLICK
;
2065 event
.m_col
= wxMSWGetColumnClicked(nmhdr
, &ptClick
);
2066 event
.m_pointDrag
.x
= ptClick
.x
;
2067 event
.m_pointDrag
.y
= ptClick
.y
;
2071 case HDN_GETDISPINFOW
:
2072 // letting Windows XP handle this message results in mysterious
2073 // crashes in comctl32.dll seemingly because of bad message
2076 // I have no idea what is the real cause of the bug (which is,
2077 // just to make things interesting, impossible to reproduce
2078 // reliably) but ignoring all these messages does fix it and
2079 // doesn't seem to have any negative consequences
2083 return wxControl::MSWOnNotify(idCtrl
, lParam
, result
);
2087 #endif // defined(HDN_BEGINTRACKA)
2088 if ( nmhdr
->hwndFrom
== GetHwnd() )
2090 // almost all messages use NM_LISTVIEW
2091 NM_LISTVIEW
*nmLV
= (NM_LISTVIEW
*)nmhdr
;
2093 const int iItem
= nmLV
->iItem
;
2096 // FreeAllInternalData will cause LVN_ITEMCHANG* messages, which can be
2097 // ignored for efficiency. It is done here because the internal data is in the
2098 // process of being deleted so we don't want to try and access it below.
2099 if ( m_ignoreChangeMessages
&&
2100 ( (nmLV
->hdr
.code
== LVN_ITEMCHANGED
) ||
2101 (nmLV
->hdr
.code
== LVN_ITEMCHANGING
)) )
2107 // If we have a valid item then check if there is a data value
2108 // associated with it and put it in the event.
2109 if ( iItem
>= 0 && iItem
< GetItemCount() )
2111 wxListItemInternalData
*internaldata
=
2112 wxGetInternalData(GetHwnd(), iItem
);
2115 event
.m_item
.m_data
= internaldata
->lParam
;
2118 bool processed
= true;
2119 switch ( nmhdr
->code
)
2121 case LVN_BEGINRDRAG
:
2122 eventType
= wxEVT_COMMAND_LIST_BEGIN_RDRAG
;
2126 if ( eventType
== wxEVT_NULL
)
2128 eventType
= wxEVT_COMMAND_LIST_BEGIN_DRAG
;
2131 event
.m_itemIndex
= iItem
;
2132 event
.m_pointDrag
.x
= nmLV
->ptAction
.x
;
2133 event
.m_pointDrag
.y
= nmLV
->ptAction
.y
;
2136 // NB: we have to handle both *A and *W versions here because some
2137 // versions of comctl32.dll send ANSI messages even to the
2139 case LVN_BEGINLABELEDITA
:
2140 case LVN_BEGINLABELEDITW
:
2143 if ( nmhdr
->code
== LVN_BEGINLABELEDITA
)
2145 item
.Init(((LV_DISPINFOA
*)lParam
)->item
);
2147 else // LVN_BEGINLABELEDITW
2149 item
.Init(((LV_DISPINFOW
*)lParam
)->item
);
2152 eventType
= wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT
;
2153 wxConvertFromMSWListItem(GetHwnd(), event
.m_item
, item
);
2154 event
.m_itemIndex
= event
.m_item
.m_itemId
;
2158 case LVN_ENDLABELEDITA
:
2159 case LVN_ENDLABELEDITW
:
2162 if ( nmhdr
->code
== LVN_ENDLABELEDITA
)
2164 item
.Init(((LV_DISPINFOA
*)lParam
)->item
);
2166 else // LVN_ENDLABELEDITW
2168 item
.Init(((LV_DISPINFOW
*)lParam
)->item
);
2171 // was editing cancelled?
2172 const LV_ITEM
& lvi
= (LV_ITEM
)item
;
2173 if ( !lvi
.pszText
|| lvi
.iItem
== -1 )
2175 // EDIT control will be deleted by the list control
2176 // itself so prevent us from deleting it as well
2177 DeleteEditControl();
2179 event
.SetEditCanceled(true);
2182 eventType
= wxEVT_COMMAND_LIST_END_LABEL_EDIT
;
2183 wxConvertFromMSWListItem(NULL
, event
.m_item
, item
);
2184 event
.m_itemIndex
= event
.m_item
.m_itemId
;
2188 case LVN_COLUMNCLICK
:
2189 eventType
= wxEVT_COMMAND_LIST_COL_CLICK
;
2190 event
.m_itemIndex
= -1;
2191 event
.m_col
= nmLV
->iSubItem
;
2194 case LVN_DELETEALLITEMS
:
2195 eventType
= wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS
;
2196 event
.m_itemIndex
= -1;
2199 case LVN_DELETEITEM
:
2202 // this should be prevented by the post-processing code
2203 // below, but "just in case"
2207 eventType
= wxEVT_COMMAND_LIST_DELETE_ITEM
;
2208 event
.m_itemIndex
= iItem
;
2209 // delete the assoicated internal data
2210 wxDeleteInternalData(this, iItem
);
2213 case LVN_INSERTITEM
:
2214 eventType
= wxEVT_COMMAND_LIST_INSERT_ITEM
;
2215 event
.m_itemIndex
= iItem
;
2218 case LVN_ITEMCHANGED
:
2219 // we translate this catch all message into more interesting
2220 // (and more easy to process) wxWidgets events
2222 // first of all, we deal with the state change events only and
2223 // only for valid items (item == -1 for the virtual list
2225 if ( nmLV
->uChanged
& LVIF_STATE
&& iItem
!= -1 )
2227 // temp vars for readability
2228 const UINT stOld
= nmLV
->uOldState
;
2229 const UINT stNew
= nmLV
->uNewState
;
2231 event
.m_item
.SetId(iItem
);
2232 event
.m_item
.SetMask(wxLIST_MASK_TEXT
|
2235 GetItem(event
.m_item
);
2237 // has the focus changed?
2238 if ( !(stOld
& LVIS_FOCUSED
) && (stNew
& LVIS_FOCUSED
) )
2240 eventType
= wxEVT_COMMAND_LIST_ITEM_FOCUSED
;
2241 event
.m_itemIndex
= iItem
;
2244 if ( (stNew
& LVIS_SELECTED
) != (stOld
& LVIS_SELECTED
) )
2246 if ( eventType
!= wxEVT_NULL
)
2248 // focus and selection have both changed: send the
2249 // focus event from here and the selection one
2251 event
.SetEventType(eventType
);
2252 (void)HandleWindowEvent(event
);
2254 else // no focus event to send
2256 // then need to set m_itemIndex as it wasn't done
2258 event
.m_itemIndex
= iItem
;
2261 eventType
= stNew
& LVIS_SELECTED
2262 ? wxEVT_COMMAND_LIST_ITEM_SELECTED
2263 : wxEVT_COMMAND_LIST_ITEM_DESELECTED
;
2267 if ( eventType
== wxEVT_NULL
)
2269 // not an interesting event for us
2277 LV_KEYDOWN
*info
= (LV_KEYDOWN
*)lParam
;
2278 WORD wVKey
= info
->wVKey
;
2280 // get the current selection
2281 long lItem
= GetNextItem(-1,
2283 wxLIST_STATE_SELECTED
);
2285 // <Enter> or <Space> activate the selected item if any (but
2286 // not with any modifiers as they have a predefined meaning
2289 (wVKey
== VK_RETURN
|| wVKey
== VK_SPACE
) &&
2290 !wxIsAnyModifierDown() )
2292 eventType
= wxEVT_COMMAND_LIST_ITEM_ACTIVATED
;
2296 eventType
= wxEVT_COMMAND_LIST_KEY_DOWN
;
2298 // wxCharCodeMSWToWX() returns 0 if the key is an ASCII
2299 // value which should be used as is
2300 int code
= wxCharCodeMSWToWX(wVKey
);
2301 event
.m_code
= code
? code
: wVKey
;
2305 event
.m_item
.m_itemId
= lItem
;
2309 // fill the other fields too
2310 event
.m_item
.m_text
= GetItemText(lItem
);
2311 event
.m_item
.m_data
= GetItemData(lItem
);
2317 // if the user processes it in wxEVT_COMMAND_LEFT_CLICK(), don't do
2319 if ( wxControl::MSWOnNotify(idCtrl
, lParam
, result
) )
2324 // else translate it into wxEVT_COMMAND_LIST_ITEM_ACTIVATED event
2325 // if it happened on an item (and not on empty place)
2332 eventType
= wxEVT_COMMAND_LIST_ITEM_ACTIVATED
;
2333 event
.m_itemIndex
= iItem
;
2334 event
.m_item
.m_text
= GetItemText(iItem
);
2335 event
.m_item
.m_data
= GetItemData(iItem
);
2338 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
2339 case GN_CONTEXTMENU
:
2340 #endif //__WXWINCE__
2342 // if the user processes it in wxEVT_COMMAND_RIGHT_CLICK(),
2343 // don't do anything else
2344 if ( wxControl::MSWOnNotify(idCtrl
, lParam
, result
) )
2349 // else translate it into wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK event
2350 LV_HITTESTINFO lvhti
;
2351 wxZeroMemory(lvhti
);
2353 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
2354 if(nmhdr
->code
== GN_CONTEXTMENU
) {
2355 lvhti
.pt
= ((NMRGINFO
*)nmhdr
)->ptAction
;
2357 #endif //__WXWINCE__
2358 ::GetCursorPos(&(lvhti
.pt
));
2359 ::ScreenToClient(GetHwnd(),&(lvhti
.pt
));
2360 if ( ListView_HitTest(GetHwnd(),&lvhti
) != -1 )
2362 if ( lvhti
.flags
& LVHT_ONITEM
)
2364 eventType
= wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
;
2365 event
.m_itemIndex
= lvhti
.iItem
;
2366 event
.m_pointDrag
.x
= lvhti
.pt
.x
;
2367 event
.m_pointDrag
.y
= lvhti
.pt
.y
;
2372 #ifdef NM_CUSTOMDRAW
2374 *result
= OnCustomDraw(lParam
);
2376 return *result
!= CDRF_DODEFAULT
;
2377 #endif // _WIN32_IE >= 0x300
2379 case LVN_ODCACHEHINT
:
2381 const NM_CACHEHINT
*cacheHint
= (NM_CACHEHINT
*)lParam
;
2383 eventType
= wxEVT_COMMAND_LIST_CACHE_HINT
;
2385 // we get some really stupid cache hints like ones for
2386 // items in range 0..0 for an empty control or, after
2387 // deleting an item, for items in invalid range -- filter
2389 if ( cacheHint
->iFrom
> cacheHint
->iTo
)
2392 event
.m_oldItemIndex
= cacheHint
->iFrom
;
2394 const long iMax
= GetItemCount();
2395 event
.m_itemIndex
= cacheHint
->iTo
< iMax
? cacheHint
->iTo
2400 #ifdef HAVE_NMLVFINDITEM
2401 case LVN_ODFINDITEM
:
2402 // this message is only used with the virtual list control but
2403 // even there we don't want to always use it: in a control with
2404 // sufficiently big number of items (defined as > 1000 here),
2405 // accidentally pressing a key could result in hanging an
2406 // application waiting while it performs linear search
2407 if ( IsVirtual() && GetItemCount() <= 1000 )
2409 NMLVFINDITEM
* pFindInfo
= (NMLVFINDITEM
*)lParam
;
2411 // no match by default
2414 // we only handle string-based searches here
2416 // TODO: what about LVFI_PARTIAL, should we handle this?
2417 if ( !(pFindInfo
->lvfi
.flags
& LVFI_STRING
) )
2422 const wxChar
* const searchstr
= pFindInfo
->lvfi
.psz
;
2423 const size_t len
= wxStrlen(searchstr
);
2425 // this is the first item we should examine, search from it
2426 // wrapping if necessary
2427 const int startPos
= pFindInfo
->iStart
;
2428 const int maxPos
= GetItemCount();
2429 wxCHECK_MSG( startPos
<= maxPos
, false,
2430 _T("bad starting position in LVN_ODFINDITEM") );
2432 int currentPos
= startPos
;
2435 // wrap to the beginning if necessary
2436 if ( currentPos
== maxPos
)
2438 // somewhat surprizingly, LVFI_WRAP isn't set in
2439 // flags but we still should wrap
2443 // does this item begin with searchstr?
2444 if ( wxStrnicmp(searchstr
,
2445 GetItemText(currentPos
), len
) == 0 )
2447 *result
= currentPos
;
2451 while ( ++currentPos
!= startPos
);
2453 if ( *result
== -1 )
2459 SetItemState(*result
,
2460 wxLIST_STATE_SELECTED
| wxLIST_STATE_FOCUSED
,
2461 wxLIST_STATE_SELECTED
| wxLIST_STATE_FOCUSED
);
2462 EnsureVisible(*result
);
2470 #endif // HAVE_NMLVFINDITEM
2472 case LVN_GETDISPINFO
:
2475 LV_DISPINFO
*info
= (LV_DISPINFO
*)lParam
;
2477 LV_ITEM
& lvi
= info
->item
;
2478 long item
= lvi
.iItem
;
2480 if ( lvi
.mask
& LVIF_TEXT
)
2482 wxString text
= OnGetItemText(item
, lvi
.iSubItem
);
2483 wxStrlcpy(lvi
.pszText
, text
.c_str(), lvi
.cchTextMax
);
2486 // see comment at the end of wxListCtrl::GetColumn()
2487 #ifdef NM_CUSTOMDRAW
2488 if ( lvi
.mask
& LVIF_IMAGE
)
2490 lvi
.iImage
= OnGetItemColumnImage(item
, lvi
.iSubItem
);
2492 #endif // NM_CUSTOMDRAW
2494 // even though we never use LVM_SETCALLBACKMASK, we still
2495 // can get messages with LVIF_STATE in lvi.mask under Vista
2496 if ( lvi
.mask
& LVIF_STATE
)
2498 // we don't have anything to return from here...
2511 return wxControl::MSWOnNotify(idCtrl
, lParam
, result
);
2515 // where did this one come from?
2519 // process the event
2520 // -----------------
2522 event
.SetEventType(eventType
);
2524 bool processed
= HandleWindowEvent(event
);
2528 switch ( nmhdr
->code
)
2530 case LVN_DELETEALLITEMS
:
2531 // always return true to suppress all additional LVN_DELETEITEM
2532 // notifications - this makes deleting all items from a list ctrl
2536 // also, we may free all user data now (couldn't do it before as
2537 // the user should have access to it in OnDeleteAllItems() handler)
2538 FreeAllInternalData();
2540 // the control is empty now, synchronize the cached number of items
2541 // with the real one
2545 case LVN_ENDLABELEDITA
:
2546 case LVN_ENDLABELEDITW
:
2547 // logic here is inverted compared to all the other messages
2548 *result
= event
.IsAllowed();
2550 // EDIT control will be deleted by the list control itself so
2551 // prevent us from deleting it as well
2552 DeleteEditControl();
2558 *result
= !event
.IsAllowed();
2563 // ----------------------------------------------------------------------------
2564 // custom draw stuff
2565 // ----------------------------------------------------------------------------
2567 // see comment at the end of wxListCtrl::GetColumn()
2568 #ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
2570 static RECT
GetCustomDrawnItemRect(const NMCUSTOMDRAW
& nmcd
)
2573 wxGetListCtrlItemRect(nmcd
.hdr
.hwndFrom
, nmcd
.dwItemSpec
, LVIR_BOUNDS
, rc
);
2576 wxGetListCtrlItemRect(nmcd
.hdr
.hwndFrom
, nmcd
.dwItemSpec
, LVIR_ICON
, rcIcon
);
2578 // exclude the icon part, neither the selection background nor focus rect
2580 rc
.left
= rcIcon
.right
;
2586 bool HandleSubItemPrepaint(LPNMLVCUSTOMDRAW pLVCD
, HFONT hfont
, int colCount
)
2588 NMCUSTOMDRAW
& nmcd
= pLVCD
->nmcd
;
2591 HWND hwndList
= nmcd
.hdr
.hwndFrom
;
2592 const int col
= pLVCD
->iSubItem
;
2593 const DWORD item
= nmcd
.dwItemSpec
;
2595 // the font must be valid, otherwise we wouldn't be painting the item at all
2596 SelectInHDC
selFont(hdc
, hfont
);
2598 // get the rectangle to paint
2599 int subitem
= colCount
? col
+ 1 : col
;
2601 wxGetListCtrlSubItemRect(hwndList
, item
, subitem
, LVIR_BOUNDS
, rc
);
2604 // get the image and text to draw
2608 it
.mask
= LVIF_TEXT
| LVIF_IMAGE
;
2612 it
.cchTextMax
= WXSIZEOF(text
);
2613 ListView_GetItem(hwndList
, &it
);
2615 HIMAGELIST himl
= ListView_GetImageList(hwndList
, LVSIL_SMALL
);
2616 if ( himl
&& ImageList_GetImageCount(himl
) )
2618 if ( it
.iImage
!= -1 )
2620 ImageList_Draw(himl
, it
.iImage
, hdc
, rc
.left
, rc
.top
,
2621 nmcd
.uItemState
& CDIS_SELECTED
? ILD_SELECTED
2625 // notice that even if this item doesn't have any image, the list
2626 // control still leaves space for the image in the first column if the
2627 // image list is not empty (presumably so that items with and without
2629 if ( it
.iImage
!= -1 || it
.iSubItem
== 0 )
2632 ImageList_GetIconSize(himl
, &wImage
, &hImage
);
2634 rc
.left
+= wImage
+ 2;
2638 ::SetBkMode(hdc
, TRANSPARENT
);
2640 UINT fmt
= DT_SINGLELINE
|
2643 #endif // __WXWINCE__
2648 wxZeroMemory(lvCol
);
2649 lvCol
.mask
= LVCF_FMT
;
2650 if ( ListView_GetColumn(hwndList
, col
, &lvCol
) )
2652 switch ( lvCol
.fmt
& LVCFMT_JUSTIFYMASK
)
2667 //else: failed to get alignment, assume it's DT_LEFT (default)
2669 DrawText(hdc
, text
, -1, &rc
, fmt
);
2674 static void HandleItemPostpaint(NMCUSTOMDRAW nmcd
)
2676 if ( nmcd
.uItemState
& CDIS_FOCUS
)
2678 RECT rc
= GetCustomDrawnItemRect(nmcd
);
2680 // don't use the provided HDC, it's in some strange state by now
2681 ::DrawFocusRect(WindowHDC(nmcd
.hdr
.hwndFrom
), &rc
);
2685 // pLVCD->clrText and clrTextBk should contain the colours to use
2686 static void HandleItemPaint(LPNMLVCUSTOMDRAW pLVCD
, HFONT hfont
)
2688 NMCUSTOMDRAW
& nmcd
= pLVCD
->nmcd
; // just a shortcut
2690 const HWND hwndList
= nmcd
.hdr
.hwndFrom
;
2691 const int item
= nmcd
.dwItemSpec
;
2693 // unfortunately we can't trust CDIS_SELECTED, it is often set even when
2694 // the item is not at all selected for some reason (comctl32 6), but we
2695 // also can't always trust ListView_GetItem() as it could return the old
2696 // item status if we're called just after the (de)selection, so remember
2697 // the last item to gain selection and also check for it here
2698 for ( int i
= -1;; )
2700 i
= ListView_GetNextItem(hwndList
, i
, LVNI_SELECTED
);
2703 nmcd
.uItemState
&= ~CDIS_SELECTED
;
2709 nmcd
.uItemState
|= CDIS_SELECTED
;
2714 // same thing for CDIS_FOCUS (except simpler as there is only one of them)
2716 // NB: cast is needed to work around the bug in mingw32 headers which don't
2717 // have it inside ListView_GetNextItem() itself (unlike SDK ones)
2718 if ( ::GetFocus() == hwndList
&&
2719 ListView_GetNextItem(
2720 hwndList
, static_cast<WPARAM
>(-1), LVNI_FOCUSED
) == item
)
2722 nmcd
.uItemState
|= CDIS_FOCUS
;
2726 nmcd
.uItemState
&= ~CDIS_FOCUS
;
2729 if ( nmcd
.uItemState
& CDIS_SELECTED
)
2731 int syscolFg
, syscolBg
;
2732 if ( ::GetFocus() == hwndList
)
2734 syscolFg
= COLOR_HIGHLIGHTTEXT
;
2735 syscolBg
= COLOR_HIGHLIGHT
;
2737 else // selected but unfocused
2739 syscolFg
= COLOR_WINDOWTEXT
;
2740 syscolBg
= COLOR_BTNFACE
;
2742 // don't grey out the icon in this case neither
2743 nmcd
.uItemState
&= ~CDIS_SELECTED
;
2746 pLVCD
->clrText
= ::GetSysColor(syscolFg
);
2747 pLVCD
->clrTextBk
= ::GetSysColor(syscolBg
);
2749 //else: not selected, use normal colours from pLVCD
2752 RECT rc
= GetCustomDrawnItemRect(nmcd
);
2754 ::SetTextColor(hdc
, pLVCD
->clrText
);
2755 ::FillRect(hdc
, &rc
, AutoHBRUSH(pLVCD
->clrTextBk
));
2757 // we could use CDRF_NOTIFYSUBITEMDRAW here but it results in weird repaint
2758 // problems so just draw everything except the focus rect from here instead
2759 const int colCount
= Header_GetItemCount(ListView_GetHeader(hwndList
));
2760 for ( int col
= 0; col
< colCount
; col
++ )
2762 pLVCD
->iSubItem
= col
;
2763 HandleSubItemPrepaint(pLVCD
, hfont
, colCount
);
2766 HandleItemPostpaint(nmcd
);
2769 static WXLPARAM
HandleItemPrepaint(wxListCtrl
*listctrl
,
2770 LPNMLVCUSTOMDRAW pLVCD
,
2771 wxListItemAttr
*attr
)
2775 // nothing to do for this item
2776 return CDRF_DODEFAULT
;
2780 // set the colours to use for text drawing
2781 pLVCD
->clrText
= attr
->HasTextColour()
2782 ? wxColourToRGB(attr
->GetTextColour())
2783 : wxColourToRGB(listctrl
->GetTextColour());
2784 pLVCD
->clrTextBk
= attr
->HasBackgroundColour()
2785 ? wxColourToRGB(attr
->GetBackgroundColour())
2786 : wxColourToRGB(listctrl
->GetBackgroundColour());
2788 // select the font if non default one is specified
2789 if ( attr
->HasFont() )
2791 wxFont font
= attr
->GetFont();
2792 if ( font
.GetEncoding() != wxFONTENCODING_SYSTEM
)
2794 // the standard control ignores the font encoding/charset, at least
2795 // with recent comctl32.dll versions (5 and 6, it uses to work with
2796 // 4.something) so we have to draw the item entirely ourselves in
2798 HandleItemPaint(pLVCD
, GetHfontOf(font
));
2799 return CDRF_SKIPDEFAULT
;
2802 ::SelectObject(pLVCD
->nmcd
.hdc
, GetHfontOf(font
));
2804 return CDRF_NEWFONT
;
2807 return CDRF_DODEFAULT
;
2810 WXLPARAM
wxListCtrl::OnCustomDraw(WXLPARAM lParam
)
2812 LPNMLVCUSTOMDRAW pLVCD
= (LPNMLVCUSTOMDRAW
)lParam
;
2813 NMCUSTOMDRAW
& nmcd
= pLVCD
->nmcd
;
2814 switch ( nmcd
.dwDrawStage
)
2817 // if we've got any items with non standard attributes,
2818 // notify us before painting each item
2820 // for virtual controls, always suppose that we have attributes as
2821 // there is no way to check for this
2822 if ( IsVirtual() || m_hasAnyAttr
)
2823 return CDRF_NOTIFYITEMDRAW
;
2826 case CDDS_ITEMPREPAINT
:
2827 // get a message for each subitem
2828 return CDRF_NOTIFYITEMDRAW
;
2830 case CDDS_SUBITEM
| CDDS_ITEMPREPAINT
:
2831 const int item
= nmcd
.dwItemSpec
;
2832 const int column
= pLVCD
->iSubItem
;
2834 // we get this message with item == 0 for an empty control, we
2835 // must ignore it as calling OnGetItemAttr() would be wrong
2836 if ( item
< 0 || item
>= GetItemCount() )
2839 if ( column
< 0 || column
>= GetColumnCount() )
2842 return HandleItemPrepaint(this, pLVCD
, DoGetItemColumnAttr(item
, column
));
2845 return CDRF_DODEFAULT
;
2848 #endif // NM_CUSTOMDRAW supported
2850 // Necessary for drawing hrules and vrules, if specified
2851 void wxListCtrl::OnPaint(wxPaintEvent
& event
)
2853 const int itemCount
= GetItemCount();
2854 const bool drawHRules
= HasFlag(wxLC_HRULES
);
2855 const bool drawVRules
= HasFlag(wxLC_VRULES
);
2857 if (!InReportView() || !(drawHRules
|| drawVRules
) || !itemCount
)
2865 wxControl::OnPaint(event
);
2867 // Reset the device origin since it may have been set
2868 dc
.SetDeviceOrigin(0, 0);
2870 wxPen
pen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT
));
2872 dc
.SetBrush(* wxTRANSPARENT_BRUSH
);
2874 wxSize clientSize
= GetClientSize();
2879 const long top
= GetTopItem();
2880 for ( int i
= top
; i
< top
+ GetCountPerPage() + 1; i
++ )
2882 if (GetItemRect(i
, itemRect
))
2884 int cy
= itemRect
.GetTop();
2885 if (i
!= 0) // Don't draw the first one
2887 dc
.DrawLine(0, cy
, clientSize
.x
, cy
);
2890 if (i
== itemCount
- 1)
2892 cy
= itemRect
.GetBottom();
2893 dc
.DrawLine(0, cy
, clientSize
.x
, cy
);
2902 wxRect firstItemRect
;
2903 GetItemRect(0, firstItemRect
);
2905 if (GetItemRect(itemCount
- 1, itemRect
))
2907 // this is a fix for bug 673394: erase the pixels which we would
2908 // otherwise leave on the screen
2909 static const int gap
= 2;
2910 dc
.SetPen(*wxTRANSPARENT_PEN
);
2911 dc
.SetBrush(wxBrush(GetBackgroundColour()));
2912 dc
.DrawRectangle(0, firstItemRect
.GetY() - gap
,
2913 clientSize
.GetWidth(), gap
);
2916 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
2918 const int numCols
= GetColumnCount();
2919 wxVector
<int> indexArray(numCols
);
2920 if ( !ListView_GetColumnOrderArray(GetHwnd(),
2924 wxFAIL_MSG( _T("invalid column index array in OnPaint()") );
2928 int x
= itemRect
.GetX();
2929 for (int col
= 0; col
< numCols
; col
++)
2931 int colWidth
= GetColumnWidth(indexArray
[col
]);
2933 dc
.DrawLine(x
-1, firstItemRect
.GetY() - gap
,
2934 x
-1, itemRect
.GetBottom());
2941 wxListCtrl::MSWWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2947 // we should bypass our own WM_PRINT handling as we don't handle
2948 // PRF_CHILDREN flag, so leave it to the native control itself
2949 return MSWDefWindowProc(nMsg
, wParam
, lParam
);
2952 case WM_CONTEXTMENU
:
2953 // because this message is propagated upwards the child-parent
2954 // chain, we get it for the right clicks on the header window but
2955 // this is confusing in wx as right clicking there already
2956 // generates a separate wxEVT_COMMAND_LIST_COL_RIGHT_CLICK event
2957 // so just ignore them
2958 if ( (HWND
)wParam
== ListView_GetHeader(GetHwnd()) )
2963 return wxControl::MSWWindowProc(nMsg
, wParam
, lParam
);
2966 // ----------------------------------------------------------------------------
2967 // virtual list controls
2968 // ----------------------------------------------------------------------------
2970 wxString
wxListCtrl::OnGetItemText(long WXUNUSED(item
), long WXUNUSED(col
)) const
2972 // this is a pure virtual function, in fact - which is not really pure
2973 // because the controls which are not virtual don't need to implement it
2974 wxFAIL_MSG( _T("wxListCtrl::OnGetItemText not supposed to be called") );
2976 return wxEmptyString
;
2979 int wxListCtrl::OnGetItemImage(long WXUNUSED(item
)) const
2981 wxCHECK_MSG(!GetImageList(wxIMAGE_LIST_SMALL
),
2983 wxT("List control has an image list, OnGetItemImage or OnGetItemColumnImage should be overridden."));
2987 int wxListCtrl::OnGetItemColumnImage(long item
, long column
) const
2990 return OnGetItemImage(item
);
2995 wxListItemAttr
*wxListCtrl::OnGetItemAttr(long WXUNUSED_UNLESS_DEBUG(item
)) const
2997 wxASSERT_MSG( item
>= 0 && item
< GetItemCount(),
2998 _T("invalid item index in OnGetItemAttr()") );
3000 // no attributes by default
3004 wxListItemAttr
*wxListCtrl::DoGetItemColumnAttr(long item
, long column
) const
3006 return IsVirtual() ? OnGetItemColumnAttr(item
, column
)
3007 : wxGetInternalDataAttr(this, item
);
3010 void wxListCtrl::SetItemCount(long count
)
3012 wxASSERT_MSG( IsVirtual(), _T("this is for virtual controls only") );
3014 if ( !::SendMessage(GetHwnd(), LVM_SETITEMCOUNT
, (WPARAM
)count
,
3015 LVSICF_NOSCROLL
| LVSICF_NOINVALIDATEALL
) )
3017 wxLogLastError(_T("ListView_SetItemCount"));
3020 wxASSERT_MSG( m_count
== ListView_GetItemCount(GetHwnd()),
3021 wxT("m_count should match ListView_GetItemCount"));
3024 void wxListCtrl::RefreshItem(long item
)
3026 RefreshItems(item
, item
);
3029 void wxListCtrl::RefreshItems(long itemFrom
, long itemTo
)
3031 ListView_RedrawItems(GetHwnd(), itemFrom
, itemTo
);
3034 // ----------------------------------------------------------------------------
3035 // internal data stuff
3036 // ----------------------------------------------------------------------------
3038 static wxListItemInternalData
*wxGetInternalData(HWND hwnd
, long itemId
)
3041 it
.mask
= LVIF_PARAM
;
3044 if ( !ListView_GetItem(hwnd
, &it
) )
3047 return (wxListItemInternalData
*) it
.lParam
;
3051 wxListItemInternalData
*wxGetInternalData(const wxListCtrl
*ctl
, long itemId
)
3053 return wxGetInternalData(GetHwndOf(ctl
), itemId
);
3057 wxListItemAttr
*wxGetInternalDataAttr(const wxListCtrl
*ctl
, long itemId
)
3059 wxListItemInternalData
*data
= wxGetInternalData(ctl
, itemId
);
3061 return data
? data
->attr
: NULL
;
3064 static void wxDeleteInternalData(wxListCtrl
* ctl
, long itemId
)
3066 wxListItemInternalData
*data
= wxGetInternalData(ctl
, itemId
);
3070 memset(&item
, 0, sizeof(item
));
3071 item
.iItem
= itemId
;
3072 item
.mask
= LVIF_PARAM
;
3073 item
.lParam
= (LPARAM
) 0;
3074 ListView_SetItem((HWND
)ctl
->GetHWND(), &item
);
3079 // ----------------------------------------------------------------------------
3080 // wxWin <-> MSW items conversions
3081 // ----------------------------------------------------------------------------
3083 static void wxConvertFromMSWListItem(HWND hwndListCtrl
,
3087 wxListItemInternalData
*internaldata
=
3088 (wxListItemInternalData
*) lvItem
.lParam
;
3091 info
.m_data
= internaldata
->lParam
;
3095 info
.m_stateMask
= 0;
3096 info
.m_itemId
= lvItem
.iItem
;
3098 long oldMask
= lvItem
.mask
;
3100 bool needText
= false;
3101 if (hwndListCtrl
!= 0)
3103 if ( lvItem
.mask
& LVIF_TEXT
)
3110 lvItem
.pszText
= new wxChar
[513];
3111 lvItem
.cchTextMax
= 512;
3113 lvItem
.mask
|= LVIF_TEXT
| LVIF_IMAGE
| LVIF_PARAM
;
3114 ::SendMessage(hwndListCtrl
, LVM_GETITEM
, 0, (LPARAM
)& lvItem
);
3117 if ( lvItem
.mask
& LVIF_STATE
)
3119 info
.m_mask
|= wxLIST_MASK_STATE
;
3121 if ( lvItem
.stateMask
& LVIS_CUT
)
3123 info
.m_stateMask
|= wxLIST_STATE_CUT
;
3124 if ( lvItem
.state
& LVIS_CUT
)
3125 info
.m_state
|= wxLIST_STATE_CUT
;
3127 if ( lvItem
.stateMask
& LVIS_DROPHILITED
)
3129 info
.m_stateMask
|= wxLIST_STATE_DROPHILITED
;
3130 if ( lvItem
.state
& LVIS_DROPHILITED
)
3131 info
.m_state
|= wxLIST_STATE_DROPHILITED
;
3133 if ( lvItem
.stateMask
& LVIS_FOCUSED
)
3135 info
.m_stateMask
|= wxLIST_STATE_FOCUSED
;
3136 if ( lvItem
.state
& LVIS_FOCUSED
)
3137 info
.m_state
|= wxLIST_STATE_FOCUSED
;
3139 if ( lvItem
.stateMask
& LVIS_SELECTED
)
3141 info
.m_stateMask
|= wxLIST_STATE_SELECTED
;
3142 if ( lvItem
.state
& LVIS_SELECTED
)
3143 info
.m_state
|= wxLIST_STATE_SELECTED
;
3147 if ( lvItem
.mask
& LVIF_TEXT
)
3149 info
.m_mask
|= wxLIST_MASK_TEXT
;
3150 info
.m_text
= lvItem
.pszText
;
3152 if ( lvItem
.mask
& LVIF_IMAGE
)
3154 info
.m_mask
|= wxLIST_MASK_IMAGE
;
3155 info
.m_image
= lvItem
.iImage
;
3157 if ( lvItem
.mask
& LVIF_PARAM
)
3158 info
.m_mask
|= wxLIST_MASK_DATA
;
3159 if ( lvItem
.mask
& LVIF_DI_SETITEM
)
3160 info
.m_mask
|= wxLIST_SET_ITEM
;
3161 info
.m_col
= lvItem
.iSubItem
;
3166 delete[] lvItem
.pszText
;
3168 lvItem
.mask
= oldMask
;
3171 static void wxConvertToMSWFlags(long state
, long stateMask
, LV_ITEM
& lvItem
)
3173 if (stateMask
& wxLIST_STATE_CUT
)
3175 lvItem
.stateMask
|= LVIS_CUT
;
3176 if (state
& wxLIST_STATE_CUT
)
3177 lvItem
.state
|= LVIS_CUT
;
3179 if (stateMask
& wxLIST_STATE_DROPHILITED
)
3181 lvItem
.stateMask
|= LVIS_DROPHILITED
;
3182 if (state
& wxLIST_STATE_DROPHILITED
)
3183 lvItem
.state
|= LVIS_DROPHILITED
;
3185 if (stateMask
& wxLIST_STATE_FOCUSED
)
3187 lvItem
.stateMask
|= LVIS_FOCUSED
;
3188 if (state
& wxLIST_STATE_FOCUSED
)
3189 lvItem
.state
|= LVIS_FOCUSED
;
3191 if (stateMask
& wxLIST_STATE_SELECTED
)
3193 lvItem
.stateMask
|= LVIS_SELECTED
;
3194 if (state
& wxLIST_STATE_SELECTED
)
3195 lvItem
.state
|= LVIS_SELECTED
;
3199 static void wxConvertToMSWListItem(const wxListCtrl
*ctrl
,
3200 const wxListItem
& info
,
3203 if ( ctrl
->InReportView() )
3205 wxASSERT_MSG( 0 <= info
.m_col
&& info
.m_col
< ctrl
->GetColumnCount(),
3206 "wxListCtrl column index out of bounds" );
3208 else // not in report view
3210 wxASSERT_MSG( info
.m_col
== 0, "columns only exist in report view" );
3213 lvItem
.iItem
= (int) info
.m_itemId
;
3215 lvItem
.iImage
= info
.m_image
;
3216 lvItem
.stateMask
= 0;
3219 lvItem
.iSubItem
= info
.m_col
;
3221 if (info
.m_mask
& wxLIST_MASK_STATE
)
3223 lvItem
.mask
|= LVIF_STATE
;
3225 wxConvertToMSWFlags(info
.m_state
, info
.m_stateMask
, lvItem
);
3228 if (info
.m_mask
& wxLIST_MASK_TEXT
)
3230 lvItem
.mask
|= LVIF_TEXT
;
3231 if ( ctrl
->HasFlag(wxLC_USER_TEXT
) )
3233 lvItem
.pszText
= LPSTR_TEXTCALLBACK
;
3237 // pszText is not const, hence the cast
3238 lvItem
.pszText
= (wxChar
*)info
.m_text
.wx_str();
3239 if ( lvItem
.pszText
)
3240 lvItem
.cchTextMax
= info
.m_text
.length();
3242 lvItem
.cchTextMax
= 0;
3245 if (info
.m_mask
& wxLIST_MASK_IMAGE
)
3246 lvItem
.mask
|= LVIF_IMAGE
;
3249 static void wxConvertToMSWListCol(HWND hwndList
,
3251 const wxListItem
& item
,
3254 wxZeroMemory(lvCol
);
3256 if ( item
.m_mask
& wxLIST_MASK_TEXT
)
3258 lvCol
.mask
|= LVCF_TEXT
;
3259 lvCol
.pszText
= (wxChar
*)item
.m_text
.wx_str(); // cast is safe
3262 if ( item
.m_mask
& wxLIST_MASK_FORMAT
)
3264 lvCol
.mask
|= LVCF_FMT
;
3266 if ( item
.m_format
== wxLIST_FORMAT_LEFT
)
3267 lvCol
.fmt
= LVCFMT_LEFT
;
3268 else if ( item
.m_format
== wxLIST_FORMAT_RIGHT
)
3269 lvCol
.fmt
= LVCFMT_RIGHT
;
3270 else if ( item
.m_format
== wxLIST_FORMAT_CENTRE
)
3271 lvCol
.fmt
= LVCFMT_CENTER
;
3274 if ( item
.m_mask
& wxLIST_MASK_WIDTH
)
3276 lvCol
.mask
|= LVCF_WIDTH
;
3277 if ( item
.m_width
== wxLIST_AUTOSIZE
)
3278 lvCol
.cx
= LVSCW_AUTOSIZE
;
3279 else if ( item
.m_width
== wxLIST_AUTOSIZE_USEHEADER
)
3280 lvCol
.cx
= LVSCW_AUTOSIZE_USEHEADER
;
3282 lvCol
.cx
= item
.m_width
;
3285 // see comment at the end of wxListCtrl::GetColumn()
3286 #ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
3287 if ( item
.m_mask
& wxLIST_MASK_IMAGE
)
3289 if ( wxApp::GetComCtl32Version() >= 470 )
3291 lvCol
.mask
|= LVCF_IMAGE
;
3293 // we use LVCFMT_BITMAP_ON_RIGHT because the images on the right
3294 // seem to be generally nicer than on the left and the generic
3295 // version only draws them on the right (we don't have a flag to
3296 // specify the image location anyhow)
3298 // we don't use LVCFMT_COL_HAS_IMAGES because it doesn't seem to
3299 // make any difference in my tests -- but maybe we should?
3300 if ( item
.m_image
!= -1 )
3302 // as we're going to overwrite the format field, get its
3303 // current value first -- unless we want to overwrite it anyhow
3304 if ( !(lvCol
.mask
& LVCF_FMT
) )
3307 wxZeroMemory(lvColOld
);
3308 lvColOld
.mask
= LVCF_FMT
;
3309 if ( ListView_GetColumn(hwndList
, col
, &lvColOld
) )
3311 lvCol
.fmt
= lvColOld
.fmt
;
3314 lvCol
.mask
|= LVCF_FMT
;
3317 lvCol
.fmt
|= LVCFMT_BITMAP_ON_RIGHT
| LVCFMT_IMAGE
;
3320 lvCol
.iImage
= item
.m_image
;
3322 //else: it doesn't support item images anyhow
3324 #endif // _WIN32_IE >= 0x0300
3327 #endif // wxUSE_LISTCTRL