+bool wxListCtrl::SortItems(wxListCtrlCompare fn, wxIntPtr data)
+{
+ wxInternalDataSort internalData;
+ internalData.user_fn = fn;
+ internalData.data = data;
+
+ // WPARAM cast is needed for mingw/cygwin
+ if ( !ListView_SortItems(GetHwnd(),
+ wxInternalDataCompareFunc,
+ (WPARAM) &internalData) )
+ {
+ wxLogDebug(wxT("ListView_SortItems() failed"));
+
+ return false;
+ }
+
+ return true;
+}
+
+
+
+// ----------------------------------------------------------------------------
+// message processing
+// ----------------------------------------------------------------------------
+
+bool wxListCtrl::MSWShouldPreProcessMessage(WXMSG* msg)
+{
+ if ( msg->message == WM_KEYDOWN )
+ {
+ // Only eat VK_RETURN if not being used by the application in
+ // conjunction with modifiers
+ if ( msg->wParam == VK_RETURN && !wxIsAnyModifierDown() )
+ {
+ // we need VK_RETURN to generate wxEVT_COMMAND_LIST_ITEM_ACTIVATED
+ return false;
+ }
+ }
+ return wxControl::MSWShouldPreProcessMessage(msg);
+}
+
+bool wxListCtrl::MSWCommand(WXUINT cmd, WXWORD id_)
+{
+ const int id = (signed short)id_;
+ if (cmd == EN_UPDATE)
+ {
+ wxCommandEvent event(wxEVT_COMMAND_TEXT_UPDATED, id);
+ event.SetEventObject( this );
+ ProcessCommand(event);
+ return true;
+ }
+ else if (cmd == EN_KILLFOCUS)
+ {
+ wxCommandEvent event(wxEVT_KILL_FOCUS, id);
+ event.SetEventObject( this );
+ ProcessCommand(event);
+ return true;
+ }
+ else
+ return false;
+}
+
+// utility used by wxListCtrl::MSWOnNotify and by wxDataViewHeaderWindowMSW::MSWOnNotify
+int WXDLLIMPEXP_CORE wxMSWGetColumnClicked(NMHDR *nmhdr, POINT *ptClick)
+{
+ // find the column clicked: we have to search for it ourselves as the
+ // notification message doesn't provide this info
+
+ // where did the click occur?
+#if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
+ if ( nmhdr->code == GN_CONTEXTMENU )
+ {
+ *ptClick = ((NMRGINFO*)nmhdr)->ptAction;
+ }
+ else
+#endif //__WXWINCE__
+ if ( !::GetCursorPos(ptClick) )
+ {
+ wxLogLastError(wxT("GetCursorPos"));
+ }
+
+ // we need to use listctrl coordinates for the event point so this is what
+ // we return in ptClick, but for comparison with Header_GetItemRect()
+ // result below we need to use header window coordinates
+ POINT ptClickHeader = *ptClick;
+ if ( !::ScreenToClient(nmhdr->hwndFrom, &ptClickHeader) )
+ {
+ wxLogLastError(wxT("ScreenToClient(listctrl header)"));
+ }
+
+ if ( !::ScreenToClient(::GetParent(nmhdr->hwndFrom), ptClick) )
+ {
+ wxLogLastError(wxT("ScreenToClient(listctrl)"));
+ }
+
+ const int colCount = Header_GetItemCount(nmhdr->hwndFrom);
+ for ( int col = 0; col < colCount; col++ )
+ {
+ RECT rect;
+ if ( Header_GetItemRect(nmhdr->hwndFrom, col, &rect) )
+ {
+ if ( ::PtInRect(&rect, ptClickHeader) )
+ {
+ return col;
+ }
+ }
+ }
+
+ return wxNOT_FOUND;
+}
+
+bool wxListCtrl::MSWOnNotify(int idCtrl, WXLPARAM lParam, WXLPARAM *result)
+{
+
+ // prepare the event
+ // -----------------
+
+ wxListEvent event(wxEVT_NULL, m_windowId);
+ event.SetEventObject(this);
+
+ wxEventType eventType = wxEVT_NULL;
+
+ NMHDR *nmhdr = (NMHDR *)lParam;
+
+ // if your compiler is as broken as this, you should really change it: this
+ // code is needed for normal operation! #ifdef below is only useful for
+ // automatic rebuilds which are done with a very old compiler version
+#ifdef HDN_BEGINTRACKA
+
+ // check for messages from the header (in report view)
+ HWND hwndHdr = ListView_GetHeader(GetHwnd());
+
+ // is it a message from the header?
+ if ( nmhdr->hwndFrom == hwndHdr )
+ {
+ HD_NOTIFY *nmHDR = (HD_NOTIFY *)nmhdr;
+
+ event.m_itemIndex = -1;
+
+ bool ignore = false;
+ switch ( nmhdr->code )
+ {
+ // yet another comctl32.dll bug: under NT/W2K it sends Unicode
+ // TRACK messages even to ANSI programs: on my system I get
+ // HDN_BEGINTRACKW and HDN_ENDTRACKA!
+ //
+ // work around is to simply catch both versions and hope that it
+ // works (why should this message exist in ANSI and Unicode is
+ // beyond me as it doesn't deal with strings at all...)
+ //
+ // another problem is that HDN_TRACK is not sent at all by header
+ // with HDS_FULLDRAG style which is used by default by wxListCtrl
+ // under recent Windows versions (starting from at least XP) so we
+ // need to use HDN_ITEMCHANGING instead of it
+ case HDN_BEGINTRACKA:
+ case HDN_BEGINTRACKW:
+ eventType = wxEVT_COMMAND_LIST_COL_BEGIN_DRAG;
+ // fall through
+
+ case HDN_ITEMCHANGING:
+ if ( eventType == wxEVT_NULL )
+ {
+ if ( !nmHDR->pitem || !(nmHDR->pitem->mask & HDI_WIDTH) )
+ {
+ // something other than the width is being changed,
+ // ignore it
+ ignore = true;
+ break;
+ }
+
+ // also ignore the events sent when the width didn't really
+ // change: this is not just an optimization but also gets
+ // rid of a useless and unexpected DRAGGING event which
+ // would otherwise be sent after the END_DRAG one as we get
+ // an HDN_ITEMCHANGING after HDN_ENDTRACK for some reason
+ if ( nmHDR->pitem->cxy == GetColumnWidth(nmHDR->iItem) )
+ {
+ ignore = true;
+ break;
+ }
+
+ eventType = wxEVT_COMMAND_LIST_COL_DRAGGING;
+ }
+ // fall through
+
+ case HDN_ENDTRACKA:
+ case HDN_ENDTRACKW:
+ if ( eventType == wxEVT_NULL )
+ eventType = wxEVT_COMMAND_LIST_COL_END_DRAG;
+
+ event.m_item.m_width = nmHDR->pitem->cxy;
+ event.m_col = nmHDR->iItem;
+ break;
+
+#if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
+ case GN_CONTEXTMENU:
+#endif //__WXWINCE__
+ case NM_RCLICK:
+ {
+ POINT ptClick;
+
+ eventType = wxEVT_COMMAND_LIST_COL_RIGHT_CLICK;
+ event.m_col = wxMSWGetColumnClicked(nmhdr, &ptClick);
+ event.m_pointDrag.x = ptClick.x;
+ event.m_pointDrag.y = ptClick.y;
+ }
+ break;
+
+ case HDN_GETDISPINFOW:
+ // letting Windows XP handle this message results in mysterious
+ // crashes in comctl32.dll seemingly because of bad message
+ // parameters
+ //
+ // I have no idea what is the real cause of the bug (which is,
+ // just to make things interesting, impossible to reproduce
+ // reliably) but ignoring all these messages does fix it and
+ // doesn't seem to have any negative consequences
+ return true;
+
+ default:
+ ignore = true;
+ }
+
+ if ( ignore )
+ return wxControl::MSWOnNotify(idCtrl, lParam, result);
+ }
+ else
+#endif // defined(HDN_BEGINTRACKA)
+ if ( nmhdr->hwndFrom == GetHwnd() )
+ {
+ // almost all messages use NM_LISTVIEW
+ NM_LISTVIEW *nmLV = (NM_LISTVIEW *)nmhdr;
+
+ const int iItem = nmLV->iItem;
+
+
+ // If we have a valid item then check if there is a data value
+ // associated with it and put it in the event.
+ if ( iItem >= 0 && iItem < GetItemCount() )
+ {
+ wxMSWListItemData *internaldata =
+ MSWGetItemData(iItem);
+
+ if ( internaldata )
+ event.m_item.m_data = internaldata->lParam;
+ }
+
+ bool processed = true;
+ switch ( nmhdr->code )
+ {
+ case LVN_BEGINRDRAG:
+ eventType = wxEVT_COMMAND_LIST_BEGIN_RDRAG;
+ // fall through
+
+ case LVN_BEGINDRAG:
+ if ( eventType == wxEVT_NULL )
+ {
+ eventType = wxEVT_COMMAND_LIST_BEGIN_DRAG;
+ }
+
+ event.m_itemIndex = iItem;
+ event.m_pointDrag.x = nmLV->ptAction.x;
+ event.m_pointDrag.y = nmLV->ptAction.y;
+ break;
+
+ // NB: we have to handle both *A and *W versions here because some
+ // versions of comctl32.dll send ANSI messages even to the
+ // Unicode windows
+ case LVN_BEGINLABELEDITA:
+ case LVN_BEGINLABELEDITW:
+ {
+ wxLV_ITEM item;
+ if ( nmhdr->code == LVN_BEGINLABELEDITA )
+ {
+ item.Init(((LV_DISPINFOA *)lParam)->item);
+ }
+ else // LVN_BEGINLABELEDITW
+ {
+ item.Init(((LV_DISPINFOW *)lParam)->item);
+ }
+
+ eventType = wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT;
+ wxConvertFromMSWListItem(GetHwnd(), event.m_item, item);
+ event.m_itemIndex = event.m_item.m_itemId;
+ }
+ break;
+
+ case LVN_ENDLABELEDITA:
+ case LVN_ENDLABELEDITW:
+ {
+ wxLV_ITEM item;
+ if ( nmhdr->code == LVN_ENDLABELEDITA )
+ {
+ item.Init(((LV_DISPINFOA *)lParam)->item);
+ }
+ else // LVN_ENDLABELEDITW
+ {
+ item.Init(((LV_DISPINFOW *)lParam)->item);
+ }
+
+ // was editing cancelled?
+ const LV_ITEM& lvi = (LV_ITEM)item;
+ if ( !lvi.pszText || lvi.iItem == -1 )
+ {
+ // EDIT control will be deleted by the list control
+ // itself so prevent us from deleting it as well
+ DeleteEditControl();
+
+ event.SetEditCanceled(true);
+ }
+
+ eventType = wxEVT_COMMAND_LIST_END_LABEL_EDIT;
+ wxConvertFromMSWListItem(NULL, event.m_item, item);
+ event.m_itemIndex = event.m_item.m_itemId;
+ }
+ break;
+
+ case LVN_COLUMNCLICK:
+ eventType = wxEVT_COMMAND_LIST_COL_CLICK;
+ event.m_itemIndex = -1;
+ event.m_col = nmLV->iSubItem;
+ break;
+
+ case LVN_DELETEALLITEMS:
+ eventType = wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS;
+ event.m_itemIndex = -1;
+ break;
+
+ case LVN_DELETEITEM:
+ if ( m_count == 0 )
+ {
+ // this should be prevented by the post-processing code
+ // below, but "just in case"
+ return false;
+ }
+
+ eventType = wxEVT_COMMAND_LIST_DELETE_ITEM;
+ event.m_itemIndex = iItem;
+
+ break;
+
+ case LVN_INSERTITEM:
+ eventType = wxEVT_COMMAND_LIST_INSERT_ITEM;
+ event.m_itemIndex = iItem;
+ break;
+
+ case LVN_ITEMCHANGED:
+ // we translate this catch all message into more interesting
+ // (and more easy to process) wxWidgets events
+
+ // first of all, we deal with the state change events only and
+ // only for valid items (item == -1 for the virtual list
+ // control)
+ if ( nmLV->uChanged & LVIF_STATE && iItem != -1 )
+ {
+ // temp vars for readability
+ const UINT stOld = nmLV->uOldState;
+ const UINT stNew = nmLV->uNewState;
+
+ event.m_item.SetId(iItem);
+ event.m_item.SetMask(wxLIST_MASK_TEXT |
+ wxLIST_MASK_IMAGE |
+ wxLIST_MASK_DATA);
+ GetItem(event.m_item);
+
+ // has the focus changed?
+ if ( !(stOld & LVIS_FOCUSED) && (stNew & LVIS_FOCUSED) )
+ {
+ eventType = wxEVT_COMMAND_LIST_ITEM_FOCUSED;
+ event.m_itemIndex = iItem;
+ }
+
+ if ( (stNew & LVIS_SELECTED) != (stOld & LVIS_SELECTED) )
+ {
+ if ( eventType != wxEVT_NULL )
+ {
+ // focus and selection have both changed: send the
+ // focus event from here and the selection one
+ // below
+ event.SetEventType(eventType);
+ (void)HandleWindowEvent(event);
+ }
+ else // no focus event to send
+ {
+ // then need to set m_itemIndex as it wasn't done
+ // above
+ event.m_itemIndex = iItem;
+ }
+
+ eventType = stNew & LVIS_SELECTED
+ ? wxEVT_COMMAND_LIST_ITEM_SELECTED
+ : wxEVT_COMMAND_LIST_ITEM_DESELECTED;
+ }
+ }
+
+ if ( eventType == wxEVT_NULL )
+ {
+ // not an interesting event for us
+ return false;
+ }
+
+ break;
+
+ case LVN_KEYDOWN:
+ {
+ LV_KEYDOWN *info = (LV_KEYDOWN *)lParam;
+ WORD wVKey = info->wVKey;
+
+ // get the current selection
+ long lItem = GetNextItem(-1,
+ wxLIST_NEXT_ALL,
+ wxLIST_STATE_SELECTED);
+
+ // <Enter> or <Space> activate the selected item if any (but
+ // not with any modifiers as they have a predefined meaning
+ // then)
+ if ( lItem != -1 &&
+ (wVKey == VK_RETURN || wVKey == VK_SPACE) &&
+ !wxIsAnyModifierDown() )
+ {
+ eventType = wxEVT_COMMAND_LIST_ITEM_ACTIVATED;
+ }
+ else
+ {
+ eventType = wxEVT_COMMAND_LIST_KEY_DOWN;
+
+ event.m_code = wxMSWKeyboard::VKToWX(wVKey);
+
+ if ( event.m_code == WXK_NONE )
+ {
+ // We can't translate this to a standard key code,
+ // until support for Unicode key codes is added to
+ // wxListEvent we just ignore them.
+ return false;
+ }
+ }
+
+ event.m_itemIndex =
+ event.m_item.m_itemId = lItem;
+
+ if ( lItem != -1 )
+ {
+ // fill the other fields too
+ event.m_item.m_text = GetItemText(lItem);
+ event.m_item.m_data = GetItemData(lItem);
+ }
+ }
+ break;
+
+ case NM_DBLCLK:
+ // if the user processes it in wxEVT_COMMAND_LEFT_CLICK(), don't do
+ // anything else
+ if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
+ {
+ return true;
+ }
+
+ // else translate it into wxEVT_COMMAND_LIST_ITEM_ACTIVATED event
+ // if it happened on an item (and not on empty place)
+ if ( iItem == -1 )
+ {
+ // not on item
+ return false;
+ }
+
+ eventType = wxEVT_COMMAND_LIST_ITEM_ACTIVATED;
+ event.m_itemIndex = iItem;
+ event.m_item.m_text = GetItemText(iItem);
+ event.m_item.m_data = GetItemData(iItem);
+ break;
+
+#if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
+ case GN_CONTEXTMENU:
+#endif //__WXWINCE__
+ case NM_RCLICK:
+ // if the user processes it in wxEVT_COMMAND_RIGHT_CLICK(),
+ // don't do anything else
+ if ( wxControl::MSWOnNotify(idCtrl, lParam, result) )
+ {
+ return true;
+ }
+
+ // else translate it into wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK event
+ LV_HITTESTINFO lvhti;
+ wxZeroMemory(lvhti);
+
+#if defined(__WXWINCE__) && !defined(__HANDHELDPC__) && _WIN32_WCE < 400
+ if ( nmhdr->code == GN_CONTEXTMENU )
+ {
+ lvhti.pt = ((NMRGINFO*)nmhdr)->ptAction;
+ }
+ else
+#endif //__WXWINCE__
+ {
+ ::GetCursorPos(&(lvhti.pt));
+ }
+
+ ::ScreenToClient(GetHwnd(), &lvhti.pt);
+ if ( ListView_HitTest(GetHwnd(), &lvhti) != -1 )
+ {
+ if ( lvhti.flags & LVHT_ONITEM )
+ {
+ eventType = wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK;
+ event.m_itemIndex = lvhti.iItem;
+ event.m_pointDrag.x = lvhti.pt.x;
+ event.m_pointDrag.y = lvhti.pt.y;
+ }
+ }
+ break;
+
+#ifdef NM_CUSTOMDRAW
+ case NM_CUSTOMDRAW:
+ *result = OnCustomDraw(lParam);
+
+ return *result != CDRF_DODEFAULT;
+#endif // _WIN32_IE >= 0x300
+
+ case LVN_ODCACHEHINT:
+ {
+ const NM_CACHEHINT *cacheHint = (NM_CACHEHINT *)lParam;
+
+ eventType = wxEVT_COMMAND_LIST_CACHE_HINT;
+
+ // we get some really stupid cache hints like ones for
+ // items in range 0..0 for an empty control or, after
+ // deleting an item, for items in invalid range -- filter
+ // this garbage out
+ if ( cacheHint->iFrom > cacheHint->iTo )
+ return false;
+
+ event.m_oldItemIndex = cacheHint->iFrom;
+
+ const long iMax = GetItemCount();
+ event.m_itemIndex = cacheHint->iTo < iMax ? cacheHint->iTo
+ : iMax - 1;
+ }
+ break;
+
+#ifdef HAVE_NMLVFINDITEM
+ case LVN_ODFINDITEM:
+ // Find an item in a (necessarily virtual) list control.
+ if ( IsVirtual() )
+ {
+ NMLVFINDITEM* pFindInfo = (NMLVFINDITEM*)lParam;
+
+ // no match by default
+ *result = -1;
+
+ // we only handle string-based searches here
+ //
+ // TODO: what about LVFI_PARTIAL, should we handle this?
+ if ( !(pFindInfo->lvfi.flags & LVFI_STRING) )
+ {
+ return false;
+ }
+
+ const wxChar * const searchstr = pFindInfo->lvfi.psz;
+ const size_t len = wxStrlen(searchstr);
+
+ // this is the first item we should examine, search from it
+ // wrapping if necessary
+ int startPos = pFindInfo->iStart;
+ const int maxPos = GetItemCount();
+
+ // Check that the index is valid to ensure that our loop
+ // below always terminates.
+ if ( startPos < 0 || startPos >= maxPos )
+ {
+ // When the last item in the control is selected,
+ // iStart is really set to (invalid) maxPos index so
+ // accept this silently.
+ if ( startPos != maxPos )
+ {
+ wxLogDebug(wxT("Ignoring invalid search start ")
+ wxT("position %d in list control with ")
+ wxT("%d items."), startPos, maxPos);
+ }
+
+ startPos = 0;
+ }
+
+ // Linear search in a control with a lot of items can take
+ // a long time so we limit the total time of the search to
+ // ensure that the program doesn't appear to hang.
+#if wxUSE_STOPWATCH
+ wxStopWatch sw;
+#endif // wxUSE_STOPWATCH
+ for ( int currentPos = startPos; ; )
+ {
+ // does this item begin with searchstr?
+ if ( wxStrnicmp(searchstr,
+ GetItemText(currentPos), len) == 0 )
+ {
+ *result = currentPos;
+ break;
+ }
+
+ // Go to next item with wrapping if necessary.
+ if ( ++currentPos == maxPos )
+ {
+ // Surprisingly, LVFI_WRAP seems to be never set in
+ // the flags so wrap regardless of it.
+ currentPos = 0;
+ }
+
+ if ( currentPos == startPos )
+ {
+ // We examined all items without finding anything.
+ //
+ // Notice that we still return true as we did
+ // perform the search, if we didn't do this the
+ // message would have been considered unhandled and
+ // the control seems to always select the first
+ // item by default in this case.
+ return true;
+ }
+
+#if wxUSE_STOPWATCH
+ // Check the time elapsed only every thousand
+ // iterations for performance reasons: if we did it
+ // more often calling wxStopWatch::Time() could take
+ // noticeable time on its own.
+ if ( !((currentPos - startPos)%1000) )
+ {
+ // We use half a second to limit the search time
+ // which is about as long as we can take without
+ // annoying the user.
+ if ( sw.Time() > 500 )
+ {
+ // As above, return true to prevent the control
+ // from selecting the first item by default.
+ return true;
+ }
+ }
+#endif // wxUSE_STOPWATCH
+
+ }
+
+ SetItemState(*result,
+ wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED,
+ wxLIST_STATE_SELECTED | wxLIST_STATE_FOCUSED);
+ EnsureVisible(*result);
+ return true;
+ }
+ else
+ {
+ processed = false;
+ }
+ break;
+#endif // HAVE_NMLVFINDITEM
+
+ case LVN_GETDISPINFO:
+ if ( IsVirtual() )
+ {
+ LV_DISPINFO *info = (LV_DISPINFO *)lParam;
+
+ LV_ITEM& lvi = info->item;
+ long item = lvi.iItem;
+
+ if ( lvi.mask & LVIF_TEXT )
+ {
+ wxString text = OnGetItemText(item, lvi.iSubItem);
+ wxStrlcpy(lvi.pszText, text.c_str(), lvi.cchTextMax);
+ }
+
+ // see comment at the end of wxListCtrl::GetColumn()
+#ifdef NM_CUSTOMDRAW
+ if ( lvi.mask & LVIF_IMAGE )
+ {
+ lvi.iImage = OnGetItemColumnImage(item, lvi.iSubItem);
+ }
+#endif // NM_CUSTOMDRAW
+
+ // even though we never use LVM_SETCALLBACKMASK, we still
+ // can get messages with LVIF_STATE in lvi.mask under Vista
+ if ( lvi.mask & LVIF_STATE )
+ {
+ // we don't have anything to return from here...
+ lvi.stateMask = 0;
+ }
+
+ return true;
+ }
+ // fall through
+
+ default:
+ processed = false;
+ }
+
+ if ( !processed )
+ return wxControl::MSWOnNotify(idCtrl, lParam, result);
+ }
+ else
+ {
+ // where did this one come from?
+ return false;
+ }
+
+ // process the event
+ // -----------------
+
+ event.SetEventType(eventType);
+
+ // fill in the item before passing it to the event handler if we do have a
+ // valid item index and haven't filled it yet (e.g. for LVN_ITEMCHANGED)
+ if ( event.m_itemIndex != -1 && !event.m_item.GetMask() )
+ {
+ wxListItem& item = event.m_item;
+
+ item.SetId(event.m_itemIndex);
+ item.SetMask(wxLIST_MASK_TEXT | wxLIST_MASK_IMAGE | wxLIST_MASK_DATA);
+ GetItem(item);
+ }
+
+ bool processed = HandleWindowEvent(event);
+
+ // post processing
+ // ---------------
+ switch ( nmhdr->code )
+ {
+ case LVN_DELETEALLITEMS:
+ // always return true to suppress all additional LVN_DELETEITEM
+ // notifications - this makes deleting all items from a list ctrl
+ // much faster
+ *result = TRUE;
+
+ // also, we may free all user data now (couldn't do it before as
+ // the user should have access to it in OnDeleteAllItems() handler)
+ FreeAllInternalData();
+
+ // the control is empty now, synchronize the cached number of items
+ // with the real one
+ m_count = 0;
+ return true;
+
+ case LVN_DELETEITEM:
+ // Delete the associated internal data. Notice that this can be
+ // done only after the event has been handled as the data could be
+ // accessed during the handling of the event.
+ if ( wxMSWListItemData *data = MSWGetItemData(event.m_itemIndex) )
+ {
+ const unsigned count = m_internalData.size();
+ for ( unsigned n = 0; n < count; n++ )
+ {
+ if ( m_internalData[n] == data )
+ {
+ m_internalData.erase(m_internalData.begin() + n);
+ wxDELETE(data);
+ break;
+ }
+ }
+
+ wxASSERT_MSG( !data, "invalid internal data pointer?" );
+ }
+ break;
+
+ case LVN_ENDLABELEDITA:
+ case LVN_ENDLABELEDITW:
+ // logic here is inverted compared to all the other messages
+ *result = event.IsAllowed();
+
+ // EDIT control will be deleted by the list control itself so
+ // prevent us from deleting it as well
+ DeleteEditControl();
+
+ return true;
+ }
+
+ if ( processed )
+ *result = !event.IsAllowed();
+
+ return processed;
+}
+
+// ----------------------------------------------------------------------------
+// custom draw stuff
+// ----------------------------------------------------------------------------
+
+// see comment at the end of wxListCtrl::GetColumn()
+#ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
+
+static RECT GetCustomDrawnItemRect(const NMCUSTOMDRAW& nmcd)
+{
+ RECT rc;
+ wxGetListCtrlItemRect(nmcd.hdr.hwndFrom, nmcd.dwItemSpec, LVIR_BOUNDS, rc);
+
+ RECT rcIcon;
+ wxGetListCtrlItemRect(nmcd.hdr.hwndFrom, nmcd.dwItemSpec, LVIR_ICON, rcIcon);
+
+ // exclude the icon part, neither the selection background nor focus rect
+ // should cover it
+ rc.left = rcIcon.right;
+
+ return rc;
+}
+
+static
+bool HandleSubItemPrepaint(LPNMLVCUSTOMDRAW pLVCD, HFONT hfont, int colCount)
+{
+ NMCUSTOMDRAW& nmcd = pLVCD->nmcd;
+
+ HDC hdc = nmcd.hdc;
+ HWND hwndList = nmcd.hdr.hwndFrom;
+ const int col = pLVCD->iSubItem;
+ const DWORD item = nmcd.dwItemSpec;
+
+ // the font must be valid, otherwise we wouldn't be painting the item at all
+ SelectInHDC selFont(hdc, hfont);
+
+ // get the rectangle to paint
+ int subitem = colCount ? col + 1 : col;
+ RECT rc;
+ wxGetListCtrlSubItemRect(hwndList, item, subitem, LVIR_BOUNDS, rc);
+ rc.left += 6;
+
+ // get the image and text to draw
+ wxChar text[512];
+ LV_ITEM it;
+ wxZeroMemory(it);
+ it.mask = LVIF_TEXT | LVIF_IMAGE;
+ it.iItem = item;
+ it.iSubItem = col;
+ it.pszText = text;
+ it.cchTextMax = WXSIZEOF(text);
+ ListView_GetItem(hwndList, &it);
+
+ HIMAGELIST himl = ListView_GetImageList(hwndList, LVSIL_SMALL);
+ if ( himl && ImageList_GetImageCount(himl) )
+ {
+ if ( it.iImage != -1 )
+ {
+ ImageList_Draw(himl, it.iImage, hdc, rc.left, rc.top,
+ nmcd.uItemState & CDIS_SELECTED ? ILD_SELECTED
+ : ILD_TRANSPARENT);
+ }
+
+ // notice that even if this item doesn't have any image, the list
+ // control still leaves space for the image in the first column if the
+ // image list is not empty (presumably so that items with and without
+ // images align?)
+ if ( it.iImage != -1 || it.iSubItem == 0 )
+ {
+ int wImage, hImage;
+ ImageList_GetIconSize(himl, &wImage, &hImage);
+
+ rc.left += wImage + 2;
+ }
+ }
+
+ ::SetBkMode(hdc, TRANSPARENT);
+
+ UINT fmt = DT_SINGLELINE |
+#ifndef __WXWINCE__
+ DT_WORD_ELLIPSIS |
+#endif // __WXWINCE__
+ DT_NOPREFIX |
+ DT_VCENTER;
+
+ LV_COLUMN lvCol;
+ wxZeroMemory(lvCol);
+ lvCol.mask = LVCF_FMT;
+ if ( ListView_GetColumn(hwndList, col, &lvCol) )
+ {
+ switch ( lvCol.fmt & LVCFMT_JUSTIFYMASK )
+ {
+ case LVCFMT_LEFT:
+ fmt |= DT_LEFT;
+ break;
+
+ case LVCFMT_CENTER:
+ fmt |= DT_CENTER;
+ break;
+
+ case LVCFMT_RIGHT:
+ fmt |= DT_RIGHT;
+ break;
+ }
+ }
+ //else: failed to get alignment, assume it's DT_LEFT (default)
+
+ DrawText(hdc, text, -1, &rc, fmt);
+
+ return true;
+}
+
+static void HandleItemPostpaint(NMCUSTOMDRAW nmcd)
+{
+ if ( nmcd.uItemState & CDIS_FOCUS )
+ {
+ RECT rc = GetCustomDrawnItemRect(nmcd);
+
+ // don't use the provided HDC, it's in some strange state by now
+ ::DrawFocusRect(WindowHDC(nmcd.hdr.hwndFrom), &rc);
+ }
+}
+
+// pLVCD->clrText and clrTextBk should contain the colours to use
+static void HandleItemPaint(LPNMLVCUSTOMDRAW pLVCD, HFONT hfont)
+{
+ NMCUSTOMDRAW& nmcd = pLVCD->nmcd; // just a shortcut
+
+ const HWND hwndList = nmcd.hdr.hwndFrom;
+ const int item = nmcd.dwItemSpec;
+
+ // unfortunately we can't trust CDIS_SELECTED, it is often set even when
+ // the item is not at all selected for some reason (comctl32 6), but we
+ // also can't always trust ListView_GetItem() as it could return the old
+ // item status if we're called just after the (de)selection, so remember
+ // the last item to gain selection and also check for it here
+ for ( int i = -1;; )
+ {
+ i = ListView_GetNextItem(hwndList, i, LVNI_SELECTED);
+ if ( i == -1 )
+ {
+ nmcd.uItemState &= ~CDIS_SELECTED;
+ break;
+ }
+
+ if ( i == item )
+ {
+ nmcd.uItemState |= CDIS_SELECTED;
+ break;
+ }
+ }
+
+ // same thing for CDIS_FOCUS (except simpler as there is only one of them)
+ //
+ // NB: cast is needed to work around the bug in mingw32 headers which don't
+ // have it inside ListView_GetNextItem() itself (unlike SDK ones)
+ if ( ::GetFocus() == hwndList &&
+ ListView_GetNextItem(
+ hwndList, static_cast<WPARAM>(-1), LVNI_FOCUSED) == item )
+ {
+ nmcd.uItemState |= CDIS_FOCUS;
+ }
+ else
+ {
+ nmcd.uItemState &= ~CDIS_FOCUS;
+ }
+
+ if ( nmcd.uItemState & CDIS_SELECTED )
+ {
+ int syscolFg, syscolBg;
+ if ( ::GetFocus() == hwndList )
+ {
+ syscolFg = COLOR_HIGHLIGHTTEXT;
+ syscolBg = COLOR_HIGHLIGHT;
+ }
+ else // selected but unfocused
+ {
+ syscolFg = COLOR_WINDOWTEXT;
+ syscolBg = COLOR_BTNFACE;
+
+ // don't grey out the icon in this case neither
+ nmcd.uItemState &= ~CDIS_SELECTED;
+ }
+
+ pLVCD->clrText = ::GetSysColor(syscolFg);
+ pLVCD->clrTextBk = ::GetSysColor(syscolBg);
+ }
+ //else: not selected, use normal colours from pLVCD
+
+ HDC hdc = nmcd.hdc;
+ RECT rc = GetCustomDrawnItemRect(nmcd);
+
+ ::SetTextColor(hdc, pLVCD->clrText);
+ ::FillRect(hdc, &rc, AutoHBRUSH(pLVCD->clrTextBk));
+
+ // we could use CDRF_NOTIFYSUBITEMDRAW here but it results in weird repaint
+ // problems so just draw everything except the focus rect from here instead
+ const int colCount = Header_GetItemCount(ListView_GetHeader(hwndList));
+ for ( int col = 0; col < colCount; col++ )
+ {
+ pLVCD->iSubItem = col;
+ HandleSubItemPrepaint(pLVCD, hfont, colCount);
+ }
+
+ HandleItemPostpaint(nmcd);
+}
+
+static WXLPARAM HandleItemPrepaint(wxListCtrl *listctrl,
+ LPNMLVCUSTOMDRAW pLVCD,
+ wxListItemAttr *attr)
+{
+ if ( !attr )
+ {
+ // nothing to do for this item
+ return CDRF_DODEFAULT;
+ }
+
+
+ // set the colours to use for text drawing
+ pLVCD->clrText = attr->HasTextColour()
+ ? wxColourToRGB(attr->GetTextColour())
+ : wxColourToRGB(listctrl->GetTextColour());
+ pLVCD->clrTextBk = attr->HasBackgroundColour()
+ ? wxColourToRGB(attr->GetBackgroundColour())
+ : wxColourToRGB(listctrl->GetBackgroundColour());
+
+ // select the font if non default one is specified
+ if ( attr->HasFont() )
+ {
+ wxFont font = attr->GetFont();
+ if ( font.GetEncoding() != wxFONTENCODING_SYSTEM )
+ {
+ // the standard control ignores the font encoding/charset, at least
+ // with recent comctl32.dll versions (5 and 6, it uses to work with
+ // 4.something) so we have to draw the item entirely ourselves in
+ // this case
+ HandleItemPaint(pLVCD, GetHfontOf(font));
+ return CDRF_SKIPDEFAULT;
+ }
+
+ ::SelectObject(pLVCD->nmcd.hdc, GetHfontOf(font));
+
+ return CDRF_NEWFONT;
+ }
+
+ return CDRF_DODEFAULT;
+}
+
+WXLPARAM wxListCtrl::OnCustomDraw(WXLPARAM lParam)
+{
+ LPNMLVCUSTOMDRAW pLVCD = (LPNMLVCUSTOMDRAW)lParam;
+ NMCUSTOMDRAW& nmcd = pLVCD->nmcd;
+ switch ( nmcd.dwDrawStage )
+ {
+ case CDDS_PREPAINT:
+ // if we've got any items with non standard attributes,
+ // notify us before painting each item
+ //
+ // for virtual controls, always suppose that we have attributes as
+ // there is no way to check for this
+ if ( IsVirtual() || m_hasAnyAttr )
+ return CDRF_NOTIFYITEMDRAW;
+ break;
+
+ case CDDS_ITEMPREPAINT:
+ // get a message for each subitem
+ return CDRF_NOTIFYITEMDRAW;
+
+ case CDDS_SUBITEM | CDDS_ITEMPREPAINT:
+ const int item = nmcd.dwItemSpec;
+ const int column = pLVCD->iSubItem;
+
+ // we get this message with item == 0 for an empty control, we
+ // must ignore it as calling OnGetItemAttr() would be wrong
+ if ( item < 0 || item >= GetItemCount() )
+ break;
+ // same for columns
+ if ( column < 0 || column >= GetColumnCount() )
+ break;
+
+ return HandleItemPrepaint(this, pLVCD, DoGetItemColumnAttr(item, column));
+ }
+
+ return CDRF_DODEFAULT;
+}
+
+#endif // NM_CUSTOMDRAW supported
+
+// Necessary for drawing hrules and vrules, if specified
+void wxListCtrl::OnPaint(wxPaintEvent& event)
+{
+ const int itemCount = GetItemCount();
+ const bool drawHRules = HasFlag(wxLC_HRULES);
+ const bool drawVRules = HasFlag(wxLC_VRULES);
+
+ if (!InReportView() || !(drawHRules || drawVRules) || !itemCount)
+ {
+ event.Skip();
+ return;
+ }
+
+ wxPaintDC dc(this);
+
+ wxControl::OnPaint(event);
+
+ // Reset the device origin since it may have been set
+ dc.SetDeviceOrigin(0, 0);
+
+ wxPen pen(wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT));
+ dc.SetPen(pen);
+ dc.SetBrush(* wxTRANSPARENT_BRUSH);
+
+ wxSize clientSize = GetClientSize();
+ wxRect itemRect;
+
+ if (drawHRules)
+ {
+ const long top = GetTopItem();
+ for ( int i = top; i < top + GetCountPerPage() + 1; i++ )
+ {
+ if (GetItemRect(i, itemRect))
+ {
+ int cy = itemRect.GetTop();
+ if (i != 0) // Don't draw the first one
+ {
+ dc.DrawLine(0, cy, clientSize.x, cy);
+ }
+ // Draw last line
+ if (i == itemCount - 1)
+ {
+ cy = itemRect.GetBottom();
+ dc.DrawLine(0, cy, clientSize.x, cy);
+ break;
+ }
+ }
+ }
+ }
+
+ if (drawVRules)
+ {
+ wxRect firstItemRect;
+ GetItemRect(0, firstItemRect);
+
+ if (GetItemRect(itemCount - 1, itemRect))
+ {
+ // this is a fix for bug 673394: erase the pixels which we would
+ // otherwise leave on the screen
+ static const int gap = 2;
+ dc.SetPen(*wxTRANSPARENT_PEN);
+ dc.SetBrush(wxBrush(GetBackgroundColour()));
+ dc.DrawRectangle(0, firstItemRect.GetY() - gap,
+ clientSize.GetWidth(), gap);
+
+ dc.SetPen(pen);
+ dc.SetBrush(*wxTRANSPARENT_BRUSH);
+
+ const int numCols = GetColumnCount();
+ wxVector<int> indexArray(numCols);
+ if ( !ListView_GetColumnOrderArray(GetHwnd(),
+ numCols,
+ &indexArray[0]) )
+ {
+ wxFAIL_MSG( wxT("invalid column index array in OnPaint()") );
+ return;
+ }
+
+ int x = itemRect.GetX();
+ for (int col = 0; col < numCols; col++)
+ {
+ int colWidth = GetColumnWidth(indexArray[col]);
+ x += colWidth ;
+ dc.DrawLine(x-1, firstItemRect.GetY() - gap,
+ x-1, itemRect.GetBottom());
+ }
+ }
+ }
+}
+
+WXLRESULT
+wxListCtrl::MSWWindowProc(WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
+{
+ switch ( nMsg )
+ {
+#ifdef WM_PRINT
+ case WM_PRINT:
+ // we should bypass our own WM_PRINT handling as we don't handle
+ // PRF_CHILDREN flag, so leave it to the native control itself
+ return MSWDefWindowProc(nMsg, wParam, lParam);
+#endif // WM_PRINT
+
+ case WM_CONTEXTMENU:
+ // because this message is propagated upwards the child-parent
+ // chain, we get it for the right clicks on the header window but
+ // this is confusing in wx as right clicking there already
+ // generates a separate wxEVT_COMMAND_LIST_COL_RIGHT_CLICK event
+ // so just ignore them
+ if ( (HWND)wParam == ListView_GetHeader(GetHwnd()) )
+ return 0;
+ //else: break
+ }
+
+ return wxControl::MSWWindowProc(nMsg, wParam, lParam);
+}
+
+// ----------------------------------------------------------------------------
+// virtual list controls
+// ----------------------------------------------------------------------------
+
+wxString wxListCtrl::OnGetItemText(long WXUNUSED(item), long WXUNUSED(col)) const
+{
+ // this is a pure virtual function, in fact - which is not really pure
+ // because the controls which are not virtual don't need to implement it
+ wxFAIL_MSG( wxT("wxListCtrl::OnGetItemText not supposed to be called") );
+
+ return wxEmptyString;
+}
+
+int wxListCtrl::OnGetItemImage(long WXUNUSED(item)) const
+{
+ wxCHECK_MSG(!GetImageList(wxIMAGE_LIST_SMALL),
+ -1,
+ wxT("List control has an image list, OnGetItemImage or OnGetItemColumnImage should be overridden."));
+ return -1;
+}
+
+int wxListCtrl::OnGetItemColumnImage(long item, long column) const
+{
+ if (!column)
+ return OnGetItemImage(item);
+
+ return -1;
+}
+
+wxListItemAttr *wxListCtrl::OnGetItemAttr(long WXUNUSED_UNLESS_DEBUG(item)) const
+{
+ wxASSERT_MSG( item >= 0 && item < GetItemCount(),
+ wxT("invalid item index in OnGetItemAttr()") );
+
+ // no attributes by default
+ return NULL;
+}
+
+wxListItemAttr *wxListCtrl::DoGetItemColumnAttr(long item, long column) const
+{
+ if ( IsVirtual() )
+ return OnGetItemColumnAttr(item, column);
+
+ wxMSWListItemData * const data = MSWGetItemData(item);
+ return data ? data->attr : NULL;
+}
+
+void wxListCtrl::SetItemCount(long count)
+{
+ wxASSERT_MSG( IsVirtual(), wxT("this is for virtual controls only") );
+
+ if ( !::SendMessage(GetHwnd(), LVM_SETITEMCOUNT, (WPARAM)count,
+ LVSICF_NOSCROLL | LVSICF_NOINVALIDATEALL) )
+ {
+ wxLogLastError(wxT("ListView_SetItemCount"));
+ }
+ m_count = count;
+ wxASSERT_MSG( m_count == ListView_GetItemCount(GetHwnd()),
+ wxT("m_count should match ListView_GetItemCount"));
+}
+
+void wxListCtrl::RefreshItem(long item)
+{
+ RefreshItems(item, item);
+}
+
+void wxListCtrl::RefreshItems(long itemFrom, long itemTo)
+{
+ ListView_RedrawItems(GetHwnd(), itemFrom, itemTo);
+}
+
+// ----------------------------------------------------------------------------
+// wxWin <-> MSW items conversions
+// ----------------------------------------------------------------------------
+
+static void wxConvertFromMSWListItem(HWND hwndListCtrl,
+ wxListItem& info,
+ LV_ITEM& lvItem)
+{
+ wxMSWListItemData *internaldata =
+ (wxMSWListItemData *) lvItem.lParam;
+
+ if (internaldata)
+ info.m_data = internaldata->lParam;
+
+ info.m_mask = 0;
+ info.m_state = 0;
+ info.m_stateMask = 0;
+ info.m_itemId = lvItem.iItem;
+
+ long oldMask = lvItem.mask;
+
+ bool needText = false;
+ if (hwndListCtrl != 0)
+ {
+ if ( lvItem.mask & LVIF_TEXT )
+ needText = false;
+ else
+ needText = true;
+
+ if ( needText )
+ {
+ lvItem.pszText = new wxChar[513];
+ lvItem.cchTextMax = 512;
+ }
+ lvItem.mask |= LVIF_TEXT | LVIF_IMAGE | LVIF_PARAM;
+ ::SendMessage(hwndListCtrl, LVM_GETITEM, 0, (LPARAM)& lvItem);
+ }
+
+ if ( lvItem.mask & LVIF_STATE )
+ {
+ info.m_mask |= wxLIST_MASK_STATE;
+
+ if ( lvItem.stateMask & LVIS_CUT)
+ {
+ info.m_stateMask |= wxLIST_STATE_CUT;
+ if ( lvItem.state & LVIS_CUT )
+ info.m_state |= wxLIST_STATE_CUT;
+ }
+ if ( lvItem.stateMask & LVIS_DROPHILITED)
+ {
+ info.m_stateMask |= wxLIST_STATE_DROPHILITED;
+ if ( lvItem.state & LVIS_DROPHILITED )
+ info.m_state |= wxLIST_STATE_DROPHILITED;
+ }
+ if ( lvItem.stateMask & LVIS_FOCUSED)
+ {
+ info.m_stateMask |= wxLIST_STATE_FOCUSED;
+ if ( lvItem.state & LVIS_FOCUSED )
+ info.m_state |= wxLIST_STATE_FOCUSED;
+ }
+ if ( lvItem.stateMask & LVIS_SELECTED)
+ {
+ info.m_stateMask |= wxLIST_STATE_SELECTED;
+ if ( lvItem.state & LVIS_SELECTED )
+ info.m_state |= wxLIST_STATE_SELECTED;
+ }
+ }
+
+ if ( lvItem.mask & LVIF_TEXT )
+ {
+ info.m_mask |= wxLIST_MASK_TEXT;
+ info.m_text = lvItem.pszText;
+ }
+ if ( lvItem.mask & LVIF_IMAGE )
+ {
+ info.m_mask |= wxLIST_MASK_IMAGE;
+ info.m_image = lvItem.iImage;
+ }
+ if ( lvItem.mask & LVIF_PARAM )
+ info.m_mask |= wxLIST_MASK_DATA;
+ if ( lvItem.mask & LVIF_DI_SETITEM )
+ info.m_mask |= wxLIST_SET_ITEM;
+ info.m_col = lvItem.iSubItem;
+
+ if (needText)
+ {
+ if (lvItem.pszText)
+ delete[] lvItem.pszText;
+ }
+ lvItem.mask = oldMask;
+}
+
+static void wxConvertToMSWFlags(long state, long stateMask, LV_ITEM& lvItem)
+{
+ if (stateMask & wxLIST_STATE_CUT)
+ {
+ lvItem.stateMask |= LVIS_CUT;
+ if (state & wxLIST_STATE_CUT)
+ lvItem.state |= LVIS_CUT;
+ }
+ if (stateMask & wxLIST_STATE_DROPHILITED)
+ {
+ lvItem.stateMask |= LVIS_DROPHILITED;
+ if (state & wxLIST_STATE_DROPHILITED)
+ lvItem.state |= LVIS_DROPHILITED;
+ }
+ if (stateMask & wxLIST_STATE_FOCUSED)
+ {
+ lvItem.stateMask |= LVIS_FOCUSED;
+ if (state & wxLIST_STATE_FOCUSED)
+ lvItem.state |= LVIS_FOCUSED;
+ }
+ if (stateMask & wxLIST_STATE_SELECTED)
+ {
+ lvItem.stateMask |= LVIS_SELECTED;
+ if (state & wxLIST_STATE_SELECTED)
+ lvItem.state |= LVIS_SELECTED;
+ }
+}
+
+static void wxConvertToMSWListItem(const wxListCtrl *ctrl,
+ const wxListItem& info,
+ LV_ITEM& lvItem)
+{
+ if ( ctrl->InReportView() )
+ {
+ wxASSERT_MSG( 0 <= info.m_col && info.m_col < ctrl->GetColumnCount(),
+ "wxListCtrl column index out of bounds" );
+ }
+ else // not in report view
+ {
+ wxASSERT_MSG( info.m_col == 0, "columns only exist in report view" );
+ }
+
+ lvItem.iItem = (int) info.m_itemId;
+
+ lvItem.iImage = info.m_image;
+ lvItem.stateMask = 0;
+ lvItem.state = 0;
+ lvItem.mask = 0;
+ lvItem.iSubItem = info.m_col;
+
+ if (info.m_mask & wxLIST_MASK_STATE)
+ {
+ lvItem.mask |= LVIF_STATE;
+
+ wxConvertToMSWFlags(info.m_state, info.m_stateMask, lvItem);
+ }
+
+ if (info.m_mask & wxLIST_MASK_TEXT)
+ {
+ lvItem.mask |= LVIF_TEXT;
+ if ( ctrl->HasFlag(wxLC_USER_TEXT) )
+ {
+ lvItem.pszText = LPSTR_TEXTCALLBACK;
+ }
+ else
+ {
+ // pszText is not const, hence the cast
+ lvItem.pszText = (wxChar *)info.m_text.wx_str();
+ if ( lvItem.pszText )
+ lvItem.cchTextMax = info.m_text.length();
+ else
+ lvItem.cchTextMax = 0;
+ }
+ }
+ if (info.m_mask & wxLIST_MASK_IMAGE)
+ lvItem.mask |= LVIF_IMAGE;
+}
+
+static void wxConvertToMSWListCol(HWND hwndList,
+ int col,
+ const wxListItem& item,
+ LV_COLUMN& lvCol)
+{
+ wxZeroMemory(lvCol);
+
+ if ( item.m_mask & wxLIST_MASK_TEXT )
+ {
+ lvCol.mask |= LVCF_TEXT;
+ lvCol.pszText = (wxChar *)item.m_text.wx_str(); // cast is safe
+ }
+
+ if ( item.m_mask & wxLIST_MASK_FORMAT )
+ {
+ lvCol.mask |= LVCF_FMT;
+
+ if ( item.m_format == wxLIST_FORMAT_LEFT )
+ lvCol.fmt = LVCFMT_LEFT;
+ else if ( item.m_format == wxLIST_FORMAT_RIGHT )
+ lvCol.fmt = LVCFMT_RIGHT;
+ else if ( item.m_format == wxLIST_FORMAT_CENTRE )
+ lvCol.fmt = LVCFMT_CENTER;
+ }
+
+ if ( item.m_mask & wxLIST_MASK_WIDTH )
+ {
+ lvCol.mask |= LVCF_WIDTH;
+ if ( item.m_width == wxLIST_AUTOSIZE)
+ lvCol.cx = LVSCW_AUTOSIZE;
+ else if ( item.m_width == wxLIST_AUTOSIZE_USEHEADER)
+ lvCol.cx = LVSCW_AUTOSIZE_USEHEADER;
+ else
+ lvCol.cx = item.m_width;
+ }
+
+ // see comment at the end of wxListCtrl::GetColumn()
+#ifdef NM_CUSTOMDRAW // _WIN32_IE >= 0x0300
+ if ( item.m_mask & wxLIST_MASK_IMAGE )
+ {
+ if ( wxApp::GetComCtl32Version() >= 470 )
+ {
+ lvCol.mask |= LVCF_IMAGE;
+
+ // we use LVCFMT_BITMAP_ON_RIGHT because the images on the right
+ // seem to be generally nicer than on the left and the generic
+ // version only draws them on the right (we don't have a flag to
+ // specify the image location anyhow)
+ //
+ // we don't use LVCFMT_COL_HAS_IMAGES because it doesn't seem to
+ // make any difference in my tests -- but maybe we should?
+ if ( item.m_image != -1 )
+ {
+ // as we're going to overwrite the format field, get its
+ // current value first -- unless we want to overwrite it anyhow
+ if ( !(lvCol.mask & LVCF_FMT) )
+ {
+ LV_COLUMN lvColOld;
+ wxZeroMemory(lvColOld);
+ lvColOld.mask = LVCF_FMT;
+ if ( ListView_GetColumn(hwndList, col, &lvColOld) )
+ {
+ lvCol.fmt = lvColOld.fmt;
+ }
+
+ lvCol.mask |= LVCF_FMT;
+ }
+
+ lvCol.fmt |= LVCFMT_BITMAP_ON_RIGHT | LVCFMT_IMAGE;
+ }
+
+ lvCol.iImage = item.m_image;
+ }
+ //else: it doesn't support item images anyhow
+ }
+#endif // _WIN32_IE >= 0x0300
+}
projects / wxWidgets.git / blobdiff