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/stopwatch.h"
38 #include "wx/dcclient.h"
39 #include "wx/textctrl.h"
42 #include "wx/imaglist.h"
43 #include "wx/vector.h"
45 #include "wx/msw/private.h"
46 #include "wx/msw/private/keyboard.h"
48 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__)
56 // Currently gcc and watcom don't define NMLVFINDITEM, and DMC only defines
57 // it by its old name NM_FINDTIEM.
59 #if defined(__VISUALC__) || defined(__BORLANDC__) || defined(NMLVFINDITEM)
60 #define HAVE_NMLVFINDITEM 1
61 #elif defined(__DMC__) || defined(NM_FINDITEM)
62 #define HAVE_NMLVFINDITEM 1
63 #define NMLVFINDITEM NM_FINDITEM
66 // ----------------------------------------------------------------------------
68 // ----------------------------------------------------------------------------
70 // convert our state and mask flags to LV_ITEM constants
71 static void wxConvertToMSWFlags(long state
, long mask
, LV_ITEM
& lvItem
);
73 // convert wxListItem to LV_ITEM
74 static void wxConvertToMSWListItem(const wxListCtrl
*ctrl
,
75 const wxListItem
& info
, LV_ITEM
& lvItem
);
77 // convert LV_ITEM to wxListItem
78 static void wxConvertFromMSWListItem(HWND hwndListCtrl
,
80 /* const */ LV_ITEM
& lvItem
);
82 // convert our wxListItem to LV_COLUMN
83 static void wxConvertToMSWListCol(HWND hwndList
,
85 const wxListItem
& item
,
91 // replacement for ListView_GetSubItemRect() which provokes warnings like
92 // "the address of 'rc' will always evaluate as 'true'" when used with mingw32
95 // this function does no error checking on item and subitem parameters, notice
96 // that subitem 0 means the whole item so there is no way to retrieve the
97 // rectangle of the first subitem using this function, in particular notice
98 // that the index is *not* 1-based, in spite of what MSDN says
100 wxGetListCtrlSubItemRect(HWND hwnd
, int item
, int subitem
, int flags
, RECT
& rect
)
104 return ::SendMessage(hwnd
, LVM_GETSUBITEMRECT
, item
, (LPARAM
)&rect
) != 0;
108 wxGetListCtrlItemRect(HWND hwnd
, int item
, int flags
, RECT
& rect
)
110 return wxGetListCtrlSubItemRect(hwnd
, item
, 0, flags
, rect
);
113 } // anonymous namespace
115 // ----------------------------------------------------------------------------
116 // private helper classes
117 // ----------------------------------------------------------------------------
119 // We have to handle both fooW and fooA notifications in several cases
120 // because of broken comctl32.dll and/or unicows.dll. This class is used to
121 // convert LV_ITEMA and LV_ITEMW to LV_ITEM (which is either LV_ITEMA or
122 // LV_ITEMW depending on wxUSE_UNICODE setting), so that it can be processed
123 // by wxConvertToMSWListItem().
125 #define LV_ITEM_NATIVE LV_ITEMW
126 #define LV_ITEM_OTHER LV_ITEMA
128 #define LV_CONV_TO_WX cMB2WX
129 #define LV_CONV_BUF wxMB2WXbuf
131 #define LV_ITEM_NATIVE LV_ITEMA
132 #define LV_ITEM_OTHER LV_ITEMW
134 #define LV_CONV_TO_WX cWC2WX
135 #define LV_CONV_BUF wxWC2WXbuf
136 #endif // Unicode/ANSI
141 // default ctor, use Init() later
142 wxLV_ITEM() { m_buf
= NULL
; m_pItem
= NULL
; }
144 // init without conversion
145 void Init(LV_ITEM_NATIVE
& item
)
147 wxASSERT_MSG( !m_pItem
, wxT("Init() called twice?") );
152 // init with conversion
153 void Init(const LV_ITEM_OTHER
& item
)
155 // avoid unnecessary dynamic memory allocation, jjust make m_pItem
156 // point to our own m_item
158 // memcpy() can't work if the struct sizes are different
159 wxCOMPILE_TIME_ASSERT( sizeof(LV_ITEM_OTHER
) == sizeof(LV_ITEM_NATIVE
),
160 CodeCantWorkIfDiffSizes
);
162 memcpy(&m_item
, &item
, sizeof(LV_ITEM_NATIVE
));
164 // convert text from ANSI to Unicod if necessary
165 if ( (item
.mask
& LVIF_TEXT
) && item
.pszText
)
167 m_buf
= new LV_CONV_BUF(wxConvLocal
.LV_CONV_TO_WX(item
.pszText
));
168 m_item
.pszText
= (wxChar
*)m_buf
->data();
172 // ctor without conversion
173 wxLV_ITEM(LV_ITEM_NATIVE
& item
) : m_buf(NULL
), m_pItem(&item
) { }
175 // ctor with conversion
176 wxLV_ITEM(LV_ITEM_OTHER
& item
) : m_buf(NULL
)
181 ~wxLV_ITEM() { delete m_buf
; }
183 // conversion to the real LV_ITEM
184 operator LV_ITEM_NATIVE
&() const { return *m_pItem
; }
189 LV_ITEM_NATIVE
*m_pItem
;
190 LV_ITEM_NATIVE m_item
;
192 wxDECLARE_NO_COPY_CLASS(wxLV_ITEM
);
195 ///////////////////////////////////////////////////////
197 // The MSW version had problems with SetTextColour() et
198 // al as the wxListItemAttr's were stored keyed on the
199 // item index. If a item was inserted anywhere but the end
200 // of the list the text attributes (colour etc) for
201 // the following items were out of sync.
204 // Under MSW the only way to associate data with a List
205 // item independent of its position in the list is to
206 // store a pointer to it in its lParam attribute. However
207 // user programs are already using this (via the
208 // SetItemData() GetItemData() calls).
210 // However what we can do is store a pointer to a
211 // structure which contains the attributes we want *and*
212 // a lParam -- and this is what wxMSWListItemData does.
214 // To conserve memory, a wxMSWListItemData is
215 // only allocated for a LV_ITEM if text attributes or
216 // user data(lparam) are being set.
217 class wxMSWListItemData
220 wxMSWListItemData() : attr(NULL
), lParam(0) {}
221 ~wxMSWListItemData() { delete attr
; }
223 wxListItemAttr
*attr
;
224 LPARAM lParam
; // real user data
226 wxDECLARE_NO_COPY_CLASS(wxMSWListItemData
);
229 BEGIN_EVENT_TABLE(wxListCtrl
, wxControl
)
230 EVT_PAINT(wxListCtrl
::OnPaint
)
233 // ============================================================================
235 // ============================================================================
237 // ----------------------------------------------------------------------------
238 // wxListCtrl construction
239 // ----------------------------------------------------------------------------
241 void wxListCtrl
::Init()
245 m_imageListState
= NULL
;
246 m_ownsImageListNormal
=
247 m_ownsImageListSmall
=
248 m_ownsImageListState
= false;
254 m_hasAnyAttr
= false;
257 bool wxListCtrl
::Create(wxWindow
*parent
,
262 const wxValidator
& validator
,
263 const wxString
& name
)
265 if ( !CreateControl(parent
, id
, pos
, size
, style
, validator
, name
) )
268 if ( !MSWCreateControl(WC_LISTVIEW
, wxEmptyString
, pos
, size
) )
271 // explicitly say that we want to use Unicode because otherwise we get ANSI
272 // versions of _some_ messages (notably LVN_GETDISPINFOA) in MSLU build
273 wxSetCCUnicodeFormat(GetHwnd());
275 // We must set the default text colour to the system/theme color, otherwise
276 // GetTextColour will always return black
277 SetTextColour(GetDefaultAttributes().colFg
);
279 if ( InReportView() )
280 MSWSetExListStyles();
285 void wxListCtrl
::MSWSetExListStyles()
287 // for comctl32.dll v 4.70+ we want to have some non default extended
288 // styles because it's prettier (and also because wxGTK does it like this)
289 if ( wxApp
::GetComCtl32Version() >= 470 )
293 GetHwnd(), LVM_SETEXTENDEDLISTVIEWSTYLE
, 0,
294 // LVS_EX_LABELTIP shouldn't be used under Windows CE where it's
295 // not defined in the SDK headers
296 #ifdef LVS_EX_LABELTIP
299 LVS_EX_FULLROWSELECT
|
300 LVS_EX_SUBITEMIMAGES
|
301 // normally this should be governed by a style as it's probably not
302 // always appropriate, but we don't have any free styles left and
303 // it seems better to enable it by default than disable
304 LVS_EX_HEADERDRAGDROP
309 WXDWORD wxListCtrl
::MSWGetStyle(long style
, WXDWORD
*exstyle
) const
311 WXDWORD wstyle
= wxControl
::MSWGetStyle(style
, exstyle
);
313 wstyle
|= LVS_SHAREIMAGELISTS
| LVS_SHOWSELALWAYS
;
318 #define MAP_MODE_STYLE(wx, ms) \
319 if ( style & (wx) ) { wstyle |= (ms); nModes++; }
320 #else // !wxDEBUG_LEVEL
321 #define MAP_MODE_STYLE(wx, ms) \
322 if ( style & (wx) ) wstyle |= (ms);
323 #endif // wxDEBUG_LEVEL/!wxDEBUG_LEVEL
325 MAP_MODE_STYLE(wxLC_ICON
, LVS_ICON
)
326 MAP_MODE_STYLE(wxLC_SMALL_ICON
, LVS_SMALLICON
)
327 MAP_MODE_STYLE(wxLC_LIST
, LVS_LIST
)
328 MAP_MODE_STYLE(wxLC_REPORT
, LVS_REPORT
)
330 wxASSERT_MSG( nModes
== 1,
331 wxT("wxListCtrl style should have exactly one mode bit set") );
333 #undef MAP_MODE_STYLE
335 if ( style
& wxLC_ALIGN_LEFT
)
336 wstyle
|= LVS_ALIGNLEFT
;
338 if ( style
& wxLC_ALIGN_TOP
)
339 wstyle
|= LVS_ALIGNTOP
;
341 if ( style
& wxLC_AUTOARRANGE
)
342 wstyle
|= LVS_AUTOARRANGE
;
344 if ( style
& wxLC_NO_SORT_HEADER
)
345 wstyle
|= LVS_NOSORTHEADER
;
347 if ( style
& wxLC_NO_HEADER
)
348 wstyle
|= LVS_NOCOLUMNHEADER
;
350 if ( style
& wxLC_EDIT_LABELS
)
351 wstyle
|= LVS_EDITLABELS
;
353 if ( style
& wxLC_SINGLE_SEL
)
354 wstyle
|= LVS_SINGLESEL
;
356 if ( style
& wxLC_SORT_ASCENDING
)
358 wstyle
|= LVS_SORTASCENDING
;
360 wxASSERT_MSG( !(style
& wxLC_SORT_DESCENDING
),
361 wxT("can't sort in ascending and descending orders at once") );
363 else if ( style
& wxLC_SORT_DESCENDING
)
364 wstyle
|= LVS_SORTDESCENDING
;
366 #if !( defined(__GNUWIN32__) && !wxCHECK_W32API_VERSION( 1, 0 ) )
367 if ( style
& wxLC_VIRTUAL
)
369 int ver
= wxApp
::GetComCtl32Version();
372 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."),
373 ver
/ 100, ver
% 100);
376 wstyle
|= LVS_OWNERDATA
;
378 #endif // ancient cygwin
383 void wxListCtrl
::UpdateStyle()
387 // The new window view style
388 DWORD dwStyleNew
= MSWGetStyle(m_windowStyle
, NULL
);
390 // some styles are not returned by MSWGetStyle()
392 dwStyleNew
|= WS_VISIBLE
;
394 // Get the current window style.
395 DWORD dwStyleOld
= ::GetWindowLong(GetHwnd(), GWL_STYLE
);
397 // we don't have wxVSCROLL style, but the list control may have it,
398 // don't change it then
399 dwStyleNew
|= dwStyleOld
& (WS_HSCROLL
| WS_VSCROLL
);
401 // Only set the window style if the view bits have changed.
402 if ( dwStyleOld
!= dwStyleNew
)
404 ::SetWindowLong(GetHwnd(), GWL_STYLE
, dwStyleNew
);
406 // if we switched to the report view, set the extended styles for
408 if ( !(dwStyleOld
& LVS_REPORT
) && (dwStyleNew
& LVS_REPORT
) )
409 MSWSetExListStyles();
414 void wxListCtrl
::FreeAllInternalData()
416 const unsigned count
= m_internalData
.size();
417 for ( unsigned n
= 0; n
< count
; n
++ )
418 delete m_internalData
[n
];
420 m_internalData
.clear();
423 void wxListCtrl
::DeleteEditControl()
427 m_textCtrl
->UnsubclassWin();
428 m_textCtrl
->SetHWND(0);
429 wxDELETE(m_textCtrl
);
433 wxListCtrl
::~wxListCtrl()
435 FreeAllInternalData();
439 if (m_ownsImageListNormal
)
440 delete m_imageListNormal
;
441 if (m_ownsImageListSmall
)
442 delete m_imageListSmall
;
443 if (m_ownsImageListState
)
444 delete m_imageListState
;
447 // ----------------------------------------------------------------------------
448 // set/get/change style
449 // ----------------------------------------------------------------------------
451 // Add or remove a single window style
452 void wxListCtrl
::SetSingleStyle(long style
, bool add
)
454 long flag
= GetWindowStyleFlag();
456 // Get rid of conflicting styles
459 if ( style
& wxLC_MASK_TYPE
)
460 flag
= flag
& ~wxLC_MASK_TYPE
;
461 if ( style
& wxLC_MASK_ALIGN
)
462 flag
= flag
& ~wxLC_MASK_ALIGN
;
463 if ( style
& wxLC_MASK_SORT
)
464 flag
= flag
& ~wxLC_MASK_SORT
;
472 SetWindowStyleFlag(flag
);
475 // Set the whole window style
476 void wxListCtrl
::SetWindowStyleFlag(long flag
)
478 if ( flag
!= m_windowStyle
)
480 wxControl
::SetWindowStyleFlag(flag
);
488 // ----------------------------------------------------------------------------
490 // ----------------------------------------------------------------------------
492 /* static */ wxVisualAttributes
493 wxListCtrl
::GetClassDefaultAttributes(wxWindowVariant variant
)
495 wxVisualAttributes attrs
= GetCompositeControlsDefaultAttributes(variant
);
497 // common controls have their own default font
498 attrs
.font
= wxGetCCDefaultFont();
503 // Sets the foreground, i.e. text, colour
504 bool wxListCtrl
::SetForegroundColour(const wxColour
& col
)
506 if ( !wxWindow
::SetForegroundColour(col
) )
509 ListView_SetTextColor(GetHwnd(), wxColourToRGB(col
));
514 // Sets the background colour
515 bool wxListCtrl
::SetBackgroundColour(const wxColour
& col
)
517 if ( !wxWindow
::SetBackgroundColour(col
) )
520 // we set the same colour for both the "empty" background and the items
522 COLORREF color
= wxColourToRGB(col
);
523 ListView_SetBkColor(GetHwnd(), color
);
524 ListView_SetTextBkColor(GetHwnd(), color
);
529 // Gets information about this column
530 bool wxListCtrl
::GetColumn(int col
, wxListItem
& item
) const
535 lvCol
.mask
= LVCF_WIDTH
;
537 if ( item
.m_mask
& wxLIST_MASK_TEXT
)
539 lvCol
.mask
|= LVCF_TEXT
;
540 lvCol
.pszText
= new wxChar
[513];
541 lvCol
.cchTextMax
= 512;
544 if ( item
.m_mask
& wxLIST_MASK_FORMAT
)
546 lvCol
.mask
|= LVCF_FMT
;
549 if ( item
.m_mask
& wxLIST_MASK_IMAGE
)
551 lvCol
.mask
|= LVCF_IMAGE
;
554 bool success
= ListView_GetColumn(GetHwnd(), col
, &lvCol
) != 0;
556 // item.m_subItem = lvCol.iSubItem;
557 item
.m_width
= lvCol
.cx
;
559 if ( (item
.m_mask
& wxLIST_MASK_TEXT
) && lvCol
.pszText
)
561 item
.m_text
= lvCol
.pszText
;
562 delete[] lvCol
.pszText
;
565 if ( item
.m_mask
& wxLIST_MASK_FORMAT
)
567 switch (lvCol
.fmt
& LVCFMT_JUSTIFYMASK
) {
569 item
.m_format
= wxLIST_FORMAT_LEFT
;
572 item
.m_format
= wxLIST_FORMAT_RIGHT
;
575 item
.m_format
= wxLIST_FORMAT_CENTRE
;
578 item
.m_format
= -1; // Unknown?
583 // the column images were not supported in older versions but how to check
584 // for this? we can't use _WIN32_IE because we always define it to a very
585 // high value, so see if another symbol which is only defined starting from
586 // comctl32.dll 4.70 is available
587 #ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
588 if ( item
.m_mask
& wxLIST_MASK_IMAGE
)
590 item
.m_image
= lvCol
.iImage
;
592 #endif // LVCOLUMN::iImage exists
597 // Sets information about this column
598 bool wxListCtrl
::SetColumn(int col
, const wxListItem
& item
)
601 wxConvertToMSWListCol(GetHwnd(), col
, item
, lvCol
);
603 return ListView_SetColumn(GetHwnd(), col
, &lvCol
) != 0;
606 // Gets the column width
607 int wxListCtrl
::GetColumnWidth(int col
) const
609 return ListView_GetColumnWidth(GetHwnd(), col
);
612 // Sets the column width
613 bool wxListCtrl
::SetColumnWidth(int col
, int width
)
615 if ( m_windowStyle
& wxLC_LIST
)
618 if ( width
== wxLIST_AUTOSIZE
)
619 width
= LVSCW_AUTOSIZE
;
620 else if ( width
== wxLIST_AUTOSIZE_USEHEADER
)
621 width
= LVSCW_AUTOSIZE_USEHEADER
;
623 return ListView_SetColumnWidth(GetHwnd(), col
, width
) != 0;
626 // ----------------------------------------------------------------------------
628 // ----------------------------------------------------------------------------
630 int wxListCtrl
::GetColumnIndexFromOrder(int order
) const
632 const int numCols
= GetColumnCount();
633 wxCHECK_MSG( order
>= 0 && order
< numCols
, -1,
634 wxT("Column position out of bounds") );
636 wxArrayInt
indexArray(numCols
);
637 if ( !ListView_GetColumnOrderArray(GetHwnd(), numCols
, &indexArray
[0]) )
640 return indexArray
[order
];
643 int wxListCtrl
::GetColumnOrder(int col
) const
645 const int numCols
= GetColumnCount();
646 wxASSERT_MSG( col
>= 0 && col
< numCols
, wxT("Column index out of bounds") );
648 wxArrayInt
indexArray(numCols
);
649 if ( !ListView_GetColumnOrderArray(GetHwnd(), numCols
, &indexArray
[0]) )
652 for ( int pos
= 0; pos
< numCols
; pos
++ )
654 if ( indexArray
[pos
] == col
)
658 wxFAIL_MSG( wxT("no column with with given order?") );
663 // Gets the column order for all columns
664 wxArrayInt wxListCtrl
::GetColumnsOrder() const
666 const int numCols
= GetColumnCount();
668 wxArrayInt
orders(numCols
);
669 if ( !ListView_GetColumnOrderArray(GetHwnd(), numCols
, &orders
[0]) )
675 // Sets the column order for all columns
676 bool wxListCtrl
::SetColumnsOrder(const wxArrayInt
& orders
)
678 const int numCols
= GetColumnCount();
680 wxCHECK_MSG( orders
.size() == (size_t)numCols
, false,
681 wxT("wrong number of elements in column orders array") );
683 return ListView_SetColumnOrderArray(GetHwnd(), numCols
, &orders
[0]) != 0;
687 // Gets the number of items that can fit vertically in the
688 // visible area of the list control (list or report view)
689 // or the total number of items in the list control (icon
690 // or small icon view)
691 int wxListCtrl
::GetCountPerPage() const
693 return ListView_GetCountPerPage(GetHwnd());
696 // Gets the edit control for editing labels.
697 wxTextCtrl
* wxListCtrl
::GetEditControl() const
699 // first check corresponds to the case when the label editing was started
700 // by user and hence m_textCtrl wasn't created by EditLabel() at all, while
701 // the second case corresponds to us being called from inside EditLabel()
702 // (e.g. from a user wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT handler): in this
703 // case EditLabel() did create the control but it didn't have an HWND to
704 // initialize it with yet
705 if ( !m_textCtrl
|| !m_textCtrl
->GetHWND() )
707 HWND hwndEdit
= ListView_GetEditControl(GetHwnd());
710 wxListCtrl
* const self
= const_cast<wxListCtrl
*>(this);
713 self
->m_textCtrl
= new wxTextCtrl
;
714 self
->InitEditControl((WXHWND
)hwndEdit
);
721 // Gets information about the item
722 bool wxListCtrl
::GetItem(wxListItem
& info
) const
725 wxZeroMemory(lvItem
);
727 lvItem
.iItem
= info
.m_itemId
;
728 lvItem
.iSubItem
= info
.m_col
;
730 if ( info
.m_mask
& wxLIST_MASK_TEXT
)
732 lvItem
.mask
|= LVIF_TEXT
;
733 lvItem
.pszText
= new wxChar
[513];
734 lvItem
.cchTextMax
= 512;
738 lvItem
.pszText
= NULL
;
741 if (info
.m_mask
& wxLIST_MASK_DATA
)
742 lvItem
.mask
|= LVIF_PARAM
;
744 if (info
.m_mask
& wxLIST_MASK_IMAGE
)
745 lvItem
.mask
|= LVIF_IMAGE
;
747 if ( info
.m_mask
& wxLIST_MASK_STATE
)
749 lvItem
.mask
|= LVIF_STATE
;
750 wxConvertToMSWFlags(0, info
.m_stateMask
, lvItem
);
753 bool success
= ListView_GetItem((HWND
)GetHWND(), &lvItem
) != 0;
756 wxLogError(_("Couldn't retrieve information about list control item %d."),
761 // give NULL as hwnd as we already have everything we need
762 wxConvertFromMSWListItem(NULL
, info
, lvItem
);
766 delete[] lvItem
.pszText
;
771 // Sets information about the item
772 bool wxListCtrl
::SetItem(wxListItem
& info
)
774 const long id
= info
.GetId();
775 wxCHECK_MSG( id
>= 0 && id
< GetItemCount(), false,
776 wxT("invalid item index in SetItem") );
779 wxConvertToMSWListItem(this, info
, item
);
781 // we never update the lParam if it contains our pointer
782 // to the wxMSWListItemData structure
783 item
.mask
&= ~LVIF_PARAM
;
785 // check if setting attributes or lParam
786 if ( info
.HasAttributes() || (info
.m_mask
& wxLIST_MASK_DATA
) )
788 // get internal item data
789 wxMSWListItemData
*data
= MSWGetItemData(id
);
793 // need to allocate the internal data object
794 data
= new wxMSWListItemData
;
795 m_internalData
.push_back(data
);
796 item
.lParam
= (LPARAM
) data
;
797 item
.mask
|= LVIF_PARAM
;
802 if ( info
.m_mask
& wxLIST_MASK_DATA
)
803 data
->lParam
= info
.m_data
;
806 if ( info
.HasAttributes() )
808 const wxListItemAttr
& attrNew
= *info
.GetAttributes();
810 // don't overwrite the already set attributes if we have them
812 data
->attr
->AssignFrom(attrNew
);
814 data
->attr
= new wxListItemAttr(attrNew
);
819 // we could be changing only the attribute in which case we don't need to
820 // call ListView_SetItem() at all
823 if ( !ListView_SetItem(GetHwnd(), &item
) )
825 wxLogDebug(wxT("ListView_SetItem() failed"));
831 // we need to update the item immediately to show the new image
832 bool updateNow
= (info
.m_mask
& wxLIST_MASK_IMAGE
) != 0;
834 // check whether it has any custom attributes
835 if ( info
.HasAttributes() )
839 // if the colour has changed, we must redraw the item
845 // we need this to make the change visible right now
846 RefreshItem(item
.iItem
);
852 long wxListCtrl
::SetItem(long index
, int col
, const wxString
& label
, int imageId
)
856 info
.m_mask
= wxLIST_MASK_TEXT
;
857 info
.m_itemId
= index
;
861 info
.m_image
= imageId
;
862 info
.m_mask
|= wxLIST_MASK_IMAGE
;
864 return SetItem(info
);
868 // Gets the item state
869 int wxListCtrl
::GetItemState(long item
, long stateMask
) const
873 info
.m_mask
= wxLIST_MASK_STATE
;
874 info
.m_stateMask
= stateMask
;
875 info
.m_itemId
= item
;
883 // Sets the item state
884 bool wxListCtrl
::SetItemState(long item
, long state
, long stateMask
)
886 // NB: don't use SetItem() here as it doesn't work with the virtual list
889 wxZeroMemory(lvItem
);
891 wxConvertToMSWFlags(state
, stateMask
, lvItem
);
893 const bool changingFocus
= (stateMask
& wxLIST_STATE_FOCUSED
) &&
894 (state
& wxLIST_STATE_FOCUSED
);
896 // for the virtual list controls we need to refresh the previously focused
897 // item manually when changing focus without changing selection
898 // programmatically because otherwise it keeps its focus rectangle until
899 // next repaint (yet another comctl32 bug)
901 if ( IsVirtual() && changingFocus
)
903 focusOld
= GetNextItem(-1, wxLIST_NEXT_ALL
, wxLIST_STATE_FOCUSED
);
910 if ( !::SendMessage(GetHwnd(), LVM_SETITEMSTATE
,
911 (WPARAM
)item
, (LPARAM
)&lvItem
) )
913 wxLogLastError(wxT("ListView_SetItemState"));
918 if ( focusOld
!= -1 )
920 // no need to refresh the item if it was previously selected, it would
921 // only result in annoying flicker
922 if ( !(GetItemState(focusOld
,
923 wxLIST_STATE_SELECTED
) & wxLIST_STATE_SELECTED
) )
925 RefreshItem(focusOld
);
929 // we expect the selection anchor, i.e. the item from which multiple
930 // selection (such as performed with e.g. Shift-arrows) starts, to be the
931 // same as the currently focused item but the native control doesn't update
932 // it when we change focus and leaves at the last item it set itself focus
933 // to, so do it explicitly
934 if ( changingFocus
&& !HasFlag(wxLC_SINGLE_SEL
) )
936 ListView_SetSelectionMark(GetHwnd(), item
);
942 // Sets the item image
943 bool wxListCtrl
::SetItemImage(long item
, int image
, int WXUNUSED(selImage
))
945 return SetItemColumnImage(item
, 0, image
);
948 // Sets the item image
949 bool wxListCtrl
::SetItemColumnImage(long item
, long column
, int image
)
953 info
.m_mask
= wxLIST_MASK_IMAGE
;
954 info
.m_image
= image
;
955 info
.m_itemId
= item
;
958 return SetItem(info
);
961 // Gets the item text
962 wxString wxListCtrl
::GetItemText(long item
, int col
) const
966 info
.m_mask
= wxLIST_MASK_TEXT
;
967 info
.m_itemId
= item
;
971 return wxEmptyString
;
975 // Sets the item text
976 void wxListCtrl
::SetItemText(long item
, const wxString
& str
)
980 info
.m_mask
= wxLIST_MASK_TEXT
;
981 info
.m_itemId
= item
;
987 // Gets the internal item data
988 wxMSWListItemData
*wxListCtrl
::MSWGetItemData(long itemId
) const
991 it
.mask
= LVIF_PARAM
;
994 if ( !ListView_GetItem(GetHwnd(), &it
) )
997 return (wxMSWListItemData
*) it
.lParam
;
1000 // Gets the item data
1001 wxUIntPtr wxListCtrl
::GetItemData(long item
) const
1005 info
.m_mask
= wxLIST_MASK_DATA
;
1006 info
.m_itemId
= item
;
1013 // Sets the item data
1014 bool wxListCtrl
::SetItemPtrData(long item
, wxUIntPtr data
)
1018 info
.m_mask
= wxLIST_MASK_DATA
;
1019 info
.m_itemId
= item
;
1022 return SetItem(info
);
1025 wxRect wxListCtrl
::GetViewRect() const
1029 // ListView_GetViewRect() can only be used in icon and small icon views
1030 // (this is documented in MSDN and, indeed, it returns bogus results in
1031 // report view, at least with comctl32.dll v6 under Windows 2003)
1032 if ( HasFlag(wxLC_ICON
| wxLC_SMALL_ICON
) )
1035 if ( !ListView_GetViewRect(GetHwnd(), &rc
) )
1037 wxLogDebug(wxT("ListView_GetViewRect() failed."));
1042 wxCopyRECTToRect(rc
, rect
);
1044 else if ( HasFlag(wxLC_REPORT
) )
1046 const long count
= GetItemCount();
1049 GetItemRect(wxMin(GetTopItem() + GetCountPerPage(), count
- 1), rect
);
1051 // extend the rectangle to start at the top (we include the column
1052 // headers, if any, for compatibility with the generic version)
1053 rect
.height
+= rect
.y
;
1059 wxFAIL_MSG( wxT("not implemented in this mode") );
1065 // Gets the item rectangle
1066 bool wxListCtrl
::GetItemRect(long item
, wxRect
& rect
, int code
) const
1068 return GetSubItemRect( item
, wxLIST_GETSUBITEMRECT_WHOLEITEM
, rect
, code
) ;
1071 bool wxListCtrl
::GetSubItemRect(long item
, long subItem
, wxRect
& rect
, int code
) const
1073 // ListView_GetSubItemRect() doesn't do subItem error checking and returns
1074 // true even for the out of range values of it (even if the results are
1075 // completely bogus in this case), so we check item validity ourselves
1076 wxCHECK_MSG( subItem
== wxLIST_GETSUBITEMRECT_WHOLEITEM
||
1077 (subItem
>= 0 && subItem
< GetColumnCount()),
1078 false, wxT("invalid sub item index") );
1080 // use wxCHECK_MSG against "item" too, for coherency with the generic implementation:
1081 wxCHECK_MSG( item
>= 0 && item
< GetItemCount(), false,
1082 wxT("invalid item in GetSubItemRect") );
1085 if ( code
== wxLIST_RECT_BOUNDS
)
1086 codeWin
= LVIR_BOUNDS
;
1087 else if ( code
== wxLIST_RECT_ICON
)
1088 codeWin
= LVIR_ICON
;
1089 else if ( code
== wxLIST_RECT_LABEL
)
1090 codeWin
= LVIR_LABEL
;
1093 wxFAIL_MSG( wxT("incorrect code in GetItemRect() / GetSubItemRect()") );
1094 codeWin
= LVIR_BOUNDS
;
1098 if ( !wxGetListCtrlSubItemRect
1102 subItem
== wxLIST_GETSUBITEMRECT_WHOLEITEM ?
0 : subItem
,
1110 wxCopyRECTToRect(rectWin
, rect
);
1112 // there is no way to retrieve the first sub item bounding rectangle using
1113 // wxGetListCtrlSubItemRect() as 0 means the whole item, so we need to
1114 // truncate it at first column ourselves
1115 if ( subItem
== 0 && code
== wxLIST_RECT_BOUNDS
)
1116 rect
.width
= GetColumnWidth(0);
1124 // Gets the item position
1125 bool wxListCtrl
::GetItemPosition(long item
, wxPoint
& pos
) const
1129 bool success
= (ListView_GetItemPosition(GetHwnd(), (int) item
, &pt
) != 0);
1131 pos
.x
= pt
.x
; pos
.y
= pt
.y
;
1135 // Sets the item position.
1136 bool wxListCtrl
::SetItemPosition(long item
, const wxPoint
& pos
)
1138 return (ListView_SetItemPosition(GetHwnd(), (int) item
, pos
.x
, pos
.y
) != 0);
1141 // Gets the number of items in the list control
1142 int wxListCtrl
::GetItemCount() const
1147 wxSize wxListCtrl
::GetItemSpacing() const
1149 const int spacing
= ListView_GetItemSpacing(GetHwnd(), (BOOL
)HasFlag(wxLC_SMALL_ICON
));
1151 return wxSize(LOWORD(spacing
), HIWORD(spacing
));
1154 #if WXWIN_COMPATIBILITY_2_6
1156 int wxListCtrl
::GetItemSpacing(bool isSmall
) const
1158 return ListView_GetItemSpacing(GetHwnd(), (BOOL
) isSmall
);
1161 #endif // WXWIN_COMPATIBILITY_2_6
1163 void wxListCtrl
::SetItemTextColour( long item
, const wxColour
&col
)
1166 info
.m_itemId
= item
;
1167 info
.SetTextColour( col
);
1171 wxColour wxListCtrl
::GetItemTextColour( long item
) const
1174 wxMSWListItemData
*data
= MSWGetItemData(item
);
1175 if ( data
&& data
->attr
)
1176 col
= data
->attr
->GetTextColour();
1181 void wxListCtrl
::SetItemBackgroundColour( long item
, const wxColour
&col
)
1184 info
.m_itemId
= item
;
1185 info
.SetBackgroundColour( col
);
1189 wxColour wxListCtrl
::GetItemBackgroundColour( long item
) const
1192 wxMSWListItemData
*data
= MSWGetItemData(item
);
1193 if ( data
&& data
->attr
)
1194 col
= data
->attr
->GetBackgroundColour();
1199 void wxListCtrl
::SetItemFont( long item
, const wxFont
&f
)
1202 info
.m_itemId
= item
;
1207 wxFont wxListCtrl
::GetItemFont( long item
) const
1210 wxMSWListItemData
*data
= MSWGetItemData(item
);
1211 if ( data
&& data
->attr
)
1212 f
= data
->attr
->GetFont();
1217 // Gets the number of selected items in the list control
1218 int wxListCtrl
::GetSelectedItemCount() const
1220 return ListView_GetSelectedCount(GetHwnd());
1223 // Gets the text colour of the listview
1224 wxColour wxListCtrl
::GetTextColour() const
1226 COLORREF ref
= ListView_GetTextColor(GetHwnd());
1227 wxColour
col(GetRValue(ref
), GetGValue(ref
), GetBValue(ref
));
1231 // Sets the text colour of the listview
1232 void wxListCtrl
::SetTextColour(const wxColour
& col
)
1234 ListView_SetTextColor(GetHwnd(), PALETTERGB(col
.Red(), col
.Green(), col
.Blue()));
1237 // Gets the index of the topmost visible item when in
1238 // list or report view
1239 long wxListCtrl
::GetTopItem() const
1241 return (long) ListView_GetTopIndex(GetHwnd());
1244 // Searches for an item, starting from 'item'.
1245 // 'geometry' is one of
1246 // wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT.
1247 // 'state' is a state bit flag, one or more of
1248 // wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT.
1249 // item can be -1 to find the first item that matches the
1251 // Returns the item or -1 if unsuccessful.
1252 long wxListCtrl
::GetNextItem(long item
, int geom
, int state
) const
1256 if ( geom
== wxLIST_NEXT_ABOVE
)
1257 flags
|= LVNI_ABOVE
;
1258 if ( geom
== wxLIST_NEXT_ALL
)
1260 if ( geom
== wxLIST_NEXT_BELOW
)
1261 flags
|= LVNI_BELOW
;
1262 if ( geom
== wxLIST_NEXT_LEFT
)
1263 flags
|= LVNI_TOLEFT
;
1264 if ( geom
== wxLIST_NEXT_RIGHT
)
1265 flags
|= LVNI_TORIGHT
;
1267 if ( state
& wxLIST_STATE_CUT
)
1269 if ( state
& wxLIST_STATE_DROPHILITED
)
1270 flags
|= LVNI_DROPHILITED
;
1271 if ( state
& wxLIST_STATE_FOCUSED
)
1272 flags
|= LVNI_FOCUSED
;
1273 if ( state
& wxLIST_STATE_SELECTED
)
1274 flags
|= LVNI_SELECTED
;
1276 return (long) ListView_GetNextItem(GetHwnd(), item
, flags
);
1280 wxImageList
*wxListCtrl
::GetImageList(int which
) const
1282 if ( which
== wxIMAGE_LIST_NORMAL
)
1284 return m_imageListNormal
;
1286 else if ( which
== wxIMAGE_LIST_SMALL
)
1288 return m_imageListSmall
;
1290 else if ( which
== wxIMAGE_LIST_STATE
)
1292 return m_imageListState
;
1297 void wxListCtrl
::SetImageList(wxImageList
*imageList
, int which
)
1300 if ( which
== wxIMAGE_LIST_NORMAL
)
1302 flags
= LVSIL_NORMAL
;
1303 if (m_ownsImageListNormal
) delete m_imageListNormal
;
1304 m_imageListNormal
= imageList
;
1305 m_ownsImageListNormal
= false;
1307 else if ( which
== wxIMAGE_LIST_SMALL
)
1309 flags
= LVSIL_SMALL
;
1310 if (m_ownsImageListSmall
) delete m_imageListSmall
;
1311 m_imageListSmall
= imageList
;
1312 m_ownsImageListSmall
= false;
1314 else if ( which
== wxIMAGE_LIST_STATE
)
1316 flags
= LVSIL_STATE
;
1317 if (m_ownsImageListState
) delete m_imageListState
;
1318 m_imageListState
= imageList
;
1319 m_ownsImageListState
= false;
1321 (void) ListView_SetImageList(GetHwnd(), (HIMAGELIST
) imageList ? imageList
->GetHIMAGELIST() : 0, flags
);
1324 void wxListCtrl
::AssignImageList(wxImageList
*imageList
, int which
)
1326 SetImageList(imageList
, which
);
1327 if ( which
== wxIMAGE_LIST_NORMAL
)
1328 m_ownsImageListNormal
= true;
1329 else if ( which
== wxIMAGE_LIST_SMALL
)
1330 m_ownsImageListSmall
= true;
1331 else if ( which
== wxIMAGE_LIST_STATE
)
1332 m_ownsImageListState
= true;
1335 // ----------------------------------------------------------------------------
1337 // ----------------------------------------------------------------------------
1339 // Arranges the items
1340 bool wxListCtrl
::Arrange(int flag
)
1343 if ( flag
== wxLIST_ALIGN_LEFT
)
1344 code
= LVA_ALIGNLEFT
;
1345 else if ( flag
== wxLIST_ALIGN_TOP
)
1346 code
= LVA_ALIGNTOP
;
1347 else if ( flag
== wxLIST_ALIGN_DEFAULT
)
1349 else if ( flag
== wxLIST_ALIGN_SNAP_TO_GRID
)
1350 code
= LVA_SNAPTOGRID
;
1352 return (ListView_Arrange(GetHwnd(), code
) != 0);
1356 bool wxListCtrl
::DeleteItem(long item
)
1358 if ( !ListView_DeleteItem(GetHwnd(), (int) item
) )
1360 wxLogLastError(wxT("ListView_DeleteItem"));
1365 wxASSERT_MSG( m_count
== ListView_GetItemCount(GetHwnd()),
1366 wxT("m_count should match ListView_GetItemCount"));
1368 // the virtual list control doesn't refresh itself correctly, help it
1371 // we need to refresh all the lines below the one which was deleted
1373 if ( item
> 0 && GetItemCount() )
1375 GetItemRect(item
- 1, rectItem
);
1380 rectItem
.height
= 0;
1383 wxRect rectWin
= GetRect();
1384 rectWin
.height
= rectWin
.GetBottom() - rectItem
.GetBottom();
1385 rectWin
.y
= rectItem
.GetBottom();
1387 RefreshRect(rectWin
);
1393 // Deletes all items
1394 bool wxListCtrl
::DeleteAllItems()
1396 // Calling ListView_DeleteAllItems() will always generate an event but we
1397 // shouldn't do it if the control is empty
1398 return !GetItemCount() || ListView_DeleteAllItems(GetHwnd()) != 0;
1401 // Deletes all items
1402 bool wxListCtrl
::DeleteAllColumns()
1404 while ( m_colCount
> 0 )
1406 if ( ListView_DeleteColumn(GetHwnd(), 0) == 0 )
1408 wxLogLastError(wxT("ListView_DeleteColumn"));
1416 wxASSERT_MSG( m_colCount
== 0, wxT("no columns should be left") );
1422 bool wxListCtrl
::DeleteColumn(int col
)
1424 bool success
= (ListView_DeleteColumn(GetHwnd(), col
) != 0);
1426 if ( success
&& (m_colCount
> 0) )
1431 // Clears items, and columns if there are any.
1432 void wxListCtrl
::ClearAll()
1435 if ( m_colCount
> 0 )
1439 void wxListCtrl
::InitEditControl(WXHWND hWnd
)
1441 m_textCtrl
->SetHWND(hWnd
);
1442 m_textCtrl
->SubclassWin(hWnd
);
1443 m_textCtrl
->SetParent(this);
1445 // we must disallow TABbing away from the control while the edit control is
1446 // shown because this leaves it in some strange state (just try removing
1447 // this line and then pressing TAB while editing an item in listctrl
1449 m_textCtrl
->SetWindowStyle(m_textCtrl
->GetWindowStyle() | wxTE_PROCESS_TAB
);
1452 wxTextCtrl
* wxListCtrl
::EditLabel(long item
, wxClassInfo
* textControlClass
)
1454 wxCHECK_MSG( textControlClass
->IsKindOf(CLASSINFO(wxTextCtrl
)), NULL
,
1455 "control used for label editing must be a wxTextCtrl" );
1457 // ListView_EditLabel requires that the list has focus.
1460 // create m_textCtrl here before calling ListView_EditLabel() because it
1461 // generates wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT event from inside it and
1462 // the user handler for it can call GetEditControl() resulting in an on
1463 // demand creation of a stock wxTextCtrl instead of the control of a
1464 // (possibly) custom wxClassInfo
1465 DeleteEditControl();
1466 m_textCtrl
= (wxTextCtrl
*)textControlClass
->CreateObject();
1468 WXHWND hWnd
= (WXHWND
) ListView_EditLabel(GetHwnd(), item
);
1471 // failed to start editing
1472 wxDELETE(m_textCtrl
);
1477 // if GetEditControl() hasn't been called, we need to initialize the edit
1478 // control ourselves
1479 if ( !m_textCtrl
->GetHWND() )
1480 InitEditControl(hWnd
);
1485 // End label editing, optionally cancelling the edit
1486 bool wxListCtrl
::EndEditLabel(bool cancel
)
1488 // m_textCtrl is not always ready, ie. in EVT_LIST_BEGIN_LABEL_EDIT
1489 HWND hwnd
= ListView_GetEditControl(GetHwnd());
1493 // Newer versions of Windows have a special ListView_CancelEditLabel()
1494 // message for cancelling editing but it, rather counter-intuitively, keeps
1495 // the last text entered in the dialog while cancelling as we do it below
1496 // restores the original text which is the more expected behaviour.
1498 // We shouldn't destroy the control ourselves according to MSDN, which
1499 // proposes WM_CANCELMODE to do this, but it doesn't seem to work so
1500 // emulate the corresponding user action instead.
1501 ::SendMessage(hwnd
, WM_KEYDOWN
, cancel ? VK_ESCAPE
: VK_RETURN
, 0);
1506 // Ensures this item is visible
1507 bool wxListCtrl
::EnsureVisible(long item
)
1509 return ListView_EnsureVisible(GetHwnd(), (int) item
, FALSE
) != FALSE
;
1512 // Find an item whose label matches this string, starting from the item after 'start'
1513 // or the beginning if 'start' is -1.
1514 long wxListCtrl
::FindItem(long start
, const wxString
& str
, bool partial
)
1516 LV_FINDINFO findInfo
;
1518 findInfo
.flags
= LVFI_STRING
;
1520 findInfo
.flags
|= LVFI_PARTIAL
;
1521 findInfo
.psz
= str
.wx_str();
1523 // ListView_FindItem() excludes the first item from search and to look
1524 // through all the items you need to start from -1 which is unnatural and
1525 // inconsistent with the generic version - so we adjust the index
1528 return ListView_FindItem(GetHwnd(), start
, &findInfo
);
1531 // Find an item whose data matches this data, starting from the item after
1532 // 'start' or the beginning if 'start' is -1.
1533 long wxListCtrl
::FindItem(long start
, wxUIntPtr data
)
1535 // we can't use ListView_FindItem() directly as we don't store the data
1536 // pointer itself in the control but rather our own internal data, so first
1537 // we need to find the right value to search for (and there can be several
1539 int idx
= wxNOT_FOUND
;
1540 const unsigned count
= m_internalData
.size();
1541 for ( unsigned n
= 0; n
< count
; n
++ )
1543 if ( m_internalData
[n
]->lParam
== (LPARAM
)data
)
1545 LV_FINDINFO findInfo
;
1546 findInfo
.flags
= LVFI_PARAM
;
1547 findInfo
.lParam
= (LPARAM
)wxPtrToUInt(m_internalData
[n
]);
1549 int rc
= ListView_FindItem(GetHwnd(), start
, &findInfo
);
1552 if ( idx
== wxNOT_FOUND
|| rc
< idx
)
1555 if ( idx
== start
+ 1 )
1557 // we can stop here, we don't risk finding a closer
1562 //else: this item is after the previously found one
1570 // Find an item nearest this position in the specified direction, starting from
1571 // the item after 'start' or the beginning if 'start' is -1.
1572 long wxListCtrl
::FindItem(long start
, const wxPoint
& pt
, int direction
)
1574 LV_FINDINFO findInfo
;
1576 findInfo
.flags
= LVFI_NEARESTXY
;
1577 findInfo
.pt
.x
= pt
.x
;
1578 findInfo
.pt
.y
= pt
.y
;
1579 findInfo
.vkDirection
= VK_RIGHT
;
1581 if ( direction
== wxLIST_FIND_UP
)
1582 findInfo
.vkDirection
= VK_UP
;
1583 else if ( direction
== wxLIST_FIND_DOWN
)
1584 findInfo
.vkDirection
= VK_DOWN
;
1585 else if ( direction
== wxLIST_FIND_LEFT
)
1586 findInfo
.vkDirection
= VK_LEFT
;
1587 else if ( direction
== wxLIST_FIND_RIGHT
)
1588 findInfo
.vkDirection
= VK_RIGHT
;
1590 return ListView_FindItem(GetHwnd(), start
, &findInfo
);
1593 // Determines which item (if any) is at the specified point,
1594 // giving details in 'flags' (see wxLIST_HITTEST_... flags above)
1596 wxListCtrl
::HitTest(const wxPoint
& point
, int& flags
, long *ptrSubItem
) const
1598 LV_HITTESTINFO hitTestInfo
;
1599 hitTestInfo
.pt
.x
= (int) point
.x
;
1600 hitTestInfo
.pt
.y
= (int) point
.y
;
1603 #ifdef LVM_SUBITEMHITTEST
1604 if ( ptrSubItem
&& wxApp
::GetComCtl32Version() >= 470 )
1606 item
= ListView_SubItemHitTest(GetHwnd(), &hitTestInfo
);
1607 *ptrSubItem
= hitTestInfo
.iSubItem
;
1610 #endif // LVM_SUBITEMHITTEST
1612 item
= ListView_HitTest(GetHwnd(), &hitTestInfo
);
1617 if ( hitTestInfo
.flags
& LVHT_ABOVE
)
1618 flags
|= wxLIST_HITTEST_ABOVE
;
1619 if ( hitTestInfo
.flags
& LVHT_BELOW
)
1620 flags
|= wxLIST_HITTEST_BELOW
;
1621 if ( hitTestInfo
.flags
& LVHT_TOLEFT
)
1622 flags
|= wxLIST_HITTEST_TOLEFT
;
1623 if ( hitTestInfo
.flags
& LVHT_TORIGHT
)
1624 flags
|= wxLIST_HITTEST_TORIGHT
;
1626 if ( hitTestInfo
.flags
& LVHT_NOWHERE
)
1627 flags
|= wxLIST_HITTEST_NOWHERE
;
1629 // note a bug or at least a very strange feature of comtl32.dll (tested
1630 // with version 4.0 under Win95 and 6.0 under Win 2003): if you click to
1631 // the right of the item label, ListView_HitTest() returns a combination of
1632 // LVHT_ONITEMICON, LVHT_ONITEMLABEL and LVHT_ONITEMSTATEICON -- filter out
1633 // the bits which don't make sense
1634 if ( hitTestInfo
.flags
& LVHT_ONITEMLABEL
)
1636 flags
|= wxLIST_HITTEST_ONITEMLABEL
;
1638 // do not translate LVHT_ONITEMICON here, as per above
1642 if ( hitTestInfo
.flags
& LVHT_ONITEMICON
)
1643 flags
|= wxLIST_HITTEST_ONITEMICON
;
1644 if ( hitTestInfo
.flags
& LVHT_ONITEMSTATEICON
)
1645 flags
|= wxLIST_HITTEST_ONITEMSTATEICON
;
1652 // Inserts an item, returning the index of the new item if successful,
1654 long wxListCtrl
::InsertItem(const wxListItem
& info
)
1656 wxASSERT_MSG( !IsVirtual(), wxT("can't be used with virtual controls") );
1659 wxConvertToMSWListItem(this, info
, item
);
1660 item
.mask
&= ~LVIF_PARAM
;
1662 // check whether we need to allocate our internal data
1663 bool needInternalData
= (info
.m_mask
& wxLIST_MASK_DATA
) ||
1664 info
.HasAttributes();
1665 if ( needInternalData
)
1667 item
.mask
|= LVIF_PARAM
;
1669 wxMSWListItemData
* const data
= new wxMSWListItemData
;
1670 m_internalData
.push_back(data
);
1671 item
.lParam
= (LPARAM
)data
;
1673 if ( info
.m_mask
& wxLIST_MASK_DATA
)
1674 data
->lParam
= info
.m_data
;
1676 // check whether it has any custom attributes
1677 if ( info
.HasAttributes() )
1679 // take copy of attributes
1680 data
->attr
= new wxListItemAttr(*info
.GetAttributes());
1682 // and remember that we have some now...
1683 m_hasAnyAttr
= true;
1687 const long rv
= ListView_InsertItem(GetHwnd(), & item
);
1689 // failing to insert the item is really unexpected
1690 wxCHECK_MSG( rv
!= -1, rv
, "failed to insert an item in wxListCtrl" );
1693 wxASSERT_MSG( m_count
== ListView_GetItemCount(GetHwnd()),
1694 wxT("m_count should match ListView_GetItemCount"));
1699 long wxListCtrl
::InsertItem(long index
, const wxString
& label
)
1702 info
.m_text
= label
;
1703 info
.m_mask
= wxLIST_MASK_TEXT
;
1704 info
.m_itemId
= index
;
1705 return InsertItem(info
);
1708 // Inserts an image item
1709 long wxListCtrl
::InsertItem(long index
, int imageIndex
)
1712 info
.m_image
= imageIndex
;
1713 info
.m_mask
= wxLIST_MASK_IMAGE
;
1714 info
.m_itemId
= index
;
1715 return InsertItem(info
);
1718 // Inserts an image/string item
1719 long wxListCtrl
::InsertItem(long index
, const wxString
& label
, int imageIndex
)
1722 info
.m_image
= imageIndex
;
1723 info
.m_text
= label
;
1724 info
.m_mask
= wxLIST_MASK_TEXT
;
1725 if (imageIndex
> -1)
1726 info
.m_mask
|= wxLIST_MASK_IMAGE
;
1727 info
.m_itemId
= index
;
1728 return InsertItem(info
);
1731 // For list view mode (only), inserts a column.
1732 long wxListCtrl
::InsertColumn(long col
, const wxListItem
& item
)
1735 wxConvertToMSWListCol(GetHwnd(), col
, item
, lvCol
);
1737 if ( !(lvCol
.mask
& LVCF_WIDTH
) )
1739 // always give some width to the new column: this one is compatible
1740 // with the generic version
1741 lvCol
.mask
|= LVCF_WIDTH
;
1745 long n
= ListView_InsertColumn(GetHwnd(), col
, &lvCol
);
1750 else // failed to insert?
1752 wxLogDebug(wxT("Failed to insert the column '%s' into listview!"),
1759 long wxListCtrl
::InsertColumn(long col
,
1760 const wxString
& heading
,
1765 item
.m_mask
= wxLIST_MASK_TEXT
| wxLIST_MASK_FORMAT
;
1766 item
.m_text
= heading
;
1769 item
.m_mask
|= wxLIST_MASK_WIDTH
;
1770 item
.m_width
= width
;
1772 item
.m_format
= format
;
1774 return InsertColumn(col
, item
);
1777 // scroll the control by the given number of pixels (exception: in list view,
1778 // dx is interpreted as number of columns)
1779 bool wxListCtrl
::ScrollList(int dx
, int dy
)
1781 if ( !ListView_Scroll(GetHwnd(), dx
, dy
) )
1783 wxLogDebug(wxT("ListView_Scroll(%d, %d) failed"), dx
, dy
);
1793 // fn is a function which takes 3 long arguments: item1, item2, data.
1794 // item1 is the long data associated with a first item (NOT the index).
1795 // item2 is the long data associated with a second item (NOT the index).
1796 // data is the same value as passed to SortItems.
1797 // The return value is a negative number if the first item should precede the second
1798 // item, a positive number of the second item should precede the first,
1799 // or zero if the two items are equivalent.
1801 // data is arbitrary data to be passed to the sort function.
1803 // Internal structures for proxying the user compare function
1804 // so that we can pass it the *real* user data
1806 // translate lParam data and call user func
1807 struct wxInternalDataSort
1809 wxListCtrlCompare user_fn
;
1813 int CALLBACK
wxInternalDataCompareFunc(LPARAM lParam1
, LPARAM lParam2
, LPARAM lParamSort
)
1815 wxInternalDataSort
* const internalData
= (wxInternalDataSort
*) lParamSort
;
1817 wxMSWListItemData
*data1
= (wxMSWListItemData
*) lParam1
;
1818 wxMSWListItemData
*data2
= (wxMSWListItemData
*) lParam2
;
1820 wxIntPtr d1
= (data1
== NULL ?
0 : data1
->lParam
);
1821 wxIntPtr d2
= (data2
== NULL ?
0 : data2
->lParam
);
1823 return internalData
->user_fn(d1
, d2
, internalData
->data
);
1827 bool wxListCtrl
::SortItems(wxListCtrlCompare fn
, wxIntPtr data
)
1829 wxInternalDataSort internalData
;
1830 internalData
.user_fn
= fn
;
1831 internalData
.data
= data
;
1833 // WPARAM cast is needed for mingw/cygwin
1834 if ( !ListView_SortItems(GetHwnd(),
1835 wxInternalDataCompareFunc
,
1836 (WPARAM
) &internalData
) )
1838 wxLogDebug(wxT("ListView_SortItems() failed"));
1848 // ----------------------------------------------------------------------------
1849 // message processing
1850 // ----------------------------------------------------------------------------
1852 bool wxListCtrl
::MSWShouldPreProcessMessage(WXMSG
* msg
)
1854 if ( msg
->message
== WM_KEYDOWN
)
1856 // Only eat VK_RETURN if not being used by the application in
1857 // conjunction with modifiers
1858 if ( msg
->wParam
== VK_RETURN
&& !wxIsAnyModifierDown() )
1860 // we need VK_RETURN to generate wxEVT_COMMAND_LIST_ITEM_ACTIVATED
1864 return wxControl
::MSWShouldPreProcessMessage(msg
);
1867 bool wxListCtrl
::MSWCommand(WXUINT cmd
, WXWORD id_
)
1869 const int id
= (signed short)id_
;
1870 if (cmd
== EN_UPDATE
)
1872 wxCommandEvent
event(wxEVT_COMMAND_TEXT_UPDATED
, id
);
1873 event
.SetEventObject( this );
1874 ProcessCommand(event
);
1877 else if (cmd
== EN_KILLFOCUS
)
1879 wxCommandEvent
event(wxEVT_KILL_FOCUS
, id
);
1880 event
.SetEventObject( this );
1881 ProcessCommand(event
);
1888 // utility used by wxListCtrl::MSWOnNotify and by wxDataViewHeaderWindowMSW::MSWOnNotify
1889 int WXDLLIMPEXP_CORE
wxMSWGetColumnClicked(NMHDR
*nmhdr
, POINT
*ptClick
)
1891 // find the column clicked: we have to search for it ourselves as the
1892 // notification message doesn't provide this info
1894 // where did the click occur?
1895 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
1896 if ( nmhdr
->code
== GN_CONTEXTMENU
)
1898 *ptClick
= ((NMRGINFO
*)nmhdr
)->ptAction
;
1901 #endif //__WXWINCE__
1903 wxGetCursorPosMSW(ptClick
);
1906 // we need to use listctrl coordinates for the event point so this is what
1907 // we return in ptClick, but for comparison with Header_GetItemRect()
1908 // result below we need to use header window coordinates
1909 POINT ptClickHeader
= *ptClick
;
1910 if ( !::ScreenToClient(nmhdr
->hwndFrom
, &ptClickHeader
) )
1912 wxLogLastError(wxT("ScreenToClient(listctrl header)"));
1915 if ( !::ScreenToClient(::GetParent(nmhdr
->hwndFrom
), ptClick
) )
1917 wxLogLastError(wxT("ScreenToClient(listctrl)"));
1920 const int colCount
= Header_GetItemCount(nmhdr
->hwndFrom
);
1921 for ( int col
= 0; col
< colCount
; col
++ )
1924 if ( Header_GetItemRect(nmhdr
->hwndFrom
, col
, &rect
) )
1926 if ( ::PtInRect(&rect
, ptClickHeader
) )
1936 bool wxListCtrl
::MSWOnNotify(int idCtrl
, WXLPARAM lParam
, WXLPARAM
*result
)
1939 // prepare the event
1940 // -----------------
1942 wxListEvent
event(wxEVT_NULL
, m_windowId
);
1943 event
.SetEventObject(this);
1945 wxEventType eventType
= wxEVT_NULL
;
1947 NMHDR
*nmhdr
= (NMHDR
*)lParam
;
1949 // if your compiler is as broken as this, you should really change it: this
1950 // code is needed for normal operation! #ifdef below is only useful for
1951 // automatic rebuilds which are done with a very old compiler version
1952 #ifdef HDN_BEGINTRACKA
1954 // check for messages from the header (in report view)
1955 HWND hwndHdr
= ListView_GetHeader(GetHwnd());
1957 // is it a message from the header?
1958 if ( nmhdr
->hwndFrom
== hwndHdr
)
1960 HD_NOTIFY
*nmHDR
= (HD_NOTIFY
*)nmhdr
;
1962 event
.m_itemIndex
= -1;
1964 bool ignore
= false;
1965 switch ( nmhdr
->code
)
1967 // yet another comctl32.dll bug: under NT/W2K it sends Unicode
1968 // TRACK messages even to ANSI programs: on my system I get
1969 // HDN_BEGINTRACKW and HDN_ENDTRACKA!
1971 // work around is to simply catch both versions and hope that it
1972 // works (why should this message exist in ANSI and Unicode is
1973 // beyond me as it doesn't deal with strings at all...)
1975 // another problem is that HDN_TRACK is not sent at all by header
1976 // with HDS_FULLDRAG style which is used by default by wxListCtrl
1977 // under recent Windows versions (starting from at least XP) so we
1978 // need to use HDN_ITEMCHANGING instead of it
1979 case HDN_BEGINTRACKA
:
1980 case HDN_BEGINTRACKW
:
1981 eventType
= wxEVT_COMMAND_LIST_COL_BEGIN_DRAG
;
1984 case HDN_ITEMCHANGING
:
1985 if ( eventType
== wxEVT_NULL
)
1987 if ( !nmHDR
->pitem
|| !(nmHDR
->pitem
->mask
& HDI_WIDTH
) )
1989 // something other than the width is being changed,
1995 // also ignore the events sent when the width didn't really
1996 // change: this is not just an optimization but also gets
1997 // rid of a useless and unexpected DRAGGING event which
1998 // would otherwise be sent after the END_DRAG one as we get
1999 // an HDN_ITEMCHANGING after HDN_ENDTRACK for some reason
2000 if ( nmHDR
->pitem
->cxy
== GetColumnWidth(nmHDR
->iItem
) )
2006 eventType
= wxEVT_COMMAND_LIST_COL_DRAGGING
;
2012 if ( eventType
== wxEVT_NULL
)
2013 eventType
= wxEVT_COMMAND_LIST_COL_END_DRAG
;
2015 event
.m_item
.m_width
= nmHDR
->pitem
->cxy
;
2016 event
.m_col
= nmHDR
->iItem
;
2019 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
2020 case GN_CONTEXTMENU
:
2021 #endif //__WXWINCE__
2026 eventType
= wxEVT_COMMAND_LIST_COL_RIGHT_CLICK
;
2027 event
.m_col
= wxMSWGetColumnClicked(nmhdr
, &ptClick
);
2028 event
.m_pointDrag
.x
= ptClick
.x
;
2029 event
.m_pointDrag
.y
= ptClick
.y
;
2033 case HDN_GETDISPINFOW
:
2034 // letting Windows XP handle this message results in mysterious
2035 // crashes in comctl32.dll seemingly because of bad message
2038 // I have no idea what is the real cause of the bug (which is,
2039 // just to make things interesting, impossible to reproduce
2040 // reliably) but ignoring all these messages does fix it and
2041 // doesn't seem to have any negative consequences
2049 return wxControl
::MSWOnNotify(idCtrl
, lParam
, result
);
2052 #endif // defined(HDN_BEGINTRACKA)
2053 if ( nmhdr
->hwndFrom
== GetHwnd() )
2055 // almost all messages use NM_LISTVIEW
2056 NM_LISTVIEW
*nmLV
= (NM_LISTVIEW
*)nmhdr
;
2058 const int iItem
= nmLV
->iItem
;
2061 // If we have a valid item then check if there is a data value
2062 // associated with it and put it in the event.
2063 if ( iItem
>= 0 && iItem
< GetItemCount() )
2065 wxMSWListItemData
*internaldata
=
2066 MSWGetItemData(iItem
);
2069 event
.m_item
.m_data
= internaldata
->lParam
;
2072 bool processed
= true;
2073 switch ( nmhdr
->code
)
2075 case LVN_BEGINRDRAG
:
2076 eventType
= wxEVT_COMMAND_LIST_BEGIN_RDRAG
;
2080 if ( eventType
== wxEVT_NULL
)
2082 eventType
= wxEVT_COMMAND_LIST_BEGIN_DRAG
;
2085 event
.m_itemIndex
= iItem
;
2086 event
.m_pointDrag
.x
= nmLV
->ptAction
.x
;
2087 event
.m_pointDrag
.y
= nmLV
->ptAction
.y
;
2090 // NB: we have to handle both *A and *W versions here because some
2091 // versions of comctl32.dll send ANSI messages even to the
2093 case LVN_BEGINLABELEDITA
:
2094 case LVN_BEGINLABELEDITW
:
2097 if ( nmhdr
->code
== LVN_BEGINLABELEDITA
)
2099 item
.Init(((LV_DISPINFOA
*)lParam
)->item
);
2101 else // LVN_BEGINLABELEDITW
2103 item
.Init(((LV_DISPINFOW
*)lParam
)->item
);
2106 eventType
= wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT
;
2107 wxConvertFromMSWListItem(GetHwnd(), event
.m_item
, item
);
2108 event
.m_itemIndex
= event
.m_item
.m_itemId
;
2112 case LVN_ENDLABELEDITA
:
2113 case LVN_ENDLABELEDITW
:
2116 if ( nmhdr
->code
== LVN_ENDLABELEDITA
)
2118 item
.Init(((LV_DISPINFOA
*)lParam
)->item
);
2120 else // LVN_ENDLABELEDITW
2122 item
.Init(((LV_DISPINFOW
*)lParam
)->item
);
2125 // was editing cancelled?
2126 const LV_ITEM
& lvi
= (LV_ITEM
)item
;
2127 if ( !lvi
.pszText
|| lvi
.iItem
== -1 )
2129 // EDIT control will be deleted by the list control
2130 // itself so prevent us from deleting it as well
2131 DeleteEditControl();
2133 event
.SetEditCanceled(true);
2136 eventType
= wxEVT_COMMAND_LIST_END_LABEL_EDIT
;
2137 wxConvertFromMSWListItem(NULL
, event
.m_item
, item
);
2138 event
.m_itemIndex
= event
.m_item
.m_itemId
;
2142 case LVN_COLUMNCLICK
:
2143 eventType
= wxEVT_COMMAND_LIST_COL_CLICK
;
2144 event
.m_itemIndex
= -1;
2145 event
.m_col
= nmLV
->iSubItem
;
2148 case LVN_DELETEALLITEMS
:
2149 eventType
= wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS
;
2150 event
.m_itemIndex
= -1;
2153 case LVN_DELETEITEM
:
2156 // this should be prevented by the post-processing code
2157 // below, but "just in case"
2161 eventType
= wxEVT_COMMAND_LIST_DELETE_ITEM
;
2162 event
.m_itemIndex
= iItem
;
2166 case LVN_INSERTITEM
:
2167 eventType
= wxEVT_COMMAND_LIST_INSERT_ITEM
;
2168 event
.m_itemIndex
= iItem
;
2171 case LVN_ITEMCHANGED
:
2172 // we translate this catch all message into more interesting
2173 // (and more easy to process) wxWidgets events
2175 // first of all, we deal with the state change events only and
2176 // only for valid items (item == -1 for the virtual list
2178 if ( nmLV
->uChanged
& LVIF_STATE
&& iItem
!= -1 )
2180 // temp vars for readability
2181 const UINT stOld
= nmLV
->uOldState
;
2182 const UINT stNew
= nmLV
->uNewState
;
2184 event
.m_item
.SetId(iItem
);
2185 event
.m_item
.SetMask(wxLIST_MASK_TEXT
|
2188 GetItem(event
.m_item
);
2190 // has the focus changed?
2191 if ( !(stOld
& LVIS_FOCUSED
) && (stNew
& LVIS_FOCUSED
) )
2193 eventType
= wxEVT_COMMAND_LIST_ITEM_FOCUSED
;
2194 event
.m_itemIndex
= iItem
;
2197 if ( (stNew
& LVIS_SELECTED
) != (stOld
& LVIS_SELECTED
) )
2199 if ( eventType
!= wxEVT_NULL
)
2201 // focus and selection have both changed: send the
2202 // focus event from here and the selection one
2204 event
.SetEventType(eventType
);
2205 (void)HandleWindowEvent(event
);
2207 else // no focus event to send
2209 // then need to set m_itemIndex as it wasn't done
2211 event
.m_itemIndex
= iItem
;
2214 eventType
= stNew
& LVIS_SELECTED
2215 ? wxEVT_COMMAND_LIST_ITEM_SELECTED
2216 : wxEVT_COMMAND_LIST_ITEM_DESELECTED
;
2220 if ( eventType
== wxEVT_NULL
)
2222 // not an interesting event for us
2230 LV_KEYDOWN
*info
= (LV_KEYDOWN
*)lParam
;
2231 WORD wVKey
= info
->wVKey
;
2233 // get the current selection
2234 long lItem
= GetNextItem(-1,
2236 wxLIST_STATE_SELECTED
);
2238 // <Enter> or <Space> activate the selected item if any (but
2239 // not with any modifiers as they have a predefined meaning
2242 (wVKey
== VK_RETURN
|| wVKey
== VK_SPACE
) &&
2243 !wxIsAnyModifierDown() )
2245 eventType
= wxEVT_COMMAND_LIST_ITEM_ACTIVATED
;
2249 eventType
= wxEVT_COMMAND_LIST_KEY_DOWN
;
2251 event
.m_code
= wxMSWKeyboard
::VKToWX(wVKey
);
2253 if ( event
.m_code
== WXK_NONE
)
2255 // We can't translate this to a standard key code,
2256 // until support for Unicode key codes is added to
2257 // wxListEvent we just ignore them.
2263 event
.m_item
.m_itemId
= lItem
;
2267 // fill the other fields too
2268 event
.m_item
.m_text
= GetItemText(lItem
);
2269 event
.m_item
.m_data
= GetItemData(lItem
);
2275 // if the user processes it in wxEVT_COMMAND_LEFT_CLICK(), don't do
2277 if ( wxControl
::MSWOnNotify(idCtrl
, lParam
, result
) )
2282 // else translate it into wxEVT_COMMAND_LIST_ITEM_ACTIVATED event
2283 // if it happened on an item (and not on empty place)
2290 eventType
= wxEVT_COMMAND_LIST_ITEM_ACTIVATED
;
2291 event
.m_itemIndex
= iItem
;
2292 event
.m_item
.m_text
= GetItemText(iItem
);
2293 event
.m_item
.m_data
= GetItemData(iItem
);
2296 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
2297 case GN_CONTEXTMENU
:
2298 #endif //__WXWINCE__
2300 // if the user processes it in wxEVT_COMMAND_RIGHT_CLICK(),
2301 // don't do anything else
2302 if ( wxControl
::MSWOnNotify(idCtrl
, lParam
, result
) )
2307 // else translate it into wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK event
2308 LV_HITTESTINFO lvhti
;
2309 wxZeroMemory(lvhti
);
2311 #if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
2312 if ( nmhdr
->code
== GN_CONTEXTMENU
)
2314 lvhti
.pt
= ((NMRGINFO
*)nmhdr
)->ptAction
;
2317 #endif //__WXWINCE__
2319 wxGetCursorPosMSW(&(lvhti
.pt
));
2322 ::ScreenToClient(GetHwnd(), &lvhti
.pt
);
2323 if ( ListView_HitTest(GetHwnd(), &lvhti
) != -1 )
2325 if ( lvhti
.flags
& LVHT_ONITEM
)
2327 eventType
= wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
;
2328 event
.m_itemIndex
= lvhti
.iItem
;
2329 event
.m_pointDrag
.x
= lvhti
.pt
.x
;
2330 event
.m_pointDrag
.y
= lvhti
.pt
.y
;
2335 #ifdef NM_CUSTOMDRAW
2337 *result
= OnCustomDraw(lParam
);
2339 return *result
!= CDRF_DODEFAULT
;
2340 #endif // _WIN32_IE >= 0x300
2342 case LVN_ODCACHEHINT
:
2344 const NM_CACHEHINT
*cacheHint
= (NM_CACHEHINT
*)lParam
;
2346 eventType
= wxEVT_COMMAND_LIST_CACHE_HINT
;
2348 // we get some really stupid cache hints like ones for
2349 // items in range 0..0 for an empty control or, after
2350 // deleting an item, for items in invalid range -- filter
2352 if ( cacheHint
->iFrom
> cacheHint
->iTo
)
2355 event
.m_oldItemIndex
= cacheHint
->iFrom
;
2357 const long iMax
= GetItemCount();
2358 event
.m_itemIndex
= cacheHint
->iTo
< iMax ? cacheHint
->iTo
2363 #ifdef HAVE_NMLVFINDITEM
2364 case LVN_ODFINDITEM
:
2365 // Find an item in a (necessarily virtual) list control.
2368 NMLVFINDITEM
* pFindInfo
= (NMLVFINDITEM
*)lParam
;
2370 // no match by default
2373 // we only handle string-based searches here
2375 // TODO: what about LVFI_PARTIAL, should we handle this?
2376 if ( !(pFindInfo
->lvfi
.flags
& LVFI_STRING
) )
2381 const wxChar
* const searchstr
= pFindInfo
->lvfi
.psz
;
2382 const size_t len
= wxStrlen(searchstr
);
2384 // this is the first item we should examine, search from it
2385 // wrapping if necessary
2386 int startPos
= pFindInfo
->iStart
;
2387 const int maxPos
= GetItemCount();
2389 // Check that the index is valid to ensure that our loop
2390 // below always terminates.
2391 if ( startPos
< 0 || startPos
>= maxPos
)
2393 // When the last item in the control is selected,
2394 // iStart is really set to (invalid) maxPos index so
2395 // accept this silently.
2396 if ( startPos
!= maxPos
)
2398 wxLogDebug(wxT("Ignoring invalid search start ")
2399 wxT("position %d in list control with ")
2400 wxT("%d items."), startPos
, maxPos
);
2406 // Linear search in a control with a lot of items can take
2407 // a long time so we limit the total time of the search to
2408 // ensure that the program doesn't appear to hang.
2411 #endif // wxUSE_STOPWATCH
2412 for ( int currentPos
= startPos
; ; )
2414 // does this item begin with searchstr?
2415 if ( wxStrnicmp(searchstr
,
2416 GetItemText(currentPos
), len
) == 0 )
2418 *result
= currentPos
;
2422 // Go to next item with wrapping if necessary.
2423 if ( ++currentPos
== maxPos
)
2425 // Surprisingly, LVFI_WRAP seems to be never set in
2426 // the flags so wrap regardless of it.
2430 if ( currentPos
== startPos
)
2432 // We examined all items without finding anything.
2434 // Notice that we still return true as we did
2435 // perform the search, if we didn't do this the
2436 // message would have been considered unhandled and
2437 // the control seems to always select the first
2438 // item by default in this case.
2443 // Check the time elapsed only every thousand
2444 // iterations for performance reasons: if we did it
2445 // more often calling wxStopWatch::Time() could take
2446 // noticeable time on its own.
2447 if ( !((currentPos
- startPos
)%1000) )
2449 // We use half a second to limit the search time
2450 // which is about as long as we can take without
2451 // annoying the user.
2452 if ( sw
.Time() > 500 )
2454 // As above, return true to prevent the control
2455 // from selecting the first item by default.
2459 #endif // wxUSE_STOPWATCH
2463 SetItemState(*result
,
2464 wxLIST_STATE_SELECTED
| wxLIST_STATE_FOCUSED
,
2465 wxLIST_STATE_SELECTED
| wxLIST_STATE_FOCUSED
);
2466 EnsureVisible(*result
);
2474 #endif // HAVE_NMLVFINDITEM
2476 case LVN_GETDISPINFO
:
2479 LV_DISPINFO
*info
= (LV_DISPINFO
*)lParam
;
2481 LV_ITEM
& lvi
= info
->item
;
2482 long item
= lvi
.iItem
;
2484 if ( lvi
.mask
& LVIF_TEXT
)
2486 wxString text
= OnGetItemText(item
, lvi
.iSubItem
);
2487 wxStrlcpy(lvi
.pszText
, text
.c_str(), lvi
.cchTextMax
);
2490 // see comment at the end of wxListCtrl::GetColumn()
2491 #ifdef NM_CUSTOMDRAW
2492 if ( lvi
.mask
& LVIF_IMAGE
)
2494 lvi
.iImage
= OnGetItemColumnImage(item
, lvi
.iSubItem
);
2496 #endif // NM_CUSTOMDRAW
2498 // even though we never use LVM_SETCALLBACKMASK, we still
2499 // can get messages with LVIF_STATE in lvi.mask under Vista
2500 if ( lvi
.mask
& LVIF_STATE
)
2502 // we don't have anything to return from here...
2515 return wxControl
::MSWOnNotify(idCtrl
, lParam
, result
);
2519 // where did this one come from?
2523 // process the event
2524 // -----------------
2526 event
.SetEventType(eventType
);
2528 // fill in the item before passing it to the event handler if we do have a
2529 // valid item index and haven't filled it yet (e.g. for LVN_ITEMCHANGED)
2530 if ( event
.m_itemIndex
!= -1 && !event
.m_item
.GetMask() )
2532 wxListItem
& item
= event
.m_item
;
2534 item
.SetId(event
.m_itemIndex
);
2535 item
.SetMask(wxLIST_MASK_TEXT
| wxLIST_MASK_IMAGE
| wxLIST_MASK_DATA
);
2539 bool processed
= HandleWindowEvent(event
);
2543 switch ( nmhdr
->code
)
2545 case LVN_DELETEALLITEMS
:
2546 // always return true to suppress all additional LVN_DELETEITEM
2547 // notifications - this makes deleting all items from a list ctrl
2551 // also, we may free all user data now (couldn't do it before as
2552 // the user should have access to it in OnDeleteAllItems() handler)
2553 FreeAllInternalData();
2555 // the control is empty now, synchronize the cached number of items
2556 // with the real one
2560 case LVN_DELETEITEM
:
2561 // Delete the associated internal data. Notice that this can be
2562 // done only after the event has been handled as the data could be
2563 // accessed during the handling of the event.
2564 if ( wxMSWListItemData
*data
= MSWGetItemData(event
.m_itemIndex
) )
2566 const unsigned count
= m_internalData
.size();
2567 for ( unsigned n
= 0; n
< count
; n
++ )
2569 if ( m_internalData
[n
] == data
)
2571 m_internalData
.erase(m_internalData
.begin() + n
);
2577 wxASSERT_MSG( !data
, "invalid internal data pointer?" );
2581 case LVN_ENDLABELEDITA
:
2582 case LVN_ENDLABELEDITW
:
2583 // logic here is inverted compared to all the other messages
2584 *result
= event
.IsAllowed();
2586 // EDIT control will be deleted by the list control itself so
2587 // prevent us from deleting it as well
2588 DeleteEditControl();
2594 *result
= !event
.IsAllowed();
2599 // ----------------------------------------------------------------------------
2600 // custom draw stuff
2601 // ----------------------------------------------------------------------------
2603 // see comment at the end of wxListCtrl::GetColumn()
2604 #ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
2606 static RECT
GetCustomDrawnItemRect(const NMCUSTOMDRAW
& nmcd
)
2609 wxGetListCtrlItemRect(nmcd
.hdr
.hwndFrom
, nmcd
.dwItemSpec
, LVIR_BOUNDS
, rc
);
2612 wxGetListCtrlItemRect(nmcd
.hdr
.hwndFrom
, nmcd
.dwItemSpec
, LVIR_ICON
, rcIcon
);
2614 // exclude the icon part, neither the selection background nor focus rect
2616 rc
.left
= rcIcon
.right
;
2622 bool HandleSubItemPrepaint(LPNMLVCUSTOMDRAW pLVCD
, HFONT hfont
, int colCount
)
2624 NMCUSTOMDRAW
& nmcd
= pLVCD
->nmcd
;
2627 HWND hwndList
= nmcd
.hdr
.hwndFrom
;
2628 const int col
= pLVCD
->iSubItem
;
2629 const DWORD item
= nmcd
.dwItemSpec
;
2631 // the font must be valid, otherwise we wouldn't be painting the item at all
2632 SelectInHDC
selFont(hdc
, hfont
);
2634 // get the rectangle to paint
2635 int subitem
= colCount ? col
+ 1 : col
;
2637 wxGetListCtrlSubItemRect(hwndList
, item
, subitem
, LVIR_BOUNDS
, rc
);
2640 // get the image and text to draw
2644 it
.mask
= LVIF_TEXT
| LVIF_IMAGE
;
2648 it
.cchTextMax
= WXSIZEOF(text
);
2649 ListView_GetItem(hwndList
, &it
);
2651 HIMAGELIST himl
= ListView_GetImageList(hwndList
, LVSIL_SMALL
);
2652 if ( himl
&& ImageList_GetImageCount(himl
) )
2654 if ( it
.iImage
!= -1 )
2656 ImageList_Draw(himl
, it
.iImage
, hdc
, rc
.left
, rc
.top
,
2657 nmcd
.uItemState
& CDIS_SELECTED ? ILD_SELECTED
2661 // notice that even if this item doesn't have any image, the list
2662 // control still leaves space for the image in the first column if the
2663 // image list is not empty (presumably so that items with and without
2665 if ( it
.iImage
!= -1 || it
.iSubItem
== 0 )
2668 ImageList_GetIconSize(himl
, &wImage
, &hImage
);
2670 rc
.left
+= wImage
+ 2;
2674 ::SetBkMode(hdc
, TRANSPARENT
);
2676 UINT fmt
= DT_SINGLELINE
|
2679 #endif // __WXWINCE__
2684 wxZeroMemory(lvCol
);
2685 lvCol
.mask
= LVCF_FMT
;
2686 if ( ListView_GetColumn(hwndList
, col
, &lvCol
) )
2688 switch ( lvCol
.fmt
& LVCFMT_JUSTIFYMASK
)
2703 //else: failed to get alignment, assume it's DT_LEFT (default)
2705 DrawText(hdc
, text
, -1, &rc
, fmt
);
2710 static void HandleItemPostpaint(NMCUSTOMDRAW nmcd
)
2712 if ( nmcd
.uItemState
& CDIS_FOCUS
)
2714 RECT rc
= GetCustomDrawnItemRect(nmcd
);
2716 // don't use the provided HDC, it's in some strange state by now
2717 ::DrawFocusRect(WindowHDC(nmcd
.hdr
.hwndFrom
), &rc
);
2721 // pLVCD->clrText and clrTextBk should contain the colours to use
2722 static void HandleItemPaint(LPNMLVCUSTOMDRAW pLVCD
, HFONT hfont
)
2724 NMCUSTOMDRAW
& nmcd
= pLVCD
->nmcd
; // just a shortcut
2726 const HWND hwndList
= nmcd
.hdr
.hwndFrom
;
2727 const int item
= nmcd
.dwItemSpec
;
2729 // unfortunately we can't trust CDIS_SELECTED, it is often set even when
2730 // the item is not at all selected for some reason (comctl32 6), but we
2731 // also can't always trust ListView_GetItem() as it could return the old
2732 // item status if we're called just after the (de)selection, so remember
2733 // the last item to gain selection and also check for it here
2734 for ( int i
= -1;; )
2736 i
= ListView_GetNextItem(hwndList
, i
, LVNI_SELECTED
);
2739 nmcd
.uItemState
&= ~CDIS_SELECTED
;
2745 nmcd
.uItemState
|= CDIS_SELECTED
;
2750 // same thing for CDIS_FOCUS (except simpler as there is only one of them)
2752 // NB: cast is needed to work around the bug in mingw32 headers which don't
2753 // have it inside ListView_GetNextItem() itself (unlike SDK ones)
2754 if ( ::GetFocus() == hwndList
&&
2755 ListView_GetNextItem(
2756 hwndList
, static_cast<WPARAM
>(-1), LVNI_FOCUSED
) == item
)
2758 nmcd
.uItemState
|= CDIS_FOCUS
;
2762 nmcd
.uItemState
&= ~CDIS_FOCUS
;
2765 if ( nmcd
.uItemState
& CDIS_SELECTED
)
2767 int syscolFg
, syscolBg
;
2768 if ( ::GetFocus() == hwndList
)
2770 syscolFg
= COLOR_HIGHLIGHTTEXT
;
2771 syscolBg
= COLOR_HIGHLIGHT
;
2773 else // selected but unfocused
2775 syscolFg
= COLOR_WINDOWTEXT
;
2776 syscolBg
= COLOR_BTNFACE
;
2778 // don't grey out the icon in this case neither
2779 nmcd
.uItemState
&= ~CDIS_SELECTED
;
2782 pLVCD
->clrText
= ::GetSysColor(syscolFg
);
2783 pLVCD
->clrTextBk
= ::GetSysColor(syscolBg
);
2785 //else: not selected, use normal colours from pLVCD
2788 RECT rc
= GetCustomDrawnItemRect(nmcd
);
2790 ::SetTextColor(hdc
, pLVCD
->clrText
);
2791 ::FillRect(hdc
, &rc
, AutoHBRUSH(pLVCD
->clrTextBk
));
2793 // we could use CDRF_NOTIFYSUBITEMDRAW here but it results in weird repaint
2794 // problems so just draw everything except the focus rect from here instead
2795 const int colCount
= Header_GetItemCount(ListView_GetHeader(hwndList
));
2796 for ( int col
= 0; col
< colCount
; col
++ )
2798 pLVCD
->iSubItem
= col
;
2799 HandleSubItemPrepaint(pLVCD
, hfont
, colCount
);
2802 HandleItemPostpaint(nmcd
);
2805 static WXLPARAM
HandleItemPrepaint(wxListCtrl
*listctrl
,
2806 LPNMLVCUSTOMDRAW pLVCD
,
2807 wxListItemAttr
*attr
)
2811 // nothing to do for this item
2812 return CDRF_DODEFAULT
;
2816 // set the colours to use for text drawing
2817 pLVCD
->clrText
= attr
->HasTextColour()
2818 ?
wxColourToRGB(attr
->GetTextColour())
2819 : wxColourToRGB(listctrl
->GetTextColour());
2820 pLVCD
->clrTextBk
= attr
->HasBackgroundColour()
2821 ?
wxColourToRGB(attr
->GetBackgroundColour())
2822 : wxColourToRGB(listctrl
->GetBackgroundColour());
2824 // select the font if non default one is specified
2825 if ( attr
->HasFont() )
2827 wxFont font
= attr
->GetFont();
2828 if ( font
.GetEncoding() != wxFONTENCODING_SYSTEM
)
2830 // the standard control ignores the font encoding/charset, at least
2831 // with recent comctl32.dll versions (5 and 6, it uses to work with
2832 // 4.something) so we have to draw the item entirely ourselves in
2834 HandleItemPaint(pLVCD
, GetHfontOf(font
));
2835 return CDRF_SKIPDEFAULT
;
2838 ::SelectObject(pLVCD
->nmcd
.hdc
, GetHfontOf(font
));
2840 return CDRF_NEWFONT
;
2843 return CDRF_DODEFAULT
;
2846 WXLPARAM wxListCtrl
::OnCustomDraw(WXLPARAM lParam
)
2848 LPNMLVCUSTOMDRAW pLVCD
= (LPNMLVCUSTOMDRAW
)lParam
;
2849 NMCUSTOMDRAW
& nmcd
= pLVCD
->nmcd
;
2850 switch ( nmcd
.dwDrawStage
)
2853 // if we've got any items with non standard attributes,
2854 // notify us before painting each item
2856 // for virtual controls, always suppose that we have attributes as
2857 // there is no way to check for this
2858 if ( IsVirtual() || m_hasAnyAttr
)
2859 return CDRF_NOTIFYITEMDRAW
;
2862 case CDDS_ITEMPREPAINT
:
2863 // get a message for each subitem
2864 return CDRF_NOTIFYITEMDRAW
;
2866 case CDDS_SUBITEM
| CDDS_ITEMPREPAINT
:
2867 const int item
= nmcd
.dwItemSpec
;
2868 const int column
= pLVCD
->iSubItem
;
2870 // we get this message with item == 0 for an empty control, we
2871 // must ignore it as calling OnGetItemAttr() would be wrong
2872 if ( item
< 0 || item
>= GetItemCount() )
2875 if ( column
< 0 || column
>= GetColumnCount() )
2878 return HandleItemPrepaint(this, pLVCD
, DoGetItemColumnAttr(item
, column
));
2881 return CDRF_DODEFAULT
;
2884 #endif // NM_CUSTOMDRAW supported
2886 // Necessary for drawing hrules and vrules, if specified
2887 void wxListCtrl
::OnPaint(wxPaintEvent
& event
)
2889 const int itemCount
= GetItemCount();
2890 const bool drawHRules
= HasFlag(wxLC_HRULES
);
2891 const bool drawVRules
= HasFlag(wxLC_VRULES
);
2893 if (!InReportView() || !(drawHRules
|| drawVRules
) || !itemCount
)
2901 wxControl
::OnPaint(event
);
2903 // Reset the device origin since it may have been set
2904 dc
.SetDeviceOrigin(0, 0);
2906 wxPen
pen(wxSystemSettings
::GetColour(wxSYS_COLOUR_3DLIGHT
));
2908 dc
.SetBrush(* wxTRANSPARENT_BRUSH
);
2910 wxSize clientSize
= GetClientSize();
2915 const long top
= GetTopItem();
2916 for ( int i
= top
; i
< top
+ GetCountPerPage() + 1; i
++ )
2918 if (GetItemRect(i
, itemRect
))
2920 int cy
= itemRect
.GetTop();
2921 if (i
!= 0) // Don't draw the first one
2923 dc
.DrawLine(0, cy
, clientSize
.x
, cy
);
2926 if (i
== itemCount
- 1)
2928 cy
= itemRect
.GetBottom();
2929 dc
.DrawLine(0, cy
, clientSize
.x
, cy
);
2938 wxRect firstItemRect
;
2939 GetItemRect(0, firstItemRect
);
2941 if (GetItemRect(itemCount
- 1, itemRect
))
2943 // this is a fix for bug 673394: erase the pixels which we would
2944 // otherwise leave on the screen
2945 static const int gap
= 2;
2946 dc
.SetPen(*wxTRANSPARENT_PEN
);
2947 dc
.SetBrush(wxBrush(GetBackgroundColour()));
2948 dc
.DrawRectangle(0, firstItemRect
.GetY() - gap
,
2949 clientSize
.GetWidth(), gap
);
2952 dc
.SetBrush(*wxTRANSPARENT_BRUSH
);
2954 const int numCols
= GetColumnCount();
2955 wxVector
<int> indexArray(numCols
);
2956 if ( !ListView_GetColumnOrderArray(GetHwnd(),
2960 wxFAIL_MSG( wxT("invalid column index array in OnPaint()") );
2964 int x
= itemRect
.GetX();
2965 for (int col
= 0; col
< numCols
; col
++)
2967 int colWidth
= GetColumnWidth(indexArray
[col
]);
2969 dc
.DrawLine(x
-1, firstItemRect
.GetY() - gap
,
2970 x
-1, itemRect
.GetBottom());
2977 wxListCtrl
::MSWWindowProc(WXUINT nMsg
, WXWPARAM wParam
, WXLPARAM lParam
)
2983 // we should bypass our own WM_PRINT handling as we don't handle
2984 // PRF_CHILDREN flag, so leave it to the native control itself
2985 return MSWDefWindowProc(nMsg
, wParam
, lParam
);
2988 case WM_CONTEXTMENU
:
2989 // because this message is propagated upwards the child-parent
2990 // chain, we get it for the right clicks on the header window but
2991 // this is confusing in wx as right clicking there already
2992 // generates a separate wxEVT_COMMAND_LIST_COL_RIGHT_CLICK event
2993 // so just ignore them
2994 if ( (HWND
)wParam
== ListView_GetHeader(GetHwnd()) )
2999 return wxControl
::MSWWindowProc(nMsg
, wParam
, lParam
);
3002 // ----------------------------------------------------------------------------
3003 // virtual list controls
3004 // ----------------------------------------------------------------------------
3006 wxString wxListCtrl
::OnGetItemText(long WXUNUSED(item
), long WXUNUSED(col
)) const
3008 // this is a pure virtual function, in fact - which is not really pure
3009 // because the controls which are not virtual don't need to implement it
3010 wxFAIL_MSG( wxT("wxListCtrl::OnGetItemText not supposed to be called") );
3012 return wxEmptyString
;
3015 int wxListCtrl
::OnGetItemImage(long WXUNUSED(item
)) const
3017 wxCHECK_MSG(!GetImageList(wxIMAGE_LIST_SMALL
),
3019 wxT("List control has an image list, OnGetItemImage or OnGetItemColumnImage should be overridden."));
3023 int wxListCtrl
::OnGetItemColumnImage(long item
, long column
) const
3026 return OnGetItemImage(item
);
3031 wxListItemAttr
*wxListCtrl
::OnGetItemAttr(long WXUNUSED_UNLESS_DEBUG(item
)) const
3033 wxASSERT_MSG( item
>= 0 && item
< GetItemCount(),
3034 wxT("invalid item index in OnGetItemAttr()") );
3036 // no attributes by default
3040 wxListItemAttr
*wxListCtrl
::DoGetItemColumnAttr(long item
, long column
) const
3043 return OnGetItemColumnAttr(item
, column
);
3045 wxMSWListItemData
* const data
= MSWGetItemData(item
);
3046 return data ? data
->attr
: NULL
;
3049 void wxListCtrl
::SetItemCount(long count
)
3051 wxASSERT_MSG( IsVirtual(), wxT("this is for virtual controls only") );
3053 if ( !::SendMessage(GetHwnd(), LVM_SETITEMCOUNT
, (WPARAM
)count
,
3054 LVSICF_NOSCROLL
| LVSICF_NOINVALIDATEALL
) )
3056 wxLogLastError(wxT("ListView_SetItemCount"));
3059 wxASSERT_MSG( m_count
== ListView_GetItemCount(GetHwnd()),
3060 wxT("m_count should match ListView_GetItemCount"));
3063 void wxListCtrl
::RefreshItem(long item
)
3065 RefreshItems(item
, item
);
3068 void wxListCtrl
::RefreshItems(long itemFrom
, long itemTo
)
3070 ListView_RedrawItems(GetHwnd(), itemFrom
, itemTo
);
3073 // ----------------------------------------------------------------------------
3074 // wxWin <-> MSW items conversions
3075 // ----------------------------------------------------------------------------
3077 static void wxConvertFromMSWListItem(HWND hwndListCtrl
,
3081 wxMSWListItemData
*internaldata
=
3082 (wxMSWListItemData
*) lvItem
.lParam
;
3085 info
.m_data
= internaldata
->lParam
;
3089 info
.m_stateMask
= 0;
3090 info
.m_itemId
= lvItem
.iItem
;
3092 long oldMask
= lvItem
.mask
;
3094 bool needText
= false;
3095 if (hwndListCtrl
!= 0)
3097 if ( lvItem
.mask
& LVIF_TEXT
)
3104 lvItem
.pszText
= new wxChar
[513];
3105 lvItem
.cchTextMax
= 512;
3107 lvItem
.mask
|= LVIF_TEXT
| LVIF_IMAGE
| LVIF_PARAM
;
3108 ::SendMessage(hwndListCtrl
, LVM_GETITEM
, 0, (LPARAM
)& lvItem
);
3111 if ( lvItem
.mask
& LVIF_STATE
)
3113 info
.m_mask
|= wxLIST_MASK_STATE
;
3115 if ( lvItem
.stateMask
& LVIS_CUT
)
3117 info
.m_stateMask
|= wxLIST_STATE_CUT
;
3118 if ( lvItem
.state
& LVIS_CUT
)
3119 info
.m_state
|= wxLIST_STATE_CUT
;
3121 if ( lvItem
.stateMask
& LVIS_DROPHILITED
)
3123 info
.m_stateMask
|= wxLIST_STATE_DROPHILITED
;
3124 if ( lvItem
.state
& LVIS_DROPHILITED
)
3125 info
.m_state
|= wxLIST_STATE_DROPHILITED
;
3127 if ( lvItem
.stateMask
& LVIS_FOCUSED
)
3129 info
.m_stateMask
|= wxLIST_STATE_FOCUSED
;
3130 if ( lvItem
.state
& LVIS_FOCUSED
)
3131 info
.m_state
|= wxLIST_STATE_FOCUSED
;
3133 if ( lvItem
.stateMask
& LVIS_SELECTED
)
3135 info
.m_stateMask
|= wxLIST_STATE_SELECTED
;
3136 if ( lvItem
.state
& LVIS_SELECTED
)
3137 info
.m_state
|= wxLIST_STATE_SELECTED
;
3141 if ( lvItem
.mask
& LVIF_TEXT
)
3143 info
.m_mask
|= wxLIST_MASK_TEXT
;
3144 info
.m_text
= lvItem
.pszText
;
3146 if ( lvItem
.mask
& LVIF_IMAGE
)
3148 info
.m_mask
|= wxLIST_MASK_IMAGE
;
3149 info
.m_image
= lvItem
.iImage
;
3151 if ( lvItem
.mask
& LVIF_PARAM
)
3152 info
.m_mask
|= wxLIST_MASK_DATA
;
3153 if ( lvItem
.mask
& LVIF_DI_SETITEM
)
3154 info
.m_mask
|= wxLIST_SET_ITEM
;
3155 info
.m_col
= lvItem
.iSubItem
;
3160 delete[] lvItem
.pszText
;
3162 lvItem
.mask
= oldMask
;
3165 static void wxConvertToMSWFlags(long state
, long stateMask
, LV_ITEM
& lvItem
)
3167 if (stateMask
& wxLIST_STATE_CUT
)
3169 lvItem
.stateMask
|= LVIS_CUT
;
3170 if (state
& wxLIST_STATE_CUT
)
3171 lvItem
.state
|= LVIS_CUT
;
3173 if (stateMask
& wxLIST_STATE_DROPHILITED
)
3175 lvItem
.stateMask
|= LVIS_DROPHILITED
;
3176 if (state
& wxLIST_STATE_DROPHILITED
)
3177 lvItem
.state
|= LVIS_DROPHILITED
;
3179 if (stateMask
& wxLIST_STATE_FOCUSED
)
3181 lvItem
.stateMask
|= LVIS_FOCUSED
;
3182 if (state
& wxLIST_STATE_FOCUSED
)
3183 lvItem
.state
|= LVIS_FOCUSED
;
3185 if (stateMask
& wxLIST_STATE_SELECTED
)
3187 lvItem
.stateMask
|= LVIS_SELECTED
;
3188 if (state
& wxLIST_STATE_SELECTED
)
3189 lvItem
.state
|= LVIS_SELECTED
;
3193 static void wxConvertToMSWListItem(const wxListCtrl
*ctrl
,
3194 const wxListItem
& info
,
3197 if ( ctrl
->InReportView() )
3199 wxASSERT_MSG( 0 <= info
.m_col
&& info
.m_col
< ctrl
->GetColumnCount(),
3200 "wxListCtrl column index out of bounds" );
3202 else // not in report view
3204 wxASSERT_MSG( info
.m_col
== 0, "columns only exist in report view" );
3207 lvItem
.iItem
= (int) info
.m_itemId
;
3209 lvItem
.iImage
= info
.m_image
;
3210 lvItem
.stateMask
= 0;
3213 lvItem
.iSubItem
= info
.m_col
;
3215 if (info
.m_mask
& wxLIST_MASK_STATE
)
3217 lvItem
.mask
|= LVIF_STATE
;
3219 wxConvertToMSWFlags(info
.m_state
, info
.m_stateMask
, lvItem
);
3222 if (info
.m_mask
& wxLIST_MASK_TEXT
)
3224 lvItem
.mask
|= LVIF_TEXT
;
3225 if ( ctrl
->HasFlag(wxLC_USER_TEXT
) )
3227 lvItem
.pszText
= LPSTR_TEXTCALLBACK
;
3231 // pszText is not const, hence the cast
3232 lvItem
.pszText
= (wxChar
*)info
.m_text
.wx_str();
3233 if ( lvItem
.pszText
)
3234 lvItem
.cchTextMax
= info
.m_text
.length();
3236 lvItem
.cchTextMax
= 0;
3239 if (info
.m_mask
& wxLIST_MASK_IMAGE
)
3240 lvItem
.mask
|= LVIF_IMAGE
;
3243 static void wxConvertToMSWListCol(HWND hwndList
,
3245 const wxListItem
& item
,
3248 wxZeroMemory(lvCol
);
3250 if ( item
.m_mask
& wxLIST_MASK_TEXT
)
3252 lvCol
.mask
|= LVCF_TEXT
;
3253 lvCol
.pszText
= (wxChar
*)item
.m_text
.wx_str(); // cast is safe
3256 if ( item
.m_mask
& wxLIST_MASK_FORMAT
)
3258 lvCol
.mask
|= LVCF_FMT
;
3260 if ( item
.m_format
== wxLIST_FORMAT_LEFT
)
3261 lvCol
.fmt
= LVCFMT_LEFT
;
3262 else if ( item
.m_format
== wxLIST_FORMAT_RIGHT
)
3263 lvCol
.fmt
= LVCFMT_RIGHT
;
3264 else if ( item
.m_format
== wxLIST_FORMAT_CENTRE
)
3265 lvCol
.fmt
= LVCFMT_CENTER
;
3268 if ( item
.m_mask
& wxLIST_MASK_WIDTH
)
3270 lvCol
.mask
|= LVCF_WIDTH
;
3271 if ( item
.m_width
== wxLIST_AUTOSIZE
)
3272 lvCol
.cx
= LVSCW_AUTOSIZE
;
3273 else if ( item
.m_width
== wxLIST_AUTOSIZE_USEHEADER
)
3274 lvCol
.cx
= LVSCW_AUTOSIZE_USEHEADER
;
3276 lvCol
.cx
= item
.m_width
;
3279 // see comment at the end of wxListCtrl::GetColumn()
3280 #ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
3281 if ( item
.m_mask
& wxLIST_MASK_IMAGE
)
3283 if ( wxApp
::GetComCtl32Version() >= 470 )
3285 lvCol
.mask
|= LVCF_IMAGE
;
3287 // we use LVCFMT_BITMAP_ON_RIGHT because the images on the right
3288 // seem to be generally nicer than on the left and the generic
3289 // version only draws them on the right (we don't have a flag to
3290 // specify the image location anyhow)
3292 // we don't use LVCFMT_COL_HAS_IMAGES because it doesn't seem to
3293 // make any difference in my tests -- but maybe we should?
3294 if ( item
.m_image
!= -1 )
3296 // as we're going to overwrite the format field, get its
3297 // current value first -- unless we want to overwrite it anyhow
3298 if ( !(lvCol
.mask
& LVCF_FMT
) )
3301 wxZeroMemory(lvColOld
);
3302 lvColOld
.mask
= LVCF_FMT
;
3303 if ( ListView_GetColumn(hwndList
, col
, &lvColOld
) )
3305 lvCol
.fmt
= lvColOld
.fmt
;
3308 lvCol
.mask
|= LVCF_FMT
;
3311 lvCol
.fmt
|= LVCFMT_BITMAP_ON_RIGHT
| LVCFMT_IMAGE
;
3314 lvCol
.iImage
= item
.m_image
;
3316 //else: it doesn't support item images anyhow
3318 #endif // _WIN32_IE >= 0x0300
3321 #endif // wxUSE_LISTCTRL