1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/generic/listctrl.cpp
3 // Purpose: generic implementation of wxListCtrl
4 // Author: Robert Roebling
5 // Vadim Zeitlin (virtual list control support)
7 // Copyright: (c) 1998 Robert Roebling
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
13 // 1. we need to implement searching/sorting for virtual controls somehow
14 // 2. when changing selection the lines are refreshed twice
17 // For compilers that support precompilation, includes "wx.h".
18 #include "wx/wxprec.h"
26 // under Win32 we always use the native version and also may use the generic
27 // one, however some things should be done only if we use only the generic
29 #if defined(__WIN32__) && !defined(__WXUNIVERSAL__)
30 #define HAVE_NATIVE_LISTCTRL
33 // if we have the native control, wx/listctrl.h declares it and not this one
34 #ifdef HAVE_NATIVE_LISTCTRL
35 #include "wx/generic/listctrl.h"
36 #else // !HAVE_NATIVE_LISTCTRL
37 #include "wx/listctrl.h"
39 // if we have a native version, its implementation file does all this
40 IMPLEMENT_DYNAMIC_CLASS(wxListItem
, wxObject
)
41 IMPLEMENT_DYNAMIC_CLASS(wxListView
, wxListCtrl
)
42 IMPLEMENT_DYNAMIC_CLASS(wxListEvent
, wxNotifyEvent
)
44 IMPLEMENT_DYNAMIC_CLASS(wxListCtrl
, wxGenericListCtrl
)
45 #endif // HAVE_NATIVE_LISTCTRL/!HAVE_NATIVE_LISTCTRL
48 #include "wx/dynarray.h"
50 #include "wx/dcscreen.h"
51 #include "wx/textctrl.h"
52 #include "wx/listbox.h"
56 #include "wx/selstore.h"
57 #include "wx/renderer.h"
60 #include "wx/mac/private.h"
64 // NOTE: If using the wxListBox visual attributes works everywhere then this can
65 // be removed, as well as the #else case below.
66 #define _USE_VISATTR 0
69 // ----------------------------------------------------------------------------
71 // ----------------------------------------------------------------------------
73 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_DRAG
)
74 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_RDRAG
)
75 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT
)
76 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_END_LABEL_EDIT
)
77 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_DELETE_ITEM
)
78 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS
)
79 #if WXWIN_COMPATIBILITY_2_4
80 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_GET_INFO
)
81 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_SET_INFO
)
83 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_SELECTED
)
84 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_DESELECTED
)
85 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_KEY_DOWN
)
86 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_INSERT_ITEM
)
87 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_CLICK
)
88 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_RIGHT_CLICK
)
89 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_BEGIN_DRAG
)
90 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_DRAGGING
)
91 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_END_DRAG
)
92 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
)
93 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK
)
94 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_ACTIVATED
)
95 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_FOCUSED
)
96 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_CACHE_HINT
)
98 // ----------------------------------------------------------------------------
100 // ----------------------------------------------------------------------------
102 // // the height of the header window (FIXME: should depend on its font!)
103 // static const int HEADER_HEIGHT = 23;
105 static const int SCROLL_UNIT_X
= 15;
107 // the spacing between the lines (in report mode)
108 static const int LINE_SPACING
= 0;
110 // extra margins around the text label
111 static const int EXTRA_WIDTH
= 4;
112 static const int EXTRA_HEIGHT
= 4;
114 // margin between the window and the items
115 static const int EXTRA_BORDER_X
= 2;
116 static const int EXTRA_BORDER_Y
= 2;
118 // offset for the header window
119 static const int HEADER_OFFSET_X
= 1;
120 static const int HEADER_OFFSET_Y
= 1;
122 // margin between rows of icons in [small] icon view
123 static const int MARGIN_BETWEEN_ROWS
= 6;
125 // when autosizing the columns, add some slack
126 static const int AUTOSIZE_COL_MARGIN
= 10;
128 // default width for the header columns
129 static const int WIDTH_COL_DEFAULT
= 80;
131 // the space between the image and the text in the report mode
132 static const int IMAGE_MARGIN_IN_REPORT_MODE
= 5;
134 // ============================================================================
136 // ============================================================================
138 //-----------------------------------------------------------------------------
139 // wxColWidthInfo (internal)
140 //-----------------------------------------------------------------------------
142 struct wxColWidthInfo
145 bool bNeedsUpdate
; // only set to true when an item whose
146 // width == nMaxWidth is removed
148 wxColWidthInfo(int w
= 0, bool needsUpdate
= false)
151 bNeedsUpdate
= needsUpdate
;
155 WX_DEFINE_ARRAY_PTR(wxColWidthInfo
*, ColWidthArray
);
157 //-----------------------------------------------------------------------------
158 // wxListItemData (internal)
159 //-----------------------------------------------------------------------------
161 class WXDLLEXPORT wxListItemData
164 wxListItemData(wxListMainWindow
*owner
);
167 void SetItem( const wxListItem
&info
);
168 void SetImage( int image
) { m_image
= image
; }
169 void SetData( wxUIntPtr data
) { m_data
= data
; }
170 void SetPosition( int x
, int y
);
171 void SetSize( int width
, int height
);
173 bool HasText() const { return !m_text
.empty(); }
174 const wxString
& GetText() const { return m_text
; }
175 void SetText(const wxString
& text
) { m_text
= text
; }
177 // we can't use empty string for measuring the string width/height, so
178 // always return something
179 wxString
GetTextForMeasuring() const
181 wxString s
= GetText();
188 bool IsHit( int x
, int y
) const;
192 int GetWidth() const;
193 int GetHeight() const;
195 int GetImage() const { return m_image
; }
196 bool HasImage() const { return GetImage() != -1; }
198 void GetItem( wxListItem
&info
) const;
200 void SetAttr(wxListItemAttr
*attr
) { m_attr
= attr
; }
201 wxListItemAttr
*GetAttr() const { return m_attr
; }
204 // the item image or -1
207 // user data associated with the item
210 // the item coordinates are not used in report mode; instead this pointer is
211 // NULL and the owner window is used to retrieve the item position and size
214 // the list ctrl we are in
215 wxListMainWindow
*m_owner
;
217 // custom attributes or NULL
218 wxListItemAttr
*m_attr
;
221 // common part of all ctors
227 //-----------------------------------------------------------------------------
228 // wxListHeaderData (internal)
229 //-----------------------------------------------------------------------------
231 class WXDLLEXPORT wxListHeaderData
: public wxObject
235 wxListHeaderData( const wxListItem
&info
);
236 void SetItem( const wxListItem
&item
);
237 void SetPosition( int x
, int y
);
238 void SetWidth( int w
);
239 void SetFormat( int format
);
240 void SetHeight( int h
);
241 bool HasImage() const;
243 bool HasText() const { return !m_text
.empty(); }
244 const wxString
& GetText() const { return m_text
; }
245 void SetText(const wxString
& text
) { m_text
= text
; }
247 void GetItem( wxListItem
&item
);
249 bool IsHit( int x
, int y
) const;
250 int GetImage() const;
251 int GetWidth() const;
252 int GetFormat() const;
268 //-----------------------------------------------------------------------------
269 // wxListLineData (internal)
270 //-----------------------------------------------------------------------------
272 WX_DECLARE_EXPORTED_LIST(wxListItemData
, wxListItemDataList
);
273 #include "wx/listimpl.cpp"
274 WX_DEFINE_LIST(wxListItemDataList
)
279 // the list of subitems: only may have more than one item in report mode
280 wxListItemDataList m_items
;
282 // this is not used in report view
294 // the part to be highlighted
295 wxRect m_rectHighlight
;
297 // extend all our rects to be centered inside the one of given width
298 void ExtendWidth(wxCoord w
)
300 wxASSERT_MSG( m_rectAll
.width
<= w
,
301 _T("width can only be increased") );
304 m_rectLabel
.x
= m_rectAll
.x
+ (w
- m_rectLabel
.width
) / 2;
305 m_rectIcon
.x
= m_rectAll
.x
+ (w
- m_rectIcon
.width
) / 2;
306 m_rectHighlight
.x
= m_rectAll
.x
+ (w
- m_rectHighlight
.width
) / 2;
311 // is this item selected? [NB: not used in virtual mode]
314 // back pointer to the list ctrl
315 wxListMainWindow
*m_owner
;
318 wxListLineData(wxListMainWindow
*owner
);
322 WX_CLEAR_LIST(wxListItemDataList
, m_items
);
326 // are we in report mode?
327 inline bool InReportView() const;
329 // are we in virtual report mode?
330 inline bool IsVirtual() const;
332 // these 2 methods shouldn't be called for report view controls, in that
333 // case we determine our position/size ourselves
335 // calculate the size of the line
336 void CalculateSize( wxDC
*dc
, int spacing
);
338 // remember the position this line appears at
339 void SetPosition( int x
, int y
, int spacing
);
343 void SetImage( int image
) { SetImage(0, image
); }
344 int GetImage() const { return GetImage(0); }
345 void SetImage( int index
, int image
);
346 int GetImage( int index
) const;
348 bool HasImage() const { return GetImage() != -1; }
349 bool HasText() const { return !GetText(0).empty(); }
351 void SetItem( int index
, const wxListItem
&info
);
352 void GetItem( int index
, wxListItem
&info
);
354 wxString
GetText(int index
) const;
355 void SetText( int index
, const wxString
& s
);
357 wxListItemAttr
*GetAttr() const;
358 void SetAttr(wxListItemAttr
*attr
);
360 // return true if the highlighting really changed
361 bool Highlight( bool on
);
363 void ReverseHighlight();
365 bool IsHighlighted() const
367 wxASSERT_MSG( !IsVirtual(), _T("unexpected call to IsHighlighted") );
369 return m_highlighted
;
372 // draw the line on the given DC in icon/list mode
373 void Draw( wxDC
*dc
);
375 // the same in report mode
376 void DrawInReportMode( wxDC
*dc
,
378 const wxRect
& rectHL
,
382 // set the line to contain num items (only can be > 1 in report mode)
383 void InitItems( int num
);
385 // get the mode (i.e. style) of the list control
386 inline int GetMode() const;
388 // prepare the DC for drawing with these item's attributes, return true if
389 // we need to draw the items background to highlight it, false otherwise
390 bool SetAttributes(wxDC
*dc
,
391 const wxListItemAttr
*attr
,
394 // draw the text on the DC with the correct justification; also add an
395 // ellipsis if the text is too large to fit in the current width
396 void DrawTextFormatted(wxDC
*dc
,
397 const wxString
&text
,
400 int yMid
, // this is middle, not top, of the text
404 WX_DECLARE_EXPORTED_OBJARRAY(wxListLineData
, wxListLineDataArray
);
405 #include "wx/arrimpl.cpp"
406 WX_DEFINE_OBJARRAY(wxListLineDataArray
)
408 //-----------------------------------------------------------------------------
409 // wxListHeaderWindow (internal)
410 //-----------------------------------------------------------------------------
412 class WXDLLEXPORT wxListHeaderWindow
: public wxWindow
415 wxListMainWindow
*m_owner
;
416 const wxCursor
*m_currentCursor
;
417 wxCursor
*m_resizeCursor
;
420 // column being resized or -1
423 // divider line position in logical (unscrolled) coords
426 // minimal position beyond which the divider line
427 // can't be dragged in logical coords
431 wxListHeaderWindow();
433 wxListHeaderWindow( wxWindow
*win
,
435 wxListMainWindow
*owner
,
436 const wxPoint
&pos
= wxDefaultPosition
,
437 const wxSize
&size
= wxDefaultSize
,
439 const wxString
&name
= wxT("wxlistctrlcolumntitles") );
441 virtual ~wxListHeaderWindow();
444 void AdjustDC( wxDC
& dc
);
446 void OnPaint( wxPaintEvent
&event
);
447 void OnMouse( wxMouseEvent
&event
);
448 void OnSetFocus( wxFocusEvent
&event
);
454 // common part of all ctors
457 // generate and process the list event of the given type, return true if
458 // it wasn't vetoed, i.e. if we should proceed
459 bool SendListEvent(wxEventType type
, const wxPoint
& pos
);
461 DECLARE_DYNAMIC_CLASS(wxListHeaderWindow
)
462 DECLARE_EVENT_TABLE()
465 //-----------------------------------------------------------------------------
466 // wxListRenameTimer (internal)
467 //-----------------------------------------------------------------------------
469 class WXDLLEXPORT wxListRenameTimer
: public wxTimer
472 wxListMainWindow
*m_owner
;
475 wxListRenameTimer( wxListMainWindow
*owner
);
479 //-----------------------------------------------------------------------------
480 // wxListTextCtrlWrapper: wraps a wxTextCtrl to make it work for inline editing
481 //-----------------------------------------------------------------------------
483 class WXDLLEXPORT wxListTextCtrlWrapper
: public wxEvtHandler
486 // NB: text must be a valid object but not Create()d yet
487 wxListTextCtrlWrapper(wxListMainWindow
*owner
,
491 wxTextCtrl
*GetText() const { return m_text
; }
493 void AcceptChangesAndFinish();
496 void OnChar( wxKeyEvent
&event
);
497 void OnKeyUp( wxKeyEvent
&event
);
498 void OnKillFocus( wxFocusEvent
&event
);
500 bool AcceptChanges();
504 wxListMainWindow
*m_owner
;
506 wxString m_startValue
;
509 bool m_aboutToFinish
;
511 DECLARE_EVENT_TABLE()
514 //-----------------------------------------------------------------------------
515 // wxListMainWindow (internal)
516 //-----------------------------------------------------------------------------
518 WX_DECLARE_EXPORTED_LIST(wxListHeaderData
, wxListHeaderDataList
);
519 #include "wx/listimpl.cpp"
520 WX_DEFINE_LIST(wxListHeaderDataList
)
522 class wxListMainWindow
: public wxScrolledWindow
526 wxListMainWindow( wxWindow
*parent
,
528 const wxPoint
& pos
= wxDefaultPosition
,
529 const wxSize
& size
= wxDefaultSize
,
531 const wxString
&name
= _T("listctrlmainwindow") );
533 virtual ~wxListMainWindow();
535 bool HasFlag(int flag
) const { return m_parent
->HasFlag(flag
); }
537 // return true if this is a virtual list control
538 bool IsVirtual() const { return HasFlag(wxLC_VIRTUAL
); }
540 // return true if the control is in report mode
541 bool InReportView() const { return HasFlag(wxLC_REPORT
); }
543 // return true if we are in single selection mode, false if multi sel
544 bool IsSingleSel() const { return HasFlag(wxLC_SINGLE_SEL
); }
546 // do we have a header window?
547 bool HasHeader() const
548 { return InReportView() && !HasFlag(wxLC_NO_HEADER
); }
550 void HighlightAll( bool on
);
552 // all these functions only do something if the line is currently visible
554 // change the line "selected" state, return true if it really changed
555 bool HighlightLine( size_t line
, bool highlight
= true);
557 // as HighlightLine() but do it for the range of lines: this is incredibly
558 // more efficient for virtual list controls!
560 // NB: unlike HighlightLine() this one does refresh the lines on screen
561 void HighlightLines( size_t lineFrom
, size_t lineTo
, bool on
= true );
563 // toggle the line state and refresh it
564 void ReverseHighlight( size_t line
)
565 { HighlightLine(line
, !IsHighlighted(line
)); RefreshLine(line
); }
567 // return true if the line is highlighted
568 bool IsHighlighted(size_t line
) const;
570 // refresh one or several lines at once
571 void RefreshLine( size_t line
);
572 void RefreshLines( size_t lineFrom
, size_t lineTo
);
574 // refresh all selected items
575 void RefreshSelected();
577 // refresh all lines below the given one: the difference with
578 // RefreshLines() is that the index here might not be a valid one (happens
579 // when the last line is deleted)
580 void RefreshAfter( size_t lineFrom
);
582 // the methods which are forwarded to wxListLineData itself in list/icon
583 // modes but are here because the lines don't store their positions in the
586 // get the bound rect for the entire line
587 wxRect
GetLineRect(size_t line
) const;
589 // get the bound rect of the label
590 wxRect
GetLineLabelRect(size_t line
) const;
592 // get the bound rect of the items icon (only may be called if we do have
594 wxRect
GetLineIconRect(size_t line
) const;
596 // get the rect to be highlighted when the item has focus
597 wxRect
GetLineHighlightRect(size_t line
) const;
599 // get the size of the total line rect
600 wxSize
GetLineSize(size_t line
) const
601 { return GetLineRect(line
).GetSize(); }
603 // return the hit code for the corresponding position (in this line)
604 long HitTestLine(size_t line
, int x
, int y
) const;
606 // bring the selected item into view, scrolling to it if necessary
607 void MoveToItem(size_t item
);
609 // bring the current item into view
610 void MoveToFocus() { MoveToItem(m_current
); }
612 // start editing the label of the given item
613 wxTextCtrl
*EditLabel(long item
,
614 wxClassInfo
* textControlClass
= CLASSINFO(wxTextCtrl
));
615 wxTextCtrl
*GetEditControl() const
617 return m_textctrlWrapper
? m_textctrlWrapper
->GetText() : NULL
;
620 void FinishEditing(wxTextCtrl
*text
)
623 m_textctrlWrapper
= NULL
;
624 SetFocusIgnoringChildren();
627 // suspend/resume redrawing the control
631 void OnRenameTimer();
632 bool OnRenameAccept(size_t itemEdit
, const wxString
& value
);
633 void OnRenameCancelled(size_t itemEdit
);
635 void OnMouse( wxMouseEvent
&event
);
637 // called to switch the selection from the current item to newCurrent,
638 void OnArrowChar( size_t newCurrent
, const wxKeyEvent
& event
);
640 void OnChar( wxKeyEvent
&event
);
641 void OnKeyDown( wxKeyEvent
&event
);
642 void OnSetFocus( wxFocusEvent
&event
);
643 void OnKillFocus( wxFocusEvent
&event
);
644 void OnScroll( wxScrollWinEvent
& event
);
646 void OnPaint( wxPaintEvent
&event
);
648 void DrawImage( int index
, wxDC
*dc
, int x
, int y
);
649 void GetImageSize( int index
, int &width
, int &height
) const;
650 int GetTextLength( const wxString
&s
) const;
652 void SetImageList( wxImageListType
*imageList
, int which
);
653 void SetItemSpacing( int spacing
, bool isSmall
= false );
654 int GetItemSpacing( bool isSmall
= false );
656 void SetColumn( int col
, wxListItem
&item
);
657 void SetColumnWidth( int col
, int width
);
658 void GetColumn( int col
, wxListItem
&item
) const;
659 int GetColumnWidth( int col
) const;
660 int GetColumnCount() const { return m_columns
.GetCount(); }
662 // returns the sum of the heights of all columns
663 int GetHeaderWidth() const;
665 int GetCountPerPage() const;
667 void SetItem( wxListItem
&item
);
668 void GetItem( wxListItem
&item
) const;
669 void SetItemState( long item
, long state
, long stateMask
);
670 void SetItemStateAll( long state
, long stateMask
);
671 int GetItemState( long item
, long stateMask
) const;
672 void GetItemRect( long index
, wxRect
&rect
) const;
673 wxRect
GetViewRect() const;
674 bool GetItemPosition( long item
, wxPoint
& pos
) const;
675 int GetSelectedItemCount() const;
677 wxString
GetItemText(long item
) const
680 info
.m_mask
= wxLIST_MASK_TEXT
;
681 info
.m_itemId
= item
;
686 void SetItemText(long item
, const wxString
& value
)
689 info
.m_mask
= wxLIST_MASK_TEXT
;
690 info
.m_itemId
= item
;
695 // set the scrollbars and update the positions of the items
696 void RecalculatePositions(bool noRefresh
= false);
698 // refresh the window and the header
701 long GetNextItem( long item
, int geometry
, int state
) const;
702 void DeleteItem( long index
);
703 void DeleteAllItems();
704 void DeleteColumn( int col
);
705 void DeleteEverything();
706 void EnsureVisible( long index
);
707 long FindItem( long start
, const wxString
& str
, bool partial
= false );
708 long FindItem( long start
, wxUIntPtr data
);
709 long FindItem( const wxPoint
& pt
);
710 long HitTest( int x
, int y
, int &flags
) const;
711 void InsertItem( wxListItem
&item
);
712 void InsertColumn( long col
, wxListItem
&item
);
713 int GetItemWidthWithImage(wxListItem
* item
);
714 void SortItems( wxListCtrlCompare fn
, long data
);
716 size_t GetItemCount() const;
717 bool IsEmpty() const { return GetItemCount() == 0; }
718 void SetItemCount(long count
);
720 // change the current (== focused) item, send a notification event
721 void ChangeCurrent(size_t current
);
722 void ResetCurrent() { ChangeCurrent((size_t)-1); }
723 bool HasCurrent() const { return m_current
!= (size_t)-1; }
725 // send out a wxListEvent
726 void SendNotify( size_t line
,
728 const wxPoint
& point
= wxDefaultPosition
);
730 // override base class virtual to reset m_lineHeight when the font changes
731 virtual bool SetFont(const wxFont
& font
)
733 if ( !wxScrolledWindow::SetFont(font
) )
741 // these are for wxListLineData usage only
743 // get the backpointer to the list ctrl
744 wxGenericListCtrl
*GetListCtrl() const
746 return wxStaticCast(GetParent(), wxGenericListCtrl
);
749 // get the height of all lines (assuming they all do have the same height)
750 wxCoord
GetLineHeight() const;
752 // get the y position of the given line (only for report view)
753 wxCoord
GetLineY(size_t line
) const;
755 // get the brush to use for the item highlighting
756 wxBrush
*GetHighlightBrush() const
758 return m_hasFocus
? m_highlightBrush
: m_highlightUnfocusedBrush
;
762 // the array of all line objects for a non virtual list control (for the
763 // virtual list control we only ever use m_lines[0])
764 wxListLineDataArray m_lines
;
766 // the list of column objects
767 wxListHeaderDataList m_columns
;
769 // currently focused item or -1
772 // the number of lines per page
775 // this flag is set when something which should result in the window
776 // redrawing happens (i.e. an item was added or deleted, or its appearance
777 // changed) and OnPaint() doesn't redraw the window while it is set which
778 // allows to minimize the number of repaintings when a lot of items are
779 // being added. The real repainting occurs only after the next OnIdle()
783 wxColour
*m_highlightColour
;
784 wxImageListType
*m_small_image_list
;
785 wxImageListType
*m_normal_image_list
;
787 int m_normal_spacing
;
791 wxTimer
*m_renameTimer
;
795 ColWidthArray m_aColWidths
;
797 // for double click logic
798 size_t m_lineLastClicked
,
799 m_lineBeforeLastClicked
,
800 m_lineSelectSingleOnUp
;
803 wxWindow
*GetMainWindowOfCompositeControl() { return GetParent(); }
805 // the total count of items in a virtual list control
808 // the object maintaining the items selection state, only used in virtual
810 wxSelectionStore m_selStore
;
812 // common part of all ctors
815 // get the line data for the given index
816 wxListLineData
*GetLine(size_t n
) const
818 wxASSERT_MSG( n
!= (size_t)-1, _T("invalid line index") );
822 wxConstCast(this, wxListMainWindow
)->CacheLineData(n
);
829 // get a dummy line which can be used for geometry calculations and such:
830 // you must use GetLine() if you want to really draw the line
831 wxListLineData
*GetDummyLine() const;
833 // cache the line data of the n-th line in m_lines[0]
834 void CacheLineData(size_t line
);
836 // get the range of visible lines
837 void GetVisibleLinesRange(size_t *from
, size_t *to
);
839 // force us to recalculate the range of visible lines
840 void ResetVisibleLinesRange() { m_lineFrom
= (size_t)-1; }
842 // get the colour to be used for drawing the rules
843 wxColour
GetRuleColour() const
845 return wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT
);
849 // initialize the current item if needed
850 void UpdateCurrent();
852 // delete all items but don't refresh: called from dtor
853 void DoDeleteAllItems();
855 // the height of one line using the current font
856 wxCoord m_lineHeight
;
858 // the total header width or 0 if not calculated yet
859 wxCoord m_headerWidth
;
861 // the first and last lines being shown on screen right now (inclusive),
862 // both may be -1 if they must be calculated so never access them directly:
863 // use GetVisibleLinesRange() above instead
867 // the brushes to use for item highlighting when we do/don't have focus
868 wxBrush
*m_highlightBrush
,
869 *m_highlightUnfocusedBrush
;
871 // if this is > 0, the control is frozen and doesn't redraw itself
872 size_t m_freezeCount
;
874 // wrapper around the text control currently used for in place editing or
875 // NULL if no item is being edited
876 wxListTextCtrlWrapper
*m_textctrlWrapper
;
879 DECLARE_DYNAMIC_CLASS(wxListMainWindow
)
880 DECLARE_EVENT_TABLE()
882 friend class wxGenericListCtrl
;
886 wxListItemData::~wxListItemData()
888 // in the virtual list control the attributes are managed by the main
889 // program, so don't delete them
890 if ( !m_owner
->IsVirtual() )
896 void wxListItemData::Init()
904 wxListItemData::wxListItemData(wxListMainWindow
*owner
)
910 if ( owner
->InReportView() )
916 void wxListItemData::SetItem( const wxListItem
&info
)
918 if ( info
.m_mask
& wxLIST_MASK_TEXT
)
919 SetText(info
.m_text
);
920 if ( info
.m_mask
& wxLIST_MASK_IMAGE
)
921 m_image
= info
.m_image
;
922 if ( info
.m_mask
& wxLIST_MASK_DATA
)
923 m_data
= info
.m_data
;
925 if ( info
.HasAttributes() )
928 *m_attr
= *info
.GetAttributes();
930 m_attr
= new wxListItemAttr(*info
.GetAttributes());
938 m_rect
->width
= info
.m_width
;
942 void wxListItemData::SetPosition( int x
, int y
)
944 wxCHECK_RET( m_rect
, _T("unexpected SetPosition() call") );
950 void wxListItemData::SetSize( int width
, int height
)
952 wxCHECK_RET( m_rect
, _T("unexpected SetSize() call") );
955 m_rect
->width
= width
;
957 m_rect
->height
= height
;
960 bool wxListItemData::IsHit( int x
, int y
) const
962 wxCHECK_MSG( m_rect
, false, _T("can't be called in this mode") );
964 return wxRect(GetX(), GetY(), GetWidth(), GetHeight()).Contains(x
, y
);
967 int wxListItemData::GetX() const
969 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
974 int wxListItemData::GetY() const
976 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
981 int wxListItemData::GetWidth() const
983 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
985 return m_rect
->width
;
988 int wxListItemData::GetHeight() const
990 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
992 return m_rect
->height
;
995 void wxListItemData::GetItem( wxListItem
&info
) const
997 long mask
= info
.m_mask
;
999 // by default, get everything for backwards compatibility
1002 if ( mask
& wxLIST_MASK_TEXT
)
1003 info
.m_text
= m_text
;
1004 if ( mask
& wxLIST_MASK_IMAGE
)
1005 info
.m_image
= m_image
;
1006 if ( mask
& wxLIST_MASK_DATA
)
1007 info
.m_data
= m_data
;
1011 if ( m_attr
->HasTextColour() )
1012 info
.SetTextColour(m_attr
->GetTextColour());
1013 if ( m_attr
->HasBackgroundColour() )
1014 info
.SetBackgroundColour(m_attr
->GetBackgroundColour());
1015 if ( m_attr
->HasFont() )
1016 info
.SetFont(m_attr
->GetFont());
1020 //-----------------------------------------------------------------------------
1022 //-----------------------------------------------------------------------------
1024 void wxListHeaderData::Init()
1035 wxListHeaderData::wxListHeaderData()
1040 wxListHeaderData::wxListHeaderData( const wxListItem
&item
)
1047 void wxListHeaderData::SetItem( const wxListItem
&item
)
1049 m_mask
= item
.m_mask
;
1051 if ( m_mask
& wxLIST_MASK_TEXT
)
1052 m_text
= item
.m_text
;
1054 if ( m_mask
& wxLIST_MASK_IMAGE
)
1055 m_image
= item
.m_image
;
1057 if ( m_mask
& wxLIST_MASK_FORMAT
)
1058 m_format
= item
.m_format
;
1060 if ( m_mask
& wxLIST_MASK_WIDTH
)
1061 SetWidth(item
.m_width
);
1064 void wxListHeaderData::SetPosition( int x
, int y
)
1070 void wxListHeaderData::SetHeight( int h
)
1075 void wxListHeaderData::SetWidth( int w
)
1077 m_width
= w
< 0 ? WIDTH_COL_DEFAULT
: w
;
1080 void wxListHeaderData::SetFormat( int format
)
1085 bool wxListHeaderData::HasImage() const
1087 return m_image
!= -1;
1090 bool wxListHeaderData::IsHit( int x
, int y
) const
1092 return ((x
>= m_xpos
) && (x
<= m_xpos
+m_width
) && (y
>= m_ypos
) && (y
<= m_ypos
+m_height
));
1095 void wxListHeaderData::GetItem( wxListItem
& item
)
1097 item
.m_mask
= m_mask
;
1098 item
.m_text
= m_text
;
1099 item
.m_image
= m_image
;
1100 item
.m_format
= m_format
;
1101 item
.m_width
= m_width
;
1104 int wxListHeaderData::GetImage() const
1109 int wxListHeaderData::GetWidth() const
1114 int wxListHeaderData::GetFormat() const
1119 //-----------------------------------------------------------------------------
1121 //-----------------------------------------------------------------------------
1123 inline int wxListLineData::GetMode() const
1125 return m_owner
->GetListCtrl()->GetWindowStyleFlag() & wxLC_MASK_TYPE
;
1128 inline bool wxListLineData::InReportView() const
1130 return m_owner
->HasFlag(wxLC_REPORT
);
1133 inline bool wxListLineData::IsVirtual() const
1135 return m_owner
->IsVirtual();
1138 wxListLineData::wxListLineData( wxListMainWindow
*owner
)
1142 if ( InReportView() )
1145 m_gi
= new GeometryInfo
;
1147 m_highlighted
= false;
1149 InitItems( GetMode() == wxLC_REPORT
? m_owner
->GetColumnCount() : 1 );
1152 void wxListLineData::CalculateSize( wxDC
*dc
, int spacing
)
1154 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1155 wxCHECK_RET( node
, _T("no subitems at all??") );
1157 wxListItemData
*item
= node
->GetData();
1162 switch ( GetMode() )
1165 case wxLC_SMALL_ICON
:
1166 m_gi
->m_rectAll
.width
= spacing
;
1168 s
= item
->GetText();
1173 m_gi
->m_rectLabel
.width
=
1174 m_gi
->m_rectLabel
.height
= 0;
1178 dc
->GetTextExtent( s
, &lw
, &lh
);
1182 m_gi
->m_rectAll
.height
= spacing
+ lh
;
1184 m_gi
->m_rectAll
.width
= lw
;
1186 m_gi
->m_rectLabel
.width
= lw
;
1187 m_gi
->m_rectLabel
.height
= lh
;
1190 if (item
->HasImage())
1193 m_owner
->GetImageSize( item
->GetImage(), w
, h
);
1194 m_gi
->m_rectIcon
.width
= w
+ 8;
1195 m_gi
->m_rectIcon
.height
= h
+ 8;
1197 if ( m_gi
->m_rectIcon
.width
> m_gi
->m_rectAll
.width
)
1198 m_gi
->m_rectAll
.width
= m_gi
->m_rectIcon
.width
;
1199 if ( m_gi
->m_rectIcon
.height
+ lh
> m_gi
->m_rectAll
.height
- 4 )
1200 m_gi
->m_rectAll
.height
= m_gi
->m_rectIcon
.height
+ lh
+ 4;
1203 if ( item
->HasText() )
1205 m_gi
->m_rectHighlight
.width
= m_gi
->m_rectLabel
.width
;
1206 m_gi
->m_rectHighlight
.height
= m_gi
->m_rectLabel
.height
;
1208 else // no text, highlight the icon
1210 m_gi
->m_rectHighlight
.width
= m_gi
->m_rectIcon
.width
;
1211 m_gi
->m_rectHighlight
.height
= m_gi
->m_rectIcon
.height
;
1216 s
= item
->GetTextForMeasuring();
1218 dc
->GetTextExtent( s
, &lw
, &lh
);
1222 m_gi
->m_rectLabel
.width
= lw
;
1223 m_gi
->m_rectLabel
.height
= lh
;
1225 m_gi
->m_rectAll
.width
= lw
;
1226 m_gi
->m_rectAll
.height
= lh
;
1228 if (item
->HasImage())
1231 m_owner
->GetImageSize( item
->GetImage(), w
, h
);
1232 m_gi
->m_rectIcon
.width
= w
;
1233 m_gi
->m_rectIcon
.height
= h
;
1235 m_gi
->m_rectAll
.width
+= 4 + w
;
1236 if (h
> m_gi
->m_rectAll
.height
)
1237 m_gi
->m_rectAll
.height
= h
;
1240 m_gi
->m_rectHighlight
.width
= m_gi
->m_rectAll
.width
;
1241 m_gi
->m_rectHighlight
.height
= m_gi
->m_rectAll
.height
;
1245 wxFAIL_MSG( _T("unexpected call to SetSize") );
1249 wxFAIL_MSG( _T("unknown mode") );
1254 void wxListLineData::SetPosition( int x
, int y
, int spacing
)
1256 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1257 wxCHECK_RET( node
, _T("no subitems at all??") );
1259 wxListItemData
*item
= node
->GetData();
1261 switch ( GetMode() )
1264 case wxLC_SMALL_ICON
:
1265 m_gi
->m_rectAll
.x
= x
;
1266 m_gi
->m_rectAll
.y
= y
;
1268 if ( item
->HasImage() )
1270 m_gi
->m_rectIcon
.x
= m_gi
->m_rectAll
.x
+ 4 +
1271 (m_gi
->m_rectAll
.width
- m_gi
->m_rectIcon
.width
) / 2;
1272 m_gi
->m_rectIcon
.y
= m_gi
->m_rectAll
.y
+ 4;
1275 if ( item
->HasText() )
1277 if (m_gi
->m_rectAll
.width
> spacing
)
1278 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ 2;
1280 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ 2 + (spacing
/ 2) - (m_gi
->m_rectLabel
.width
/ 2);
1281 m_gi
->m_rectLabel
.y
= m_gi
->m_rectAll
.y
+ m_gi
->m_rectAll
.height
+ 2 - m_gi
->m_rectLabel
.height
;
1282 m_gi
->m_rectHighlight
.x
= m_gi
->m_rectLabel
.x
- 2;
1283 m_gi
->m_rectHighlight
.y
= m_gi
->m_rectLabel
.y
- 2;
1285 else // no text, highlight the icon
1287 m_gi
->m_rectHighlight
.x
= m_gi
->m_rectIcon
.x
- 4;
1288 m_gi
->m_rectHighlight
.y
= m_gi
->m_rectIcon
.y
- 4;
1293 m_gi
->m_rectAll
.x
= x
;
1294 m_gi
->m_rectAll
.y
= y
;
1296 m_gi
->m_rectHighlight
.x
= m_gi
->m_rectAll
.x
;
1297 m_gi
->m_rectHighlight
.y
= m_gi
->m_rectAll
.y
;
1298 m_gi
->m_rectLabel
.y
= m_gi
->m_rectAll
.y
+ 2;
1300 if (item
->HasImage())
1302 m_gi
->m_rectIcon
.x
= m_gi
->m_rectAll
.x
+ 2;
1303 m_gi
->m_rectIcon
.y
= m_gi
->m_rectAll
.y
+ 2;
1304 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ 6 + m_gi
->m_rectIcon
.width
;
1308 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ 2;
1313 wxFAIL_MSG( _T("unexpected call to SetPosition") );
1317 wxFAIL_MSG( _T("unknown mode") );
1322 void wxListLineData::InitItems( int num
)
1324 for (int i
= 0; i
< num
; i
++)
1325 m_items
.Append( new wxListItemData(m_owner
) );
1328 void wxListLineData::SetItem( int index
, const wxListItem
&info
)
1330 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1331 wxCHECK_RET( node
, _T("invalid column index in SetItem") );
1333 wxListItemData
*item
= node
->GetData();
1334 item
->SetItem( info
);
1337 void wxListLineData::GetItem( int index
, wxListItem
&info
)
1339 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1342 wxListItemData
*item
= node
->GetData();
1343 item
->GetItem( info
);
1347 wxString
wxListLineData::GetText(int index
) const
1351 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1354 wxListItemData
*item
= node
->GetData();
1355 s
= item
->GetText();
1361 void wxListLineData::SetText( int index
, const wxString
& s
)
1363 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1366 wxListItemData
*item
= node
->GetData();
1371 void wxListLineData::SetImage( int index
, int image
)
1373 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1374 wxCHECK_RET( node
, _T("invalid column index in SetImage()") );
1376 wxListItemData
*item
= node
->GetData();
1377 item
->SetImage(image
);
1380 int wxListLineData::GetImage( int index
) const
1382 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1383 wxCHECK_MSG( node
, -1, _T("invalid column index in GetImage()") );
1385 wxListItemData
*item
= node
->GetData();
1386 return item
->GetImage();
1389 wxListItemAttr
*wxListLineData::GetAttr() const
1391 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1392 wxCHECK_MSG( node
, NULL
, _T("invalid column index in GetAttr()") );
1394 wxListItemData
*item
= node
->GetData();
1395 return item
->GetAttr();
1398 void wxListLineData::SetAttr(wxListItemAttr
*attr
)
1400 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1401 wxCHECK_RET( node
, _T("invalid column index in SetAttr()") );
1403 wxListItemData
*item
= node
->GetData();
1404 item
->SetAttr(attr
);
1407 bool wxListLineData::SetAttributes(wxDC
*dc
,
1408 const wxListItemAttr
*attr
,
1411 wxWindow
*listctrl
= m_owner
->GetParent();
1415 // don't use foreground colour for drawing highlighted items - this might
1416 // make them completely invisible (and there is no way to do bit
1417 // arithmetics on wxColour, unfortunately)
1420 colText
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
);
1421 else if ( attr
&& attr
->HasTextColour() )
1422 colText
= attr
->GetTextColour();
1424 colText
= listctrl
->GetForegroundColour();
1426 dc
->SetTextForeground(colText
);
1430 if ( attr
&& attr
->HasFont() )
1431 font
= attr
->GetFont();
1433 font
= listctrl
->GetFont();
1438 bool hasBgCol
= attr
&& attr
->HasBackgroundColour();
1439 if ( highlighted
|| hasBgCol
)
1442 dc
->SetBrush( *m_owner
->GetHighlightBrush() );
1444 dc
->SetBrush(wxBrush(attr
->GetBackgroundColour(), wxSOLID
));
1446 dc
->SetPen( *wxTRANSPARENT_PEN
);
1454 void wxListLineData::Draw( wxDC
*dc
)
1456 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1457 wxCHECK_RET( node
, _T("no subitems at all??") );
1459 bool highlighted
= IsHighlighted();
1461 wxListItemAttr
*attr
= GetAttr();
1463 if ( SetAttributes(dc
, attr
, highlighted
) )
1464 dc
->DrawRectangle( m_gi
->m_rectHighlight
);
1466 // just for debugging to better see where the items are
1468 dc
->SetPen(*wxRED_PEN
);
1469 dc
->SetBrush(*wxTRANSPARENT_BRUSH
);
1470 dc
->DrawRectangle( m_gi
->m_rectAll
);
1471 dc
->SetPen(*wxGREEN_PEN
);
1472 dc
->DrawRectangle( m_gi
->m_rectIcon
);
1475 wxListItemData
*item
= node
->GetData();
1476 if (item
->HasImage())
1478 // centre the image inside our rectangle, this looks nicer when items
1479 // ae aligned in a row
1480 const wxRect
& rectIcon
= m_gi
->m_rectIcon
;
1482 m_owner
->DrawImage(item
->GetImage(), dc
, rectIcon
.x
, rectIcon
.y
);
1485 if (item
->HasText())
1487 const wxRect
& rectLabel
= m_gi
->m_rectLabel
;
1489 wxDCClipper
clipper(*dc
, rectLabel
);
1490 dc
->DrawText(item
->GetText(), rectLabel
.x
, rectLabel
.y
);
1494 void wxListLineData::DrawInReportMode( wxDC
*dc
,
1496 const wxRect
& rectHL
,
1499 // TODO: later we should support setting different attributes for
1500 // different columns - to do it, just add "col" argument to
1501 // GetAttr() and move these lines into the loop below
1502 wxListItemAttr
*attr
= GetAttr();
1503 if ( SetAttributes(dc
, attr
, highlighted
) )
1504 dc
->DrawRectangle( rectHL
);
1506 wxCoord x
= rect
.x
+ HEADER_OFFSET_X
,
1507 yMid
= rect
.y
+ rect
.height
/2;
1510 for ( wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1512 node
= node
->GetNext(), col
++ )
1514 wxListItemData
*item
= node
->GetData();
1516 int width
= m_owner
->GetColumnWidth(col
);
1520 if ( item
->HasImage() )
1523 m_owner
->GetImageSize( item
->GetImage(), ix
, iy
);
1524 m_owner
->DrawImage( item
->GetImage(), dc
, xOld
, yMid
- iy
/2 );
1526 ix
+= IMAGE_MARGIN_IN_REPORT_MODE
;
1532 if ( item
->HasText() )
1533 DrawTextFormatted(dc
, item
->GetText(), col
, xOld
, yMid
, width
- 8);
1537 void wxListLineData::DrawTextFormatted(wxDC
*dc
,
1538 const wxString
&text
,
1545 dc
->GetTextExtent(text
, &w
, &h
);
1547 const wxCoord y
= yMid
- (h
+ 1)/2;
1549 wxDCClipper
clipper(*dc
, x
, y
, width
, h
);
1551 // determine if the string can fit inside the current width
1554 // it can, draw it using the items alignment
1556 m_owner
->GetColumn(col
, item
);
1557 switch ( item
.GetAlign() )
1559 case wxLIST_FORMAT_LEFT
:
1563 case wxLIST_FORMAT_RIGHT
:
1567 case wxLIST_FORMAT_CENTER
:
1568 x
+= (width
- w
) / 2;
1572 wxFAIL_MSG( _T("unknown list item format") );
1576 dc
->DrawText(text
, x
, y
);
1578 else // otherwise, truncate and add an ellipsis if possible
1580 // determine the base width
1581 wxString
ellipsis(wxT("..."));
1583 dc
->GetTextExtent(ellipsis
, &base_w
, &h
);
1585 // continue until we have enough space or only one character left
1587 size_t len
= text
.length();
1588 wxString drawntext
= text
.Left(len
);
1591 dc
->GetTextExtent(drawntext
.Last(), &w_c
, &h_c
);
1592 drawntext
.RemoveLast();
1595 if (w
+ base_w
<= width
)
1599 // if still not enough space, remove ellipsis characters
1600 while (ellipsis
.length() > 0 && w
+ base_w
> width
)
1602 ellipsis
= ellipsis
.Left(ellipsis
.length() - 1);
1603 dc
->GetTextExtent(ellipsis
, &base_w
, &h
);
1606 // now draw the text
1607 dc
->DrawText(drawntext
, x
, y
);
1608 dc
->DrawText(ellipsis
, x
+ w
, y
);
1612 bool wxListLineData::Highlight( bool on
)
1614 wxCHECK_MSG( !IsVirtual(), false, _T("unexpected call to Highlight") );
1616 if ( on
== m_highlighted
)
1624 void wxListLineData::ReverseHighlight( void )
1626 Highlight(!IsHighlighted());
1629 //-----------------------------------------------------------------------------
1630 // wxListHeaderWindow
1631 //-----------------------------------------------------------------------------
1633 IMPLEMENT_DYNAMIC_CLASS(wxListHeaderWindow
,wxWindow
)
1635 BEGIN_EVENT_TABLE(wxListHeaderWindow
,wxWindow
)
1636 EVT_PAINT (wxListHeaderWindow::OnPaint
)
1637 EVT_MOUSE_EVENTS (wxListHeaderWindow::OnMouse
)
1638 EVT_SET_FOCUS (wxListHeaderWindow::OnSetFocus
)
1641 void wxListHeaderWindow::Init()
1643 m_currentCursor
= (wxCursor
*) NULL
;
1644 m_isDragging
= false;
1648 wxListHeaderWindow::wxListHeaderWindow()
1652 m_owner
= (wxListMainWindow
*) NULL
;
1653 m_resizeCursor
= (wxCursor
*) NULL
;
1656 wxListHeaderWindow::wxListHeaderWindow( wxWindow
*win
,
1658 wxListMainWindow
*owner
,
1662 const wxString
&name
)
1663 : wxWindow( win
, id
, pos
, size
, style
, name
)
1668 m_resizeCursor
= new wxCursor( wxCURSOR_SIZEWE
);
1671 wxVisualAttributes attr
= wxPanel::GetClassDefaultAttributes();
1672 SetOwnForegroundColour( attr
.colFg
);
1673 SetOwnBackgroundColour( attr
.colBg
);
1675 SetOwnFont( attr
.font
);
1677 SetOwnForegroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
));
1678 SetOwnBackgroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
));
1680 SetOwnFont( wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
));
1684 wxListHeaderWindow::~wxListHeaderWindow()
1686 delete m_resizeCursor
;
1689 #ifdef __WXUNIVERSAL__
1690 #include "wx/univ/renderer.h"
1691 #include "wx/univ/theme.h"
1694 // shift the DC origin to match the position of the main window horz
1695 // scrollbar: this allows us to always use logical coords
1696 void wxListHeaderWindow::AdjustDC(wxDC
& dc
)
1699 m_owner
->GetScrollPixelsPerUnit( &xpix
, NULL
);
1702 m_owner
->GetViewStart( &x
, NULL
);
1704 // account for the horz scrollbar offset
1705 dc
.SetDeviceOrigin( -x
* xpix
, 0 );
1708 void wxListHeaderWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
1710 wxPaintDC
dc( this );
1715 dc
.SetFont( GetFont() );
1717 // width and height of the entire header window
1719 GetClientSize( &w
, &h
);
1720 m_owner
->CalcUnscrolledPosition(w
, 0, &w
, NULL
);
1722 dc
.SetBackgroundMode(wxTRANSPARENT
);
1723 dc
.SetTextForeground(GetForegroundColour());
1725 int x
= HEADER_OFFSET_X
;
1726 int numColumns
= m_owner
->GetColumnCount();
1728 for ( int i
= 0; i
< numColumns
&& x
< w
; i
++ )
1730 m_owner
->GetColumn( i
, item
);
1731 int wCol
= item
.m_width
;
1733 // the width of the rect to draw: make it smaller to fit entirely
1734 // inside the column rect
1743 wxRendererNative::Get().DrawHeaderButton
1747 wxRect(x
, HEADER_OFFSET_Y
, cw
, ch
),
1748 m_parent
->IsEnabled() ? 0
1749 : (int)wxCONTROL_DISABLED
1752 // see if we have enough space for the column label
1754 // for this we need the width of the text
1757 dc
.GetTextExtent(item
.GetText(), &wLabel
, &hLabel
);
1758 wLabel
+= 2 * EXTRA_WIDTH
;
1760 // and the width of the icon, if any
1761 static const int MARGIN_BETWEEN_TEXT_AND_ICON
= 2;
1762 int ix
= 0, iy
= 0; // init them just to suppress the compiler warnings
1763 const int image
= item
.m_image
;
1764 wxImageListType
*imageList
;
1767 imageList
= m_owner
->m_small_image_list
;
1770 imageList
->GetSize(image
, ix
, iy
);
1771 wLabel
+= ix
+ MARGIN_BETWEEN_TEXT_AND_ICON
;
1779 // ignore alignment if there is not enough space anyhow
1781 switch ( wLabel
< cw
? item
.GetAlign() : wxLIST_FORMAT_LEFT
)
1784 wxFAIL_MSG( _T("unknown list item format") );
1787 case wxLIST_FORMAT_LEFT
:
1791 case wxLIST_FORMAT_RIGHT
:
1792 xAligned
= x
+ cw
- wLabel
;
1795 case wxLIST_FORMAT_CENTER
:
1796 xAligned
= x
+ (cw
- wLabel
) / 2;
1800 // if we have an image, draw it on the right of the label
1807 xAligned
+ wLabel
- ix
- MARGIN_BETWEEN_TEXT_AND_ICON
,
1808 HEADER_OFFSET_Y
+ (h
- 4 - iy
)/2,
1809 wxIMAGELIST_DRAW_TRANSPARENT
1812 cw
-= ix
+ MARGIN_BETWEEN_TEXT_AND_ICON
;
1815 // draw the text clipping it so that it doesn't overwrite the column
1817 wxDCClipper
clipper(dc
, x
, HEADER_OFFSET_Y
, cw
, h
- 4 );
1819 dc
.DrawText( item
.GetText(),
1820 xAligned
+ EXTRA_WIDTH
, h
/ 2 - hLabel
/ 2 ); //HEADER_OFFSET_Y + EXTRA_HEIGHT );
1826 void wxListHeaderWindow::DrawCurrent()
1828 int x1
= m_currentX
;
1830 m_owner
->ClientToScreen( &x1
, &y1
);
1832 int x2
= m_currentX
;
1834 m_owner
->GetClientSize( NULL
, &y2
);
1835 m_owner
->ClientToScreen( &x2
, &y2
);
1838 dc
.SetLogicalFunction( wxINVERT
);
1839 dc
.SetPen( wxPen( *wxBLACK
, 2, wxSOLID
) );
1840 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
1844 dc
.DrawLine( x1
, y1
, x2
, y2
);
1846 dc
.SetLogicalFunction( wxCOPY
);
1848 dc
.SetPen( wxNullPen
);
1849 dc
.SetBrush( wxNullBrush
);
1852 void wxListHeaderWindow::OnMouse( wxMouseEvent
&event
)
1854 // we want to work with logical coords
1856 m_owner
->CalcUnscrolledPosition(event
.GetX(), 0, &x
, NULL
);
1857 int y
= event
.GetY();
1861 SendListEvent(wxEVT_COMMAND_LIST_COL_DRAGGING
, event
.GetPosition());
1863 // we don't draw the line beyond our window, but we allow dragging it
1866 GetClientSize( &w
, NULL
);
1867 m_owner
->CalcUnscrolledPosition(w
, 0, &w
, NULL
);
1870 // erase the line if it was drawn
1871 if ( m_currentX
< w
)
1874 if (event
.ButtonUp())
1877 m_isDragging
= false;
1879 m_owner
->SetColumnWidth( m_column
, m_currentX
- m_minX
);
1880 SendListEvent(wxEVT_COMMAND_LIST_COL_END_DRAG
, event
.GetPosition());
1887 m_currentX
= m_minX
+ 7;
1889 // draw in the new location
1890 if ( m_currentX
< w
)
1894 else // not dragging
1897 bool hit_border
= false;
1899 // end of the current column
1902 // find the column where this event occurred
1904 countCol
= m_owner
->GetColumnCount();
1905 for (col
= 0; col
< countCol
; col
++)
1907 xpos
+= m_owner
->GetColumnWidth( col
);
1910 if ( (abs(x
-xpos
) < 3) && (y
< 22) )
1912 // near the column border
1919 // inside the column
1926 if ( col
== countCol
)
1929 if (event
.LeftDown() || event
.RightUp())
1931 if (hit_border
&& event
.LeftDown())
1933 if ( SendListEvent(wxEVT_COMMAND_LIST_COL_BEGIN_DRAG
,
1934 event
.GetPosition()) )
1936 m_isDragging
= true;
1941 //else: column resizing was vetoed by the user code
1943 else // click on a column
1945 SendListEvent( event
.LeftDown()
1946 ? wxEVT_COMMAND_LIST_COL_CLICK
1947 : wxEVT_COMMAND_LIST_COL_RIGHT_CLICK
,
1948 event
.GetPosition());
1951 else if (event
.Moving())
1956 setCursor
= m_currentCursor
== wxSTANDARD_CURSOR
;
1957 m_currentCursor
= m_resizeCursor
;
1961 setCursor
= m_currentCursor
!= wxSTANDARD_CURSOR
;
1962 m_currentCursor
= wxSTANDARD_CURSOR
;
1966 SetCursor(*m_currentCursor
);
1971 void wxListHeaderWindow::OnSetFocus( wxFocusEvent
&WXUNUSED(event
) )
1973 m_owner
->SetFocus();
1977 bool wxListHeaderWindow::SendListEvent(wxEventType type
, const wxPoint
& pos
)
1979 wxWindow
*parent
= GetParent();
1980 wxListEvent
le( type
, parent
->GetId() );
1981 le
.SetEventObject( parent
);
1982 le
.m_pointDrag
= pos
;
1984 // the position should be relative to the parent window, not
1985 // this one for compatibility with MSW and common sense: the
1986 // user code doesn't know anything at all about this header
1987 // window, so why should it get positions relative to it?
1988 le
.m_pointDrag
.y
-= GetSize().y
;
1990 le
.m_col
= m_column
;
1991 return !parent
->GetEventHandler()->ProcessEvent( le
) || le
.IsAllowed();
1994 //-----------------------------------------------------------------------------
1995 // wxListRenameTimer (internal)
1996 //-----------------------------------------------------------------------------
1998 wxListRenameTimer::wxListRenameTimer( wxListMainWindow
*owner
)
2003 void wxListRenameTimer::Notify()
2005 m_owner
->OnRenameTimer();
2008 //-----------------------------------------------------------------------------
2009 // wxListTextCtrlWrapper (internal)
2010 //-----------------------------------------------------------------------------
2012 BEGIN_EVENT_TABLE(wxListTextCtrlWrapper
, wxEvtHandler
)
2013 EVT_CHAR (wxListTextCtrlWrapper::OnChar
)
2014 EVT_KEY_UP (wxListTextCtrlWrapper::OnKeyUp
)
2015 EVT_KILL_FOCUS (wxListTextCtrlWrapper::OnKillFocus
)
2018 wxListTextCtrlWrapper::wxListTextCtrlWrapper(wxListMainWindow
*owner
,
2021 : m_startValue(owner
->GetItemText(itemEdit
)),
2022 m_itemEdited(itemEdit
)
2027 m_aboutToFinish
= false;
2029 wxRect rectLabel
= owner
->GetLineLabelRect(itemEdit
);
2031 m_owner
->CalcScrolledPosition(rectLabel
.x
, rectLabel
.y
,
2032 &rectLabel
.x
, &rectLabel
.y
);
2034 m_text
->Create(owner
, wxID_ANY
, m_startValue
,
2035 wxPoint(rectLabel
.x
-4,rectLabel
.y
-4),
2036 wxSize(rectLabel
.width
+11,rectLabel
.height
+8));
2039 m_text
->PushEventHandler(this);
2042 void wxListTextCtrlWrapper::Finish()
2048 m_text
->RemoveEventHandler(this);
2049 m_owner
->FinishEditing(m_text
);
2051 wxPendingDelete
.Append( this );
2055 bool wxListTextCtrlWrapper::AcceptChanges()
2057 const wxString value
= m_text
->GetValue();
2059 if ( value
== m_startValue
)
2060 // nothing changed, always accept
2063 if ( !m_owner
->OnRenameAccept(m_itemEdited
, value
) )
2064 // vetoed by the user
2067 // accepted, do rename the item
2068 m_owner
->SetItemText(m_itemEdited
, value
);
2073 void wxListTextCtrlWrapper::AcceptChangesAndFinish()
2075 m_aboutToFinish
= true;
2077 // Notify the owner about the changes
2080 // Even if vetoed, close the control (consistent with MSW)
2084 void wxListTextCtrlWrapper::OnChar( wxKeyEvent
&event
)
2086 switch ( event
.m_keyCode
)
2089 AcceptChangesAndFinish();
2093 m_owner
->OnRenameCancelled( m_itemEdited
);
2102 void wxListTextCtrlWrapper::OnKeyUp( wxKeyEvent
&event
)
2110 // auto-grow the textctrl:
2111 wxSize parentSize
= m_owner
->GetSize();
2112 wxPoint myPos
= m_text
->GetPosition();
2113 wxSize mySize
= m_text
->GetSize();
2115 m_text
->GetTextExtent(m_text
->GetValue() + _T("MM"), &sx
, &sy
);
2116 if (myPos
.x
+ sx
> parentSize
.x
)
2117 sx
= parentSize
.x
- myPos
.x
;
2120 m_text
->SetSize(sx
, wxDefaultCoord
);
2125 void wxListTextCtrlWrapper::OnKillFocus( wxFocusEvent
&event
)
2127 if ( !m_finished
&& !m_aboutToFinish
)
2129 if ( !AcceptChanges() )
2130 m_owner
->OnRenameCancelled( m_itemEdited
);
2135 // We must let the native text control handle focus
2139 //-----------------------------------------------------------------------------
2141 //-----------------------------------------------------------------------------
2143 IMPLEMENT_DYNAMIC_CLASS(wxListMainWindow
,wxScrolledWindow
)
2145 BEGIN_EVENT_TABLE(wxListMainWindow
,wxScrolledWindow
)
2146 EVT_PAINT (wxListMainWindow::OnPaint
)
2147 EVT_MOUSE_EVENTS (wxListMainWindow::OnMouse
)
2148 EVT_CHAR (wxListMainWindow::OnChar
)
2149 EVT_KEY_DOWN (wxListMainWindow::OnKeyDown
)
2150 EVT_SET_FOCUS (wxListMainWindow::OnSetFocus
)
2151 EVT_KILL_FOCUS (wxListMainWindow::OnKillFocus
)
2152 EVT_SCROLLWIN (wxListMainWindow::OnScroll
)
2155 void wxListMainWindow::Init()
2160 m_lineTo
= (size_t)-1;
2166 m_small_image_list
= (wxImageListType
*) NULL
;
2167 m_normal_image_list
= (wxImageListType
*) NULL
;
2169 m_small_spacing
= 30;
2170 m_normal_spacing
= 40;
2174 m_isCreated
= false;
2176 m_lastOnSame
= false;
2177 m_renameTimer
= new wxListRenameTimer( this );
2178 m_textctrlWrapper
= NULL
;
2182 m_lineSelectSingleOnUp
=
2183 m_lineBeforeLastClicked
= (size_t)-1;
2188 wxListMainWindow::wxListMainWindow()
2193 m_highlightUnfocusedBrush
= (wxBrush
*) NULL
;
2196 wxListMainWindow::wxListMainWindow( wxWindow
*parent
,
2201 const wxString
&name
)
2202 : wxScrolledWindow( parent
, id
, pos
, size
,
2203 style
| wxHSCROLL
| wxVSCROLL
, name
)
2207 m_highlightBrush
= new wxBrush
2209 wxSystemSettings::GetColour
2211 wxSYS_COLOUR_HIGHLIGHT
2216 m_highlightUnfocusedBrush
= new wxBrush
2218 wxSystemSettings::GetColour
2220 wxSYS_COLOUR_BTNSHADOW
2225 SetScrollbars( 0, 0, 0, 0, 0, 0 );
2227 wxVisualAttributes attr
= wxGenericListCtrl::GetClassDefaultAttributes();
2228 SetOwnForegroundColour( attr
.colFg
);
2229 SetOwnBackgroundColour( attr
.colBg
);
2231 SetOwnFont( attr
.font
);
2234 wxListMainWindow::~wxListMainWindow()
2237 WX_CLEAR_LIST(wxListHeaderDataList
, m_columns
);
2238 WX_CLEAR_ARRAY(m_aColWidths
);
2240 delete m_highlightBrush
;
2241 delete m_highlightUnfocusedBrush
;
2242 delete m_renameTimer
;
2245 void wxListMainWindow::CacheLineData(size_t line
)
2247 wxGenericListCtrl
*listctrl
= GetListCtrl();
2249 wxListLineData
*ld
= GetDummyLine();
2251 size_t countCol
= GetColumnCount();
2252 for ( size_t col
= 0; col
< countCol
; col
++ )
2254 ld
->SetText(col
, listctrl
->OnGetItemText(line
, col
));
2255 ld
->SetImage(col
, listctrl
->OnGetItemColumnImage(line
, col
));
2258 ld
->SetAttr(listctrl
->OnGetItemAttr(line
));
2261 wxListLineData
*wxListMainWindow::GetDummyLine() const
2263 wxASSERT_MSG( !IsEmpty(), _T("invalid line index") );
2264 wxASSERT_MSG( IsVirtual(), _T("GetDummyLine() shouldn't be called") );
2266 wxListMainWindow
*self
= wxConstCast(this, wxListMainWindow
);
2268 // we need to recreate the dummy line if the number of columns in the
2269 // control changed as it would have the incorrect number of fields
2271 if ( !m_lines
.IsEmpty() &&
2272 m_lines
[0].m_items
.GetCount() != (size_t)GetColumnCount() )
2274 self
->m_lines
.Clear();
2277 if ( m_lines
.IsEmpty() )
2279 wxListLineData
*line
= new wxListLineData(self
);
2280 self
->m_lines
.Add(line
);
2282 // don't waste extra memory -- there never going to be anything
2283 // else/more in this array
2284 self
->m_lines
.Shrink();
2290 // ----------------------------------------------------------------------------
2291 // line geometry (report mode only)
2292 // ----------------------------------------------------------------------------
2294 wxCoord
wxListMainWindow::GetLineHeight() const
2296 // we cache the line height as calling GetTextExtent() is slow
2297 if ( !m_lineHeight
)
2299 wxListMainWindow
*self
= wxConstCast(this, wxListMainWindow
);
2301 wxClientDC
dc( self
);
2302 dc
.SetFont( GetFont() );
2305 dc
.GetTextExtent(_T("H"), NULL
, &y
);
2307 if ( m_small_image_list
&& m_small_image_list
->GetImageCount() )
2310 m_small_image_list
->GetSize(0, iw
, ih
);
2315 self
->m_lineHeight
= y
+ LINE_SPACING
;
2318 return m_lineHeight
;
2321 wxCoord
wxListMainWindow::GetLineY(size_t line
) const
2323 wxASSERT_MSG( InReportView(), _T("only works in report mode") );
2325 return LINE_SPACING
+ line
* GetLineHeight();
2328 wxRect
wxListMainWindow::GetLineRect(size_t line
) const
2330 if ( !InReportView() )
2331 return GetLine(line
)->m_gi
->m_rectAll
;
2334 rect
.x
= HEADER_OFFSET_X
;
2335 rect
.y
= GetLineY(line
);
2336 rect
.width
= GetHeaderWidth();
2337 rect
.height
= GetLineHeight();
2342 wxRect
wxListMainWindow::GetLineLabelRect(size_t line
) const
2344 if ( !InReportView() )
2345 return GetLine(line
)->m_gi
->m_rectLabel
;
2348 rect
.x
= HEADER_OFFSET_X
;
2349 rect
.y
= GetLineY(line
);
2350 rect
.width
= GetColumnWidth(0);
2351 rect
.height
= GetLineHeight();
2356 wxRect
wxListMainWindow::GetLineIconRect(size_t line
) const
2358 if ( !InReportView() )
2359 return GetLine(line
)->m_gi
->m_rectIcon
;
2361 wxListLineData
*ld
= GetLine(line
);
2362 wxASSERT_MSG( ld
->HasImage(), _T("should have an image") );
2365 rect
.x
= HEADER_OFFSET_X
;
2366 rect
.y
= GetLineY(line
);
2367 GetImageSize(ld
->GetImage(), rect
.width
, rect
.height
);
2372 wxRect
wxListMainWindow::GetLineHighlightRect(size_t line
) const
2374 return InReportView() ? GetLineRect(line
)
2375 : GetLine(line
)->m_gi
->m_rectHighlight
;
2378 long wxListMainWindow::HitTestLine(size_t line
, int x
, int y
) const
2380 wxASSERT_MSG( line
< GetItemCount(), _T("invalid line in HitTestLine") );
2382 wxListLineData
*ld
= GetLine(line
);
2384 if ( ld
->HasImage() && GetLineIconRect(line
).Contains(x
, y
) )
2385 return wxLIST_HITTEST_ONITEMICON
;
2387 // VS: Testing for "ld->HasText() || InReportView()" instead of
2388 // "ld->HasText()" is needed to make empty lines in report view
2390 if ( ld
->HasText() || InReportView() )
2392 wxRect rect
= InReportView() ? GetLineRect(line
)
2393 : GetLineLabelRect(line
);
2395 if ( rect
.Contains(x
, y
) )
2396 return wxLIST_HITTEST_ONITEMLABEL
;
2402 // ----------------------------------------------------------------------------
2403 // highlight (selection) handling
2404 // ----------------------------------------------------------------------------
2406 bool wxListMainWindow::IsHighlighted(size_t line
) const
2410 return m_selStore
.IsSelected(line
);
2414 wxListLineData
*ld
= GetLine(line
);
2415 wxCHECK_MSG( ld
, false, _T("invalid index in IsHighlighted") );
2417 return ld
->IsHighlighted();
2421 void wxListMainWindow::HighlightLines( size_t lineFrom
,
2427 wxArrayInt linesChanged
;
2428 if ( !m_selStore
.SelectRange(lineFrom
, lineTo
, highlight
,
2431 // meny items changed state, refresh everything
2432 RefreshLines(lineFrom
, lineTo
);
2434 else // only a few items changed state, refresh only them
2436 size_t count
= linesChanged
.GetCount();
2437 for ( size_t n
= 0; n
< count
; n
++ )
2439 RefreshLine(linesChanged
[n
]);
2443 else // iterate over all items in non report view
2445 for ( size_t line
= lineFrom
; line
<= lineTo
; line
++ )
2447 if ( HighlightLine(line
, highlight
) )
2453 bool wxListMainWindow::HighlightLine( size_t line
, bool highlight
)
2459 changed
= m_selStore
.SelectItem(line
, highlight
);
2463 wxListLineData
*ld
= GetLine(line
);
2464 wxCHECK_MSG( ld
, false, _T("invalid index in HighlightLine") );
2466 changed
= ld
->Highlight(highlight
);
2471 SendNotify( line
, highlight
? wxEVT_COMMAND_LIST_ITEM_SELECTED
2472 : wxEVT_COMMAND_LIST_ITEM_DESELECTED
);
2478 void wxListMainWindow::RefreshLine( size_t line
)
2480 if ( InReportView() )
2482 size_t visibleFrom
, visibleTo
;
2483 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2485 if ( line
< visibleFrom
|| line
> visibleTo
)
2489 wxRect rect
= GetLineRect(line
);
2491 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2492 RefreshRect( rect
);
2495 void wxListMainWindow::RefreshLines( size_t lineFrom
, size_t lineTo
)
2497 // we suppose that they are ordered by caller
2498 wxASSERT_MSG( lineFrom
<= lineTo
, _T("indices in disorder") );
2500 wxASSERT_MSG( lineTo
< GetItemCount(), _T("invalid line range") );
2502 if ( InReportView() )
2504 size_t visibleFrom
, visibleTo
;
2505 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2507 if ( lineFrom
< visibleFrom
)
2508 lineFrom
= visibleFrom
;
2509 if ( lineTo
> visibleTo
)
2514 rect
.y
= GetLineY(lineFrom
);
2515 rect
.width
= GetClientSize().x
;
2516 rect
.height
= GetLineY(lineTo
) - rect
.y
+ GetLineHeight();
2518 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2519 RefreshRect( rect
);
2523 // TODO: this should be optimized...
2524 for ( size_t line
= lineFrom
; line
<= lineTo
; line
++ )
2531 void wxListMainWindow::RefreshAfter( size_t lineFrom
)
2533 if ( InReportView() )
2535 size_t visibleFrom
, visibleTo
;
2536 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2538 if ( lineFrom
< visibleFrom
)
2539 lineFrom
= visibleFrom
;
2540 else if ( lineFrom
> visibleTo
)
2545 rect
.y
= GetLineY(lineFrom
);
2546 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2548 wxSize size
= GetClientSize();
2549 rect
.width
= size
.x
;
2551 // refresh till the bottom of the window
2552 rect
.height
= size
.y
- rect
.y
;
2554 RefreshRect( rect
);
2558 // TODO: how to do it more efficiently?
2563 void wxListMainWindow::RefreshSelected()
2569 if ( InReportView() )
2571 GetVisibleLinesRange(&from
, &to
);
2576 to
= GetItemCount() - 1;
2579 if ( HasCurrent() && m_current
>= from
&& m_current
<= to
)
2580 RefreshLine(m_current
);
2582 for ( size_t line
= from
; line
<= to
; line
++ )
2584 // NB: the test works as expected even if m_current == -1
2585 if ( line
!= m_current
&& IsHighlighted(line
) )
2590 void wxListMainWindow::Freeze()
2595 void wxListMainWindow::Thaw()
2597 wxCHECK_RET( m_freezeCount
> 0, _T("thawing unfrozen list control?") );
2599 if ( --m_freezeCount
== 0 )
2603 void wxListMainWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
2605 // Note: a wxPaintDC must be constructed even if no drawing is
2606 // done (a Windows requirement).
2607 wxPaintDC
dc( this );
2609 if ( IsEmpty() || m_freezeCount
)
2610 // nothing to draw or not the moment to draw it
2614 // delay the repainting until we calculate all the items positions
2620 CalcScrolledPosition( 0, 0, &dev_x
, &dev_y
);
2622 dc
.SetFont( GetFont() );
2624 if ( InReportView() )
2626 int lineHeight
= GetLineHeight();
2628 size_t visibleFrom
, visibleTo
;
2629 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2632 wxCoord xOrig
, yOrig
;
2633 CalcUnscrolledPosition(0, 0, &xOrig
, &yOrig
);
2635 // tell the caller cache to cache the data
2638 wxListEvent
evCache(wxEVT_COMMAND_LIST_CACHE_HINT
,
2639 GetParent()->GetId());
2640 evCache
.SetEventObject( GetParent() );
2641 evCache
.m_oldItemIndex
= visibleFrom
;
2642 evCache
.m_itemIndex
= visibleTo
;
2643 GetParent()->GetEventHandler()->ProcessEvent( evCache
);
2646 for ( size_t line
= visibleFrom
; line
<= visibleTo
; line
++ )
2648 rectLine
= GetLineRect(line
);
2650 if ( !IsExposed(rectLine
.x
- xOrig
, rectLine
.y
- yOrig
,
2651 rectLine
.width
, rectLine
.height
) )
2653 // don't redraw unaffected lines to avoid flicker
2657 GetLine(line
)->DrawInReportMode( &dc
,
2659 GetLineHighlightRect(line
),
2660 IsHighlighted(line
) );
2663 if ( HasFlag(wxLC_HRULES
) )
2665 wxPen
pen(GetRuleColour(), 1, wxSOLID
);
2666 wxSize clientSize
= GetClientSize();
2668 // Don't draw the first one
2669 for ( size_t i
= visibleFrom
+ 1; i
<= visibleTo
; i
++ )
2672 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
2673 dc
.DrawLine(0 - dev_x
, i
* lineHeight
,
2674 clientSize
.x
- dev_x
, i
* lineHeight
);
2677 // Draw last horizontal rule
2678 if ( visibleTo
== GetItemCount() - 1 )
2681 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
2682 dc
.DrawLine(0 - dev_x
, (m_lineTo
+ 1) * lineHeight
,
2683 clientSize
.x
- dev_x
, (m_lineTo
+ 1) * lineHeight
);
2687 // Draw vertical rules if required
2688 if ( HasFlag(wxLC_VRULES
) && !IsEmpty() )
2690 wxPen
pen(GetRuleColour(), 1, wxSOLID
);
2691 wxRect firstItemRect
, lastItemRect
;
2693 GetItemRect(visibleFrom
, firstItemRect
);
2694 GetItemRect(visibleTo
, lastItemRect
);
2695 int x
= firstItemRect
.GetX();
2697 dc
.SetBrush(* wxTRANSPARENT_BRUSH
);
2699 for (int col
= 0; col
< GetColumnCount(); col
++)
2701 int colWidth
= GetColumnWidth(col
);
2703 dc
.DrawLine(x
- dev_x
- 2, firstItemRect
.GetY() - 1 - dev_y
,
2704 x
- dev_x
- 2, lastItemRect
.GetBottom() + 1 - dev_y
);
2710 size_t count
= GetItemCount();
2711 for ( size_t i
= 0; i
< count
; i
++ )
2713 GetLine(i
)->Draw( &dc
);
2718 // Don't draw rect outline under Mac at all.
2723 dc
.SetPen( *wxBLACK_PEN
);
2724 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
2725 dc
.DrawRectangle( GetLineHighlightRect( m_current
) );
2731 void wxListMainWindow::HighlightAll( bool on
)
2733 if ( IsSingleSel() )
2735 wxASSERT_MSG( !on
, _T("can't do this in a single selection control") );
2737 // we just have one item to turn off
2738 if ( HasCurrent() && IsHighlighted(m_current
) )
2740 HighlightLine(m_current
, false);
2741 RefreshLine(m_current
);
2746 HighlightLines(0, GetItemCount() - 1, on
);
2750 void wxListMainWindow::SendNotify( size_t line
,
2751 wxEventType command
,
2752 const wxPoint
& point
)
2754 wxListEvent
le( command
, GetParent()->GetId() );
2755 le
.SetEventObject( GetParent() );
2756 le
.m_itemIndex
= line
;
2758 // set only for events which have position
2759 if ( point
!= wxDefaultPosition
)
2760 le
.m_pointDrag
= point
;
2762 // don't try to get the line info for virtual list controls: the main
2763 // program has it anyhow and if we did it would result in accessing all
2764 // the lines, even those which are not visible now and this is precisely
2765 // what we're trying to avoid
2766 if ( !IsVirtual() && (command
!= wxEVT_COMMAND_LIST_DELETE_ITEM
) )
2768 if ( line
!= (size_t)-1 )
2770 GetLine(line
)->GetItem( 0, le
.m_item
);
2772 //else: this happens for wxEVT_COMMAND_LIST_ITEM_FOCUSED event
2774 //else: there may be no more such item
2776 GetParent()->GetEventHandler()->ProcessEvent( le
);
2779 void wxListMainWindow::ChangeCurrent(size_t current
)
2781 m_current
= current
;
2783 SendNotify(current
, wxEVT_COMMAND_LIST_ITEM_FOCUSED
);
2786 wxTextCtrl
*wxListMainWindow::EditLabel(long item
, wxClassInfo
* textControlClass
)
2788 wxCHECK_MSG( (item
>= 0) && ((size_t)item
< GetItemCount()), NULL
,
2789 wxT("wrong index in wxGenericListCtrl::EditLabel()") );
2791 wxASSERT_MSG( textControlClass
->IsKindOf(CLASSINFO(wxTextCtrl
)),
2792 wxT("EditLabel() needs a text control") );
2794 size_t itemEdit
= (size_t)item
;
2796 wxListEvent
le( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT
, GetParent()->GetId() );
2797 le
.SetEventObject( GetParent() );
2798 le
.m_itemIndex
= item
;
2799 wxListLineData
*data
= GetLine(itemEdit
);
2800 wxCHECK_MSG( data
, NULL
, _T("invalid index in EditLabel()") );
2801 data
->GetItem( 0, le
.m_item
);
2803 if ( GetParent()->GetEventHandler()->ProcessEvent( le
) && !le
.IsAllowed() )
2805 // vetoed by user code
2809 // We have to call this here because the label in question might just have
2810 // been added and no screen update taken place.
2814 wxTextCtrl
* const text
= (wxTextCtrl
*)textControlClass
->CreateObject();
2815 m_textctrlWrapper
= new wxListTextCtrlWrapper(this, text
, item
);
2816 return m_textctrlWrapper
->GetText();
2819 void wxListMainWindow::OnRenameTimer()
2821 wxCHECK_RET( HasCurrent(), wxT("unexpected rename timer") );
2823 EditLabel( m_current
);
2826 bool wxListMainWindow::OnRenameAccept(size_t itemEdit
, const wxString
& value
)
2828 wxListEvent
le( wxEVT_COMMAND_LIST_END_LABEL_EDIT
, GetParent()->GetId() );
2829 le
.SetEventObject( GetParent() );
2830 le
.m_itemIndex
= itemEdit
;
2832 wxListLineData
*data
= GetLine(itemEdit
);
2834 wxCHECK_MSG( data
, false, _T("invalid index in OnRenameAccept()") );
2836 data
->GetItem( 0, le
.m_item
);
2837 le
.m_item
.m_text
= value
;
2838 return !GetParent()->GetEventHandler()->ProcessEvent( le
) ||
2842 void wxListMainWindow::OnRenameCancelled(size_t itemEdit
)
2844 // let owner know that the edit was cancelled
2845 wxListEvent
le( wxEVT_COMMAND_LIST_END_LABEL_EDIT
, GetParent()->GetId() );
2847 le
.SetEditCanceled(true);
2849 le
.SetEventObject( GetParent() );
2850 le
.m_itemIndex
= itemEdit
;
2852 wxListLineData
*data
= GetLine(itemEdit
);
2853 wxCHECK_RET( data
, _T("invalid index in OnRenameCancelled()") );
2855 data
->GetItem( 0, le
.m_item
);
2856 GetEventHandler()->ProcessEvent( le
);
2859 void wxListMainWindow::OnMouse( wxMouseEvent
&event
)
2863 // On wxMac we can't depend on the EVT_KILL_FOCUS event to properly
2864 // shutdown the edit control when the mouse is clicked elsewhere on the
2865 // listctrl because the order of events is different (or something like
2866 // that), so explicitly end the edit if it is active.
2867 if ( event
.LeftDown() && m_textctrlWrapper
)
2868 m_textctrlWrapper
->AcceptChangesAndFinish();
2871 event
.SetEventObject( GetParent() );
2872 if ( GetParent()->GetEventHandler()->ProcessEvent( event
) )
2875 if (event
.GetEventType() == wxEVT_MOUSEWHEEL
)
2877 // let the base handle mouse wheel events.
2882 if ( !HasCurrent() || IsEmpty() )
2884 if (event
.RightDown())
2886 SendNotify( (size_t)-1, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
, event
.GetPosition() );
2887 // Allow generation of context menu event
2896 if ( !(event
.Dragging() || event
.ButtonDown() || event
.LeftUp() ||
2897 event
.ButtonDClick()) )
2900 int x
= event
.GetX();
2901 int y
= event
.GetY();
2902 CalcUnscrolledPosition( x
, y
, &x
, &y
);
2904 // where did we hit it (if we did)?
2907 size_t count
= GetItemCount(),
2910 if ( InReportView() )
2912 current
= y
/ GetLineHeight();
2913 if ( current
< count
)
2914 hitResult
= HitTestLine(current
, x
, y
);
2918 // TODO: optimize it too! this is less simple than for report view but
2919 // enumerating all items is still not a way to do it!!
2920 for ( current
= 0; current
< count
; current
++ )
2922 hitResult
= HitTestLine(current
, x
, y
);
2928 if (event
.Dragging())
2930 if (m_dragCount
== 0)
2932 // we have to report the raw, physical coords as we want to be
2933 // able to call HitTest(event.m_pointDrag) from the user code to
2934 // get the item being dragged
2935 m_dragStart
= event
.GetPosition();
2940 if (m_dragCount
!= 3)
2943 int command
= event
.RightIsDown() ? wxEVT_COMMAND_LIST_BEGIN_RDRAG
2944 : wxEVT_COMMAND_LIST_BEGIN_DRAG
;
2946 wxListEvent
le( command
, GetParent()->GetId() );
2947 le
.SetEventObject( GetParent() );
2948 le
.m_itemIndex
= m_lineLastClicked
;
2949 le
.m_pointDrag
= m_dragStart
;
2950 GetParent()->GetEventHandler()->ProcessEvent( le
);
2961 // outside of any item
2962 if (event
.RightDown())
2964 SendNotify( (size_t) -1, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
, event
.GetPosition() );
2965 // Allow generation of context menu event
2970 // reset the selection and bail out
2971 HighlightAll(false);
2977 bool forceClick
= false;
2978 if (event
.ButtonDClick())
2980 m_renameTimer
->Stop();
2981 m_lastOnSame
= false;
2983 if ( current
== m_lineLastClicked
)
2985 SendNotify( current
, wxEVT_COMMAND_LIST_ITEM_ACTIVATED
);
2991 // The first click was on another item, so don't interpret this as
2992 // a double click, but as a simple click instead
2999 if (m_lineSelectSingleOnUp
!= (size_t)-1)
3001 // select single line
3002 HighlightAll( false );
3003 ReverseHighlight(m_lineSelectSingleOnUp
);
3008 if ((current
== m_current
) &&
3009 (hitResult
== wxLIST_HITTEST_ONITEMLABEL
) &&
3010 HasFlag(wxLC_EDIT_LABELS
) )
3012 m_renameTimer
->Start( 100, true );
3016 m_lastOnSame
= false;
3017 m_lineSelectSingleOnUp
= (size_t)-1;
3021 // This is necessary, because after a DnD operation in
3022 // from and to ourself, the up event is swallowed by the
3023 // DnD code. So on next non-up event (which means here and
3024 // now) m_lineSelectSingleOnUp should be reset.
3025 m_lineSelectSingleOnUp
= (size_t)-1;
3027 if (event
.RightDown())
3029 m_lineBeforeLastClicked
= m_lineLastClicked
;
3030 m_lineLastClicked
= current
;
3032 // If the item is already selected, do not update the selection.
3033 // Multi-selections should not be cleared if a selected item is clicked.
3034 if (!IsHighlighted(current
))
3036 HighlightAll(false);
3037 ChangeCurrent(current
);
3038 ReverseHighlight(m_current
);
3041 SendNotify( current
, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
, event
.GetPosition() );
3043 // Allow generation of context menu event
3046 else if (event
.MiddleDown())
3048 SendNotify( current
, wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK
);
3050 else if ( event
.LeftDown() || forceClick
)
3052 m_lineBeforeLastClicked
= m_lineLastClicked
;
3053 m_lineLastClicked
= current
;
3055 size_t oldCurrent
= m_current
;
3056 bool oldWasSelected
= IsHighlighted(m_current
);
3058 bool cmdModifierDown
= event
.CmdDown();
3059 if ( IsSingleSel() || !(cmdModifierDown
|| event
.ShiftDown()) )
3061 if ( IsSingleSel() || !IsHighlighted(current
) )
3063 HighlightAll( false );
3065 ChangeCurrent(current
);
3067 ReverseHighlight(m_current
);
3069 else // multi sel & current is highlighted & no mod keys
3071 m_lineSelectSingleOnUp
= current
;
3072 ChangeCurrent(current
); // change focus
3075 else // multi sel & either ctrl or shift is down
3077 if (cmdModifierDown
)
3079 ChangeCurrent(current
);
3081 ReverseHighlight(m_current
);
3083 else if (event
.ShiftDown())
3085 ChangeCurrent(current
);
3087 size_t lineFrom
= oldCurrent
,
3090 if ( lineTo
< lineFrom
)
3093 lineFrom
= m_current
;
3096 HighlightLines(lineFrom
, lineTo
);
3098 else // !ctrl, !shift
3100 // test in the enclosing if should make it impossible
3101 wxFAIL_MSG( _T("how did we get here?") );
3105 if (m_current
!= oldCurrent
)
3106 RefreshLine( oldCurrent
);
3108 // forceClick is only set if the previous click was on another item
3109 m_lastOnSame
= !forceClick
&& (m_current
== oldCurrent
) && oldWasSelected
;
3113 void wxListMainWindow::MoveToItem(size_t item
)
3115 if ( item
== (size_t)-1 )
3118 wxRect rect
= GetLineRect(item
);
3120 int client_w
, client_h
;
3121 GetClientSize( &client_w
, &client_h
);
3123 const int hLine
= GetLineHeight();
3125 int view_x
= SCROLL_UNIT_X
* GetScrollPos( wxHORIZONTAL
);
3126 int view_y
= hLine
* GetScrollPos( wxVERTICAL
);
3128 if ( InReportView() )
3130 // the next we need the range of lines shown it might be different,
3131 // so recalculate it
3132 ResetVisibleLinesRange();
3134 if (rect
.y
< view_y
)
3135 Scroll( -1, rect
.y
/ hLine
);
3136 if (rect
.y
+ rect
.height
+ 5 > view_y
+ client_h
)
3137 Scroll( -1, (rect
.y
+ rect
.height
- client_h
+ hLine
) / hLine
);
3141 if (rect
.x
-view_x
< 5)
3142 Scroll( (rect
.x
- 5) / SCROLL_UNIT_X
, -1 );
3143 if (rect
.x
+ rect
.width
- 5 > view_x
+ client_w
)
3144 Scroll( (rect
.x
+ rect
.width
- client_w
+ SCROLL_UNIT_X
) / SCROLL_UNIT_X
, -1 );
3148 // ----------------------------------------------------------------------------
3149 // keyboard handling
3150 // ----------------------------------------------------------------------------
3152 void wxListMainWindow::OnArrowChar(size_t newCurrent
, const wxKeyEvent
& event
)
3154 wxCHECK_RET( newCurrent
< (size_t)GetItemCount(),
3155 _T("invalid item index in OnArrowChar()") );
3157 size_t oldCurrent
= m_current
;
3159 // in single selection we just ignore Shift as we can't select several
3161 if ( event
.ShiftDown() && !IsSingleSel() )
3163 ChangeCurrent(newCurrent
);
3165 // refresh the old focus to remove it
3166 RefreshLine( oldCurrent
);
3168 // select all the items between the old and the new one
3169 if ( oldCurrent
> newCurrent
)
3171 newCurrent
= oldCurrent
;
3172 oldCurrent
= m_current
;
3175 HighlightLines(oldCurrent
, newCurrent
);
3179 // all previously selected items are unselected unless ctrl is held
3180 if ( !event
.ControlDown() )
3181 HighlightAll(false);
3183 ChangeCurrent(newCurrent
);
3185 // refresh the old focus to remove it
3186 RefreshLine( oldCurrent
);
3188 if ( !event
.ControlDown() )
3190 HighlightLine( m_current
, true );
3194 RefreshLine( m_current
);
3199 void wxListMainWindow::OnKeyDown( wxKeyEvent
&event
)
3201 wxWindow
*parent
= GetParent();
3203 // propagate the key event upwards
3204 wxKeyEvent
ke( wxEVT_KEY_DOWN
);
3205 ke
.m_shiftDown
= event
.m_shiftDown
;
3206 ke
.m_controlDown
= event
.m_controlDown
;
3207 ke
.m_altDown
= event
.m_altDown
;
3208 ke
.m_metaDown
= event
.m_metaDown
;
3209 ke
.m_keyCode
= event
.m_keyCode
;
3212 ke
.SetEventObject( parent
);
3213 if (parent
->GetEventHandler()->ProcessEvent( ke
)) return;
3218 void wxListMainWindow::OnChar( wxKeyEvent
&event
)
3220 wxWindow
*parent
= GetParent();
3222 // send a list_key event up
3225 wxListEvent
le( wxEVT_COMMAND_LIST_KEY_DOWN
, GetParent()->GetId() );
3226 le
.m_itemIndex
= m_current
;
3227 GetLine(m_current
)->GetItem( 0, le
.m_item
);
3228 le
.m_code
= event
.GetKeyCode();
3229 le
.SetEventObject( parent
);
3230 parent
->GetEventHandler()->ProcessEvent( le
);
3233 // propagate the char event upwards
3234 wxKeyEvent
ke( wxEVT_CHAR
);
3235 ke
.m_shiftDown
= event
.m_shiftDown
;
3236 ke
.m_controlDown
= event
.m_controlDown
;
3237 ke
.m_altDown
= event
.m_altDown
;
3238 ke
.m_metaDown
= event
.m_metaDown
;
3239 ke
.m_keyCode
= event
.m_keyCode
;
3242 ke
.SetEventObject( parent
);
3243 if (parent
->GetEventHandler()->ProcessEvent( ke
)) return;
3245 if (event
.GetKeyCode() == WXK_TAB
)
3247 wxNavigationKeyEvent nevent
;
3248 nevent
.SetWindowChange( event
.ControlDown() );
3249 nevent
.SetDirection( !event
.ShiftDown() );
3250 nevent
.SetEventObject( GetParent()->GetParent() );
3251 nevent
.SetCurrentFocus( m_parent
);
3252 if (GetParent()->GetParent()->GetEventHandler()->ProcessEvent( nevent
))
3256 // no item -> nothing to do
3263 // don't use m_linesPerPage directly as it might not be computed yet
3264 const int pageSize
= GetCountPerPage();
3265 wxCHECK_RET( pageSize
, _T("should have non zero page size") );
3267 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3269 if (event
.GetKeyCode() == WXK_RIGHT
)
3270 event
.m_keyCode
= WXK_LEFT
;
3271 else if (event
.GetKeyCode() == WXK_LEFT
)
3272 event
.m_keyCode
= WXK_RIGHT
;
3275 switch ( event
.GetKeyCode() )
3278 if ( m_current
> 0 )
3279 OnArrowChar( m_current
- 1, event
);
3283 if ( m_current
< (size_t)GetItemCount() - 1 )
3284 OnArrowChar( m_current
+ 1, event
);
3289 OnArrowChar( GetItemCount() - 1, event
);
3294 OnArrowChar( 0, event
);
3299 int steps
= InReportView() ? pageSize
- 1
3300 : m_current
% pageSize
;
3302 int index
= m_current
- steps
;
3306 OnArrowChar( index
, event
);
3312 int steps
= InReportView()
3314 : pageSize
- (m_current
% pageSize
) - 1;
3316 size_t index
= m_current
+ steps
;
3317 size_t count
= GetItemCount();
3318 if ( index
>= count
)
3321 OnArrowChar( index
, event
);
3326 if ( !InReportView() )
3328 int index
= m_current
- pageSize
;
3332 OnArrowChar( index
, event
);
3337 if ( !InReportView() )
3339 size_t index
= m_current
+ pageSize
;
3341 size_t count
= GetItemCount();
3342 if ( index
>= count
)
3345 OnArrowChar( index
, event
);
3350 if ( IsSingleSel() )
3352 SendNotify( m_current
, wxEVT_COMMAND_LIST_ITEM_ACTIVATED
);
3354 if ( IsHighlighted(m_current
) )
3356 // don't unselect the item in single selection mode
3359 //else: select it in ReverseHighlight() below if unselected
3362 ReverseHighlight(m_current
);
3367 SendNotify( m_current
, wxEVT_COMMAND_LIST_ITEM_ACTIVATED
);
3375 // ----------------------------------------------------------------------------
3377 // ----------------------------------------------------------------------------
3379 void wxListMainWindow::OnSetFocus( wxFocusEvent
&WXUNUSED(event
) )
3383 wxFocusEvent
event( wxEVT_SET_FOCUS
, GetParent()->GetId() );
3384 event
.SetEventObject( GetParent() );
3385 if ( GetParent()->GetEventHandler()->ProcessEvent( event
) )
3389 // wxGTK sends us EVT_SET_FOCUS events even if we had never got
3390 // EVT_KILL_FOCUS before which means that we finish by redrawing the items
3391 // which are already drawn correctly resulting in horrible flicker - avoid
3401 void wxListMainWindow::OnKillFocus( wxFocusEvent
&WXUNUSED(event
) )
3405 wxFocusEvent
event( wxEVT_KILL_FOCUS
, GetParent()->GetId() );
3406 event
.SetEventObject( GetParent() );
3407 if ( GetParent()->GetEventHandler()->ProcessEvent( event
) )
3415 void wxListMainWindow::DrawImage( int index
, wxDC
*dc
, int x
, int y
)
3417 if ( HasFlag(wxLC_ICON
) && (m_normal_image_list
))
3419 m_normal_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3421 else if ( HasFlag(wxLC_SMALL_ICON
) && (m_small_image_list
))
3423 m_small_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3425 else if ( HasFlag(wxLC_LIST
) && (m_small_image_list
))
3427 m_small_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3429 else if ( InReportView() && (m_small_image_list
))
3431 m_small_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3435 void wxListMainWindow::GetImageSize( int index
, int &width
, int &height
) const
3437 if ( HasFlag(wxLC_ICON
) && m_normal_image_list
)
3439 m_normal_image_list
->GetSize( index
, width
, height
);
3441 else if ( HasFlag(wxLC_SMALL_ICON
) && m_small_image_list
)
3443 m_small_image_list
->GetSize( index
, width
, height
);
3445 else if ( HasFlag(wxLC_LIST
) && m_small_image_list
)
3447 m_small_image_list
->GetSize( index
, width
, height
);
3449 else if ( InReportView() && m_small_image_list
)
3451 m_small_image_list
->GetSize( index
, width
, height
);
3460 int wxListMainWindow::GetTextLength( const wxString
&s
) const
3462 wxClientDC
dc( wxConstCast(this, wxListMainWindow
) );
3463 dc
.SetFont( GetFont() );
3466 dc
.GetTextExtent( s
, &lw
, NULL
);
3468 return lw
+ AUTOSIZE_COL_MARGIN
;
3471 void wxListMainWindow::SetImageList( wxImageListType
*imageList
, int which
)
3475 // calc the spacing from the icon size
3476 int width
= 0, height
= 0;
3478 if ((imageList
) && (imageList
->GetImageCount()) )
3479 imageList
->GetSize(0, width
, height
);
3481 if (which
== wxIMAGE_LIST_NORMAL
)
3483 m_normal_image_list
= imageList
;
3484 m_normal_spacing
= width
+ 8;
3487 if (which
== wxIMAGE_LIST_SMALL
)
3489 m_small_image_list
= imageList
;
3490 m_small_spacing
= width
+ 14;
3491 m_lineHeight
= 0; // ensure that the line height will be recalc'd
3495 void wxListMainWindow::SetItemSpacing( int spacing
, bool isSmall
)
3499 m_small_spacing
= spacing
;
3501 m_normal_spacing
= spacing
;
3504 int wxListMainWindow::GetItemSpacing( bool isSmall
)
3506 return isSmall
? m_small_spacing
: m_normal_spacing
;
3509 // ----------------------------------------------------------------------------
3511 // ----------------------------------------------------------------------------
3513 void wxListMainWindow::SetColumn( int col
, wxListItem
&item
)
3515 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
3517 wxCHECK_RET( node
, _T("invalid column index in SetColumn") );
3519 if ( item
.m_width
== wxLIST_AUTOSIZE_USEHEADER
)
3520 item
.m_width
= GetTextLength( item
.m_text
);
3522 wxListHeaderData
*column
= node
->GetData();
3523 column
->SetItem( item
);
3525 wxListHeaderWindow
*headerWin
= GetListCtrl()->m_headerWin
;
3527 headerWin
->m_dirty
= true;
3531 // invalidate it as it has to be recalculated
3535 void wxListMainWindow::SetColumnWidth( int col
, int width
)
3537 wxCHECK_RET( col
>= 0 && col
< GetColumnCount(),
3538 _T("invalid column index") );
3540 wxCHECK_RET( InReportView(),
3541 _T("SetColumnWidth() can only be called in report mode.") );
3544 wxListHeaderWindow
*headerWin
= GetListCtrl()->m_headerWin
;
3546 headerWin
->m_dirty
= true;
3548 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
3549 wxCHECK_RET( node
, _T("no column?") );
3551 wxListHeaderData
*column
= node
->GetData();
3553 size_t count
= GetItemCount();
3555 if (width
== wxLIST_AUTOSIZE_USEHEADER
)
3557 width
= GetTextLength(column
->GetText());
3559 else if ( width
== wxLIST_AUTOSIZE
)
3563 // TODO: determine the max width somehow...
3564 width
= WIDTH_COL_DEFAULT
;
3568 wxClientDC
dc(this);
3569 dc
.SetFont( GetFont() );
3571 int max
= AUTOSIZE_COL_MARGIN
;
3573 // if the cached column width isn't valid then recalculate it
3574 if (m_aColWidths
.Item(col
)->bNeedsUpdate
)
3576 for (size_t i
= 0; i
< count
; i
++)
3578 wxListLineData
*line
= GetLine( i
);
3579 wxListItemDataList::compatibility_iterator n
= line
->m_items
.Item( col
);
3581 wxCHECK_RET( n
, _T("no subitem?") );
3583 wxListItemData
*itemData
= n
->GetData();
3586 itemData
->GetItem(item
);
3587 int itemWidth
= GetItemWidthWithImage(&item
);
3588 if (itemWidth
> max
)
3592 m_aColWidths
.Item(col
)->bNeedsUpdate
= false;
3593 m_aColWidths
.Item(col
)->nMaxWidth
= max
;
3596 max
= m_aColWidths
.Item(col
)->nMaxWidth
;
3597 width
= max
+ AUTOSIZE_COL_MARGIN
;
3601 column
->SetWidth( width
);
3603 // invalidate it as it has to be recalculated
3607 int wxListMainWindow::GetHeaderWidth() const
3609 if ( !m_headerWidth
)
3611 wxListMainWindow
*self
= wxConstCast(this, wxListMainWindow
);
3613 size_t count
= GetColumnCount();
3614 for ( size_t col
= 0; col
< count
; col
++ )
3616 self
->m_headerWidth
+= GetColumnWidth(col
);
3620 return m_headerWidth
;
3623 void wxListMainWindow::GetColumn( int col
, wxListItem
&item
) const
3625 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
3626 wxCHECK_RET( node
, _T("invalid column index in GetColumn") );
3628 wxListHeaderData
*column
= node
->GetData();
3629 column
->GetItem( item
);
3632 int wxListMainWindow::GetColumnWidth( int col
) const
3634 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
3635 wxCHECK_MSG( node
, 0, _T("invalid column index") );
3637 wxListHeaderData
*column
= node
->GetData();
3638 return column
->GetWidth();
3641 // ----------------------------------------------------------------------------
3643 // ----------------------------------------------------------------------------
3645 void wxListMainWindow::SetItem( wxListItem
&item
)
3647 long id
= item
.m_itemId
;
3648 wxCHECK_RET( id
>= 0 && (size_t)id
< GetItemCount(),
3649 _T("invalid item index in SetItem") );
3653 wxListLineData
*line
= GetLine((size_t)id
);
3654 line
->SetItem( item
.m_col
, item
);
3656 // Set item state if user wants
3657 if ( item
.m_mask
& wxLIST_MASK_STATE
)
3658 SetItemState( item
.m_itemId
, item
.m_state
, item
.m_state
);
3662 // update the Max Width Cache if needed
3663 int width
= GetItemWidthWithImage(&item
);
3665 if (width
> m_aColWidths
.Item(item
.m_col
)->nMaxWidth
)
3666 m_aColWidths
.Item(item
.m_col
)->nMaxWidth
= width
;
3670 // update the item on screen
3672 GetItemRect(id
, rectItem
);
3673 RefreshRect(rectItem
);
3676 void wxListMainWindow::SetItemStateAll(long state
, long stateMask
)
3681 // first deal with selection
3682 if ( stateMask
& wxLIST_STATE_SELECTED
)
3684 // set/clear select state
3687 // optimized version for virtual listctrl.
3688 m_selStore
.SelectRange(0, GetItemCount() - 1, state
== wxLIST_STATE_SELECTED
);
3691 else if ( state
& wxLIST_STATE_SELECTED
)
3693 const long count
= GetItemCount();
3694 for( long i
= 0; i
< count
; i
++ )
3696 SetItemState( i
, wxLIST_STATE_SELECTED
, wxLIST_STATE_SELECTED
);
3702 // clear for non virtual (somewhat optimized by using GetNextItem())
3704 while ( (i
= GetNextItem(i
, wxLIST_NEXT_ALL
, wxLIST_STATE_SELECTED
)) != -1 )
3706 SetItemState( i
, 0, wxLIST_STATE_SELECTED
);
3711 if ( HasCurrent() && (state
== 0) && (stateMask
& wxLIST_STATE_FOCUSED
) )
3713 // unfocus all: only one item can be focussed, so clearing focus for
3714 // all items is simply clearing focus of the focussed item.
3715 SetItemState(m_current
, state
, stateMask
);
3717 //(setting focus to all items makes no sense, so it is not handled here.)
3720 void wxListMainWindow::SetItemState( long litem
, long state
, long stateMask
)
3724 SetItemStateAll(state
, stateMask
);
3728 wxCHECK_RET( litem
>= 0 && (size_t)litem
< GetItemCount(),
3729 _T("invalid list ctrl item index in SetItem") );
3731 size_t oldCurrent
= m_current
;
3732 size_t item
= (size_t)litem
; // safe because of the check above
3734 // do we need to change the focus?
3735 if ( stateMask
& wxLIST_STATE_FOCUSED
)
3737 if ( state
& wxLIST_STATE_FOCUSED
)
3739 // don't do anything if this item is already focused
3740 if ( item
!= m_current
)
3742 ChangeCurrent(item
);
3744 if ( oldCurrent
!= (size_t)-1 )
3746 if ( IsSingleSel() )
3748 HighlightLine(oldCurrent
, false);
3751 RefreshLine(oldCurrent
);
3754 RefreshLine( m_current
);
3759 // don't do anything if this item is not focused
3760 if ( item
== m_current
)
3764 if ( IsSingleSel() )
3766 // we must unselect the old current item as well or we
3767 // might end up with more than one selected item in a
3768 // single selection control
3769 HighlightLine(oldCurrent
, false);
3772 RefreshLine( oldCurrent
);
3777 // do we need to change the selection state?
3778 if ( stateMask
& wxLIST_STATE_SELECTED
)
3780 bool on
= (state
& wxLIST_STATE_SELECTED
) != 0;
3782 if ( IsSingleSel() )
3786 // selecting the item also makes it the focused one in the
3788 if ( m_current
!= item
)
3790 ChangeCurrent(item
);
3792 if ( oldCurrent
!= (size_t)-1 )
3794 HighlightLine( oldCurrent
, false );
3795 RefreshLine( oldCurrent
);
3801 // only the current item may be selected anyhow
3802 if ( item
!= m_current
)
3807 if ( HighlightLine(item
, on
) )
3814 int wxListMainWindow::GetItemState( long item
, long stateMask
) const
3816 wxCHECK_MSG( item
>= 0 && (size_t)item
< GetItemCount(), 0,
3817 _T("invalid list ctrl item index in GetItemState()") );
3819 int ret
= wxLIST_STATE_DONTCARE
;
3821 if ( stateMask
& wxLIST_STATE_FOCUSED
)
3823 if ( (size_t)item
== m_current
)
3824 ret
|= wxLIST_STATE_FOCUSED
;
3827 if ( stateMask
& wxLIST_STATE_SELECTED
)
3829 if ( IsHighlighted(item
) )
3830 ret
|= wxLIST_STATE_SELECTED
;
3836 void wxListMainWindow::GetItem( wxListItem
&item
) const
3838 wxCHECK_RET( item
.m_itemId
>= 0 && (size_t)item
.m_itemId
< GetItemCount(),
3839 _T("invalid item index in GetItem") );
3841 wxListLineData
*line
= GetLine((size_t)item
.m_itemId
);
3842 line
->GetItem( item
.m_col
, item
);
3844 // Get item state if user wants it
3845 if ( item
.m_mask
& wxLIST_MASK_STATE
)
3846 item
.m_state
= GetItemState( item
.m_itemId
, wxLIST_STATE_SELECTED
|
3847 wxLIST_STATE_FOCUSED
);
3850 // ----------------------------------------------------------------------------
3852 // ----------------------------------------------------------------------------
3854 size_t wxListMainWindow::GetItemCount() const
3856 return IsVirtual() ? m_countVirt
: m_lines
.GetCount();
3859 void wxListMainWindow::SetItemCount(long count
)
3861 m_selStore
.SetItemCount(count
);
3862 m_countVirt
= count
;
3864 ResetVisibleLinesRange();
3866 // scrollbars must be reset
3870 int wxListMainWindow::GetSelectedItemCount() const
3872 // deal with the quick case first
3873 if ( IsSingleSel() )
3874 return HasCurrent() ? IsHighlighted(m_current
) : false;
3876 // virtual controls remmebers all its selections itself
3878 return m_selStore
.GetSelectedCount();
3880 // TODO: we probably should maintain the number of items selected even for
3881 // non virtual controls as enumerating all lines is really slow...
3882 size_t countSel
= 0;
3883 size_t count
= GetItemCount();
3884 for ( size_t line
= 0; line
< count
; line
++ )
3886 if ( GetLine(line
)->IsHighlighted() )
3893 // ----------------------------------------------------------------------------
3894 // item position/size
3895 // ----------------------------------------------------------------------------
3897 wxRect
wxListMainWindow::GetViewRect() const
3899 wxASSERT_MSG( !HasFlag(wxLC_REPORT
| wxLC_LIST
),
3900 _T("wxListCtrl::GetViewRect() only works in icon mode") );
3902 // we need to find the longest/tallest label
3903 wxCoord xMax
= 0, yMax
= 0;
3904 const int count
= GetItemCount();
3907 for ( int i
= 0; i
< count
; i
++ )
3912 wxCoord x
= r
.GetRight(),
3922 // some fudge needed to make it look prettier
3923 xMax
+= 2 * EXTRA_BORDER_X
;
3924 yMax
+= 2 * EXTRA_BORDER_Y
;
3926 // account for the scrollbars if necessary
3927 const wxSize sizeAll
= GetClientSize();
3928 if ( xMax
> sizeAll
.x
)
3929 yMax
+= wxSystemSettings::GetMetric(wxSYS_HSCROLL_Y
);
3930 if ( yMax
> sizeAll
.y
)
3931 xMax
+= wxSystemSettings::GetMetric(wxSYS_VSCROLL_X
);
3933 return wxRect(0, 0, xMax
, yMax
);
3936 void wxListMainWindow::GetItemRect( long index
, wxRect
&rect
) const
3938 wxCHECK_RET( index
>= 0 && (size_t)index
< GetItemCount(),
3939 _T("invalid index in GetItemRect") );
3941 // ensure that we're laid out, otherwise we could return nonsense
3944 wxConstCast(this, wxListMainWindow
)->
3945 RecalculatePositions(true /* no refresh */);
3948 rect
= GetLineRect((size_t)index
);
3950 CalcScrolledPosition(rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
3953 bool wxListMainWindow::GetItemPosition(long item
, wxPoint
& pos
) const
3956 GetItemRect(item
, rect
);
3964 // ----------------------------------------------------------------------------
3965 // geometry calculation
3966 // ----------------------------------------------------------------------------
3968 void wxListMainWindow::RecalculatePositions(bool noRefresh
)
3970 wxClientDC
dc( this );
3971 dc
.SetFont( GetFont() );
3973 const size_t count
= GetItemCount();
3976 if ( HasFlag(wxLC_ICON
) )
3977 iconSpacing
= m_normal_spacing
;
3978 else if ( HasFlag(wxLC_SMALL_ICON
) )
3979 iconSpacing
= m_small_spacing
;
3983 // Note that we do not call GetClientSize() here but
3984 // GetSize() and subtract the border size for sunken
3985 // borders manually. This is technically incorrect,
3986 // but we need to know the client area's size WITHOUT
3987 // scrollbars here. Since we don't know if there are
3988 // any scrollbars, we use GetSize() instead. Another
3989 // solution would be to call SetScrollbars() here to
3990 // remove the scrollbars and call GetClientSize() then,
3991 // but this might result in flicker and - worse - will
3992 // reset the scrollbars to 0 which is not good at all
3993 // if you resize a dialog/window, but don't want to
3994 // reset the window scrolling. RR.
3995 // Furthermore, we actually do NOT subtract the border
3996 // width as 2 pixels is just the extra space which we
3997 // need around the actual content in the window. Other-
3998 // wise the text would e.g. touch the upper border. RR.
4001 GetSize( &clientWidth
, &clientHeight
);
4003 const int lineHeight
= GetLineHeight();
4005 if ( InReportView() )
4007 // all lines have the same height and we scroll one line per step
4008 int entireHeight
= count
* lineHeight
+ LINE_SPACING
;
4010 m_linesPerPage
= clientHeight
/ lineHeight
;
4012 ResetVisibleLinesRange();
4014 SetScrollbars( SCROLL_UNIT_X
, lineHeight
,
4015 GetHeaderWidth() / SCROLL_UNIT_X
,
4016 (entireHeight
+ lineHeight
- 1) / lineHeight
,
4017 GetScrollPos(wxHORIZONTAL
),
4018 GetScrollPos(wxVERTICAL
),
4023 // we have 3 different layout strategies: either layout all items
4024 // horizontally/vertically (wxLC_ALIGN_XXX styles explicitly given) or
4025 // to arrange them in top to bottom, left to right (don't ask me why
4026 // not the other way round...) order
4027 if ( HasFlag(wxLC_ALIGN_LEFT
| wxLC_ALIGN_TOP
) )
4029 int x
= EXTRA_BORDER_X
;
4030 int y
= EXTRA_BORDER_Y
;
4032 wxCoord widthMax
= 0;
4035 for ( i
= 0; i
< count
; i
++ )
4037 wxListLineData
*line
= GetLine(i
);
4038 line
->CalculateSize( &dc
, iconSpacing
);
4039 line
->SetPosition( x
, y
, iconSpacing
);
4041 wxSize sizeLine
= GetLineSize(i
);
4043 if ( HasFlag(wxLC_ALIGN_TOP
) )
4045 if ( sizeLine
.x
> widthMax
)
4046 widthMax
= sizeLine
.x
;
4050 else // wxLC_ALIGN_LEFT
4052 x
+= sizeLine
.x
+ MARGIN_BETWEEN_ROWS
;
4056 if ( HasFlag(wxLC_ALIGN_TOP
) )
4058 // traverse the items again and tweak their sizes so that they are
4059 // all the same in a row
4060 for ( i
= 0; i
< count
; i
++ )
4062 wxListLineData
*line
= GetLine(i
);
4063 line
->m_gi
->ExtendWidth(widthMax
);
4071 (x
+ SCROLL_UNIT_X
) / SCROLL_UNIT_X
,
4072 (y
+ lineHeight
) / lineHeight
,
4073 GetScrollPos( wxHORIZONTAL
),
4074 GetScrollPos( wxVERTICAL
),
4078 else // "flowed" arrangement, the most complicated case
4080 // at first we try without any scrollbars, if the items don't fit into
4081 // the window, we recalculate after subtracting the space taken by the
4084 int entireWidth
= 0;
4086 for (int tries
= 0; tries
< 2; tries
++)
4088 entireWidth
= 2 * EXTRA_BORDER_X
;
4092 // Now we have decided that the items do not fit into the
4093 // client area, so we need a scrollbar
4094 entireWidth
+= SCROLL_UNIT_X
;
4097 int x
= EXTRA_BORDER_X
;
4098 int y
= EXTRA_BORDER_Y
;
4099 int maxWidthInThisRow
= 0;
4102 int currentlyVisibleLines
= 0;
4104 for (size_t i
= 0; i
< count
; i
++)
4106 currentlyVisibleLines
++;
4107 wxListLineData
*line
= GetLine( i
);
4108 line
->CalculateSize( &dc
, iconSpacing
);
4109 line
->SetPosition( x
, y
, iconSpacing
);
4111 wxSize sizeLine
= GetLineSize( i
);
4113 if ( maxWidthInThisRow
< sizeLine
.x
)
4114 maxWidthInThisRow
= sizeLine
.x
;
4117 if (currentlyVisibleLines
> m_linesPerPage
)
4118 m_linesPerPage
= currentlyVisibleLines
;
4120 if ( y
+ sizeLine
.y
>= clientHeight
)
4122 currentlyVisibleLines
= 0;
4124 maxWidthInThisRow
+= MARGIN_BETWEEN_ROWS
;
4125 x
+= maxWidthInThisRow
;
4126 entireWidth
+= maxWidthInThisRow
;
4127 maxWidthInThisRow
= 0;
4130 // We have reached the last item.
4131 if ( i
== count
- 1 )
4132 entireWidth
+= maxWidthInThisRow
;
4134 if ( (tries
== 0) &&
4135 (entireWidth
+ SCROLL_UNIT_X
> clientWidth
) )
4137 clientHeight
-= wxSystemSettings::
4138 GetMetric(wxSYS_HSCROLL_Y
);
4143 if ( i
== count
- 1 )
4144 tries
= 1; // Everything fits, no second try required.
4152 (entireWidth
+ SCROLL_UNIT_X
) / SCROLL_UNIT_X
,
4154 GetScrollPos( wxHORIZONTAL
),
4163 // FIXME: why should we call it from here?
4170 void wxListMainWindow::RefreshAll()
4175 wxListHeaderWindow
*headerWin
= GetListCtrl()->m_headerWin
;
4176 if ( headerWin
&& headerWin
->m_dirty
)
4178 headerWin
->m_dirty
= false;
4179 headerWin
->Refresh();
4183 void wxListMainWindow::UpdateCurrent()
4185 if ( !HasCurrent() && !IsEmpty() )
4189 long wxListMainWindow::GetNextItem( long item
,
4190 int WXUNUSED(geometry
),
4194 max
= GetItemCount();
4195 wxCHECK_MSG( (ret
== -1) || (ret
< max
), -1,
4196 _T("invalid listctrl index in GetNextItem()") );
4198 // notice that we start with the next item (or the first one if item == -1)
4199 // and this is intentional to allow writing a simple loop to iterate over
4200 // all selected items
4203 // this is not an error because the index was OK initially,
4204 // just no such item
4211 size_t count
= GetItemCount();
4212 for ( size_t line
= (size_t)ret
; line
< count
; line
++ )
4214 if ( (state
& wxLIST_STATE_FOCUSED
) && (line
== m_current
) )
4217 if ( (state
& wxLIST_STATE_SELECTED
) && IsHighlighted(line
) )
4224 // ----------------------------------------------------------------------------
4226 // ----------------------------------------------------------------------------
4228 void wxListMainWindow::DeleteItem( long lindex
)
4230 size_t count
= GetItemCount();
4232 wxCHECK_RET( (lindex
>= 0) && ((size_t)lindex
< count
),
4233 _T("invalid item index in DeleteItem") );
4235 size_t index
= (size_t)lindex
;
4237 // we don't need to adjust the index for the previous items
4238 if ( HasCurrent() && m_current
>= index
)
4240 // if the current item is being deleted, we want the next one to
4241 // become selected - unless there is no next one - so don't adjust
4242 // m_current in this case
4243 if ( m_current
!= index
|| m_current
== count
- 1 )
4247 if ( InReportView() )
4249 // mark the Column Max Width cache as dirty if the items in the line
4250 // we're deleting contain the Max Column Width
4251 wxListLineData
* const line
= GetLine(index
);
4252 wxListItemDataList::compatibility_iterator n
;
4253 wxListItemData
*itemData
;
4257 for (size_t i
= 0; i
< m_columns
.GetCount(); i
++)
4259 n
= line
->m_items
.Item( i
);
4260 itemData
= n
->GetData();
4261 itemData
->GetItem(item
);
4263 itemWidth
= GetItemWidthWithImage(&item
);
4265 if (itemWidth
>= m_aColWidths
.Item(i
)->nMaxWidth
)
4266 m_aColWidths
.Item(i
)->bNeedsUpdate
= true;
4269 ResetVisibleLinesRange();
4275 m_selStore
.OnItemDelete(index
);
4279 m_lines
.RemoveAt( index
);
4282 // we need to refresh the (vert) scrollbar as the number of items changed
4285 SendNotify( index
, wxEVT_COMMAND_LIST_DELETE_ITEM
);
4287 RefreshAfter(index
);
4290 void wxListMainWindow::DeleteColumn( int col
)
4292 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
4294 wxCHECK_RET( node
, wxT("invalid column index in DeleteColumn()") );
4297 delete node
->GetData();
4298 m_columns
.Erase( node
);
4302 // update all the items
4303 for ( size_t i
= 0; i
< m_lines
.GetCount(); i
++ )
4305 wxListLineData
* const line
= GetLine(i
);
4306 wxListItemDataList::compatibility_iterator n
= line
->m_items
.Item( col
);
4307 delete n
->GetData();
4308 line
->m_items
.Erase(n
);
4312 if ( InReportView() ) // we only cache max widths when in Report View
4314 delete m_aColWidths
.Item(col
);
4315 m_aColWidths
.RemoveAt(col
);
4318 // invalidate it as it has to be recalculated
4322 void wxListMainWindow::DoDeleteAllItems()
4325 // nothing to do - in particular, don't send the event
4330 // to make the deletion of all items faster, we don't send the
4331 // notifications for each item deletion in this case but only one event
4332 // for all of them: this is compatible with wxMSW and documented in
4333 // DeleteAllItems() description
4335 wxListEvent
event( wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS
, GetParent()->GetId() );
4336 event
.SetEventObject( GetParent() );
4337 GetParent()->GetEventHandler()->ProcessEvent( event
);
4345 if ( InReportView() )
4347 ResetVisibleLinesRange();
4348 for (size_t i
= 0; i
< m_aColWidths
.GetCount(); i
++)
4350 m_aColWidths
.Item(i
)->bNeedsUpdate
= true;
4357 void wxListMainWindow::DeleteAllItems()
4361 RecalculatePositions();
4364 void wxListMainWindow::DeleteEverything()
4366 WX_CLEAR_LIST(wxListHeaderDataList
, m_columns
);
4367 WX_CLEAR_ARRAY(m_aColWidths
);
4372 // ----------------------------------------------------------------------------
4373 // scanning for an item
4374 // ----------------------------------------------------------------------------
4376 void wxListMainWindow::EnsureVisible( long index
)
4378 wxCHECK_RET( index
>= 0 && (size_t)index
< GetItemCount(),
4379 _T("invalid index in EnsureVisible") );
4381 // We have to call this here because the label in question might just have
4382 // been added and its position is not known yet
4384 RecalculatePositions(true /* no refresh */);
4386 MoveToItem((size_t)index
);
4389 long wxListMainWindow::FindItem(long start
, const wxString
& str
, bool WXUNUSED(partial
) )
4396 size_t count
= GetItemCount();
4397 for ( size_t i
= (size_t)pos
; i
< count
; i
++ )
4399 wxListLineData
*line
= GetLine(i
);
4400 if ( line
->GetText(0) == tmp
)
4407 long wxListMainWindow::FindItem(long start
, wxUIntPtr data
)
4413 size_t count
= GetItemCount();
4414 for (size_t i
= (size_t)pos
; i
< count
; i
++)
4416 wxListLineData
*line
= GetLine(i
);
4418 line
->GetItem( 0, item
);
4419 if (item
.m_data
== data
)
4426 long wxListMainWindow::FindItem( const wxPoint
& pt
)
4429 GetVisibleLinesRange( &topItem
, NULL
);
4432 GetItemPosition( GetItemCount() - 1, p
);
4436 long id
= (long)floor( pt
.y
* double(GetItemCount() - topItem
- 1) / p
.y
+ topItem
);
4437 if ( id
>= 0 && id
< (long)GetItemCount() )
4443 long wxListMainWindow::HitTest( int x
, int y
, int &flags
) const
4445 CalcUnscrolledPosition( x
, y
, &x
, &y
);
4447 size_t count
= GetItemCount();
4449 if ( InReportView() )
4451 size_t current
= y
/ GetLineHeight();
4452 if ( current
< count
)
4454 flags
= HitTestLine(current
, x
, y
);
4461 // TODO: optimize it too! this is less simple than for report view but
4462 // enumerating all items is still not a way to do it!!
4463 for ( size_t current
= 0; current
< count
; current
++ )
4465 flags
= HitTestLine(current
, x
, y
);
4474 // ----------------------------------------------------------------------------
4476 // ----------------------------------------------------------------------------
4478 void wxListMainWindow::InsertItem( wxListItem
&item
)
4480 wxASSERT_MSG( !IsVirtual(), _T("can't be used with virtual control") );
4482 int count
= GetItemCount();
4483 wxCHECK_RET( item
.m_itemId
>= 0, _T("invalid item index") );
4485 if (item
.m_itemId
> count
)
4486 item
.m_itemId
= count
;
4488 size_t id
= item
.m_itemId
;
4492 if ( InReportView() )
4494 ResetVisibleLinesRange();
4496 // calculate the width of the item and adjust the max column width
4497 wxColWidthInfo
*pWidthInfo
= m_aColWidths
.Item(item
.GetColumn());
4498 int width
= GetItemWidthWithImage(&item
);
4499 item
.SetWidth(width
);
4500 if (width
> pWidthInfo
->nMaxWidth
)
4501 pWidthInfo
->nMaxWidth
= width
;
4504 wxListLineData
*line
= new wxListLineData(this);
4506 line
->SetItem( item
.m_col
, item
);
4508 m_lines
.Insert( line
, id
);
4512 // If an item is selected at or below the point of insertion, we need to
4513 // increment the member variables because the current row's index has gone
4515 if ( HasCurrent() && m_current
>= id
)
4518 SendNotify(id
, wxEVT_COMMAND_LIST_INSERT_ITEM
);
4520 RefreshLines(id
, GetItemCount() - 1);
4523 void wxListMainWindow::InsertColumn( long col
, wxListItem
&item
)
4526 if ( InReportView() )
4528 if (item
.m_width
== wxLIST_AUTOSIZE_USEHEADER
)
4529 item
.m_width
= GetTextLength( item
.m_text
);
4531 wxListHeaderData
*column
= new wxListHeaderData( item
);
4532 wxColWidthInfo
*colWidthInfo
= new wxColWidthInfo();
4534 bool insert
= (col
>= 0) && ((size_t)col
< m_columns
.GetCount());
4537 wxListHeaderDataList::compatibility_iterator
4538 node
= m_columns
.Item( col
);
4539 m_columns
.Insert( node
, column
);
4540 m_aColWidths
.Insert( colWidthInfo
, col
);
4544 m_columns
.Append( column
);
4545 m_aColWidths
.Add( colWidthInfo
);
4550 // update all the items
4551 for ( size_t i
= 0; i
< m_lines
.GetCount(); i
++ )
4553 wxListLineData
* const line
= GetLine(i
);
4554 wxListItemData
* const data
= new wxListItemData(this);
4556 line
->m_items
.Insert(col
, data
);
4558 line
->m_items
.Append(data
);
4562 // invalidate it as it has to be recalculated
4567 int wxListMainWindow::GetItemWidthWithImage(wxListItem
* item
)
4570 wxClientDC
dc(this);
4572 dc
.SetFont( GetFont() );
4574 if (item
->GetImage() != -1)
4577 GetImageSize( item
->GetImage(), ix
, iy
);
4581 if (!item
->GetText().empty())
4584 dc
.GetTextExtent( item
->GetText(), &w
, NULL
);
4591 // ----------------------------------------------------------------------------
4593 // ----------------------------------------------------------------------------
4595 wxListCtrlCompare list_ctrl_compare_func_2
;
4596 long list_ctrl_compare_data
;
4598 int LINKAGEMODE
list_ctrl_compare_func_1( wxListLineData
**arg1
, wxListLineData
**arg2
)
4600 wxListLineData
*line1
= *arg1
;
4601 wxListLineData
*line2
= *arg2
;
4603 line1
->GetItem( 0, item
);
4604 wxUIntPtr data1
= item
.m_data
;
4605 line2
->GetItem( 0, item
);
4606 wxUIntPtr data2
= item
.m_data
;
4607 return list_ctrl_compare_func_2( data1
, data2
, list_ctrl_compare_data
);
4610 void wxListMainWindow::SortItems( wxListCtrlCompare fn
, long data
)
4612 list_ctrl_compare_func_2
= fn
;
4613 list_ctrl_compare_data
= data
;
4614 m_lines
.Sort( list_ctrl_compare_func_1
);
4618 // ----------------------------------------------------------------------------
4620 // ----------------------------------------------------------------------------
4622 void wxListMainWindow::OnScroll(wxScrollWinEvent
& event
)
4624 // update our idea of which lines are shown when we redraw the window the
4626 ResetVisibleLinesRange();
4629 #if ( defined(__WXGTK__) || defined(__WXMAC__) ) && !defined(__WXUNIVERSAL__)
4630 wxScrolledWindow::OnScroll(event
);
4632 HandleOnScroll( event
);
4635 if ( event
.GetOrientation() == wxHORIZONTAL
&& HasHeader() )
4637 wxGenericListCtrl
* lc
= GetListCtrl();
4638 wxCHECK_RET( lc
, _T("no listctrl window?") );
4640 lc
->m_headerWin
->Refresh();
4641 lc
->m_headerWin
->Update();
4645 int wxListMainWindow::GetCountPerPage() const
4647 if ( !m_linesPerPage
)
4649 wxConstCast(this, wxListMainWindow
)->
4650 m_linesPerPage
= GetClientSize().y
/ GetLineHeight();
4653 return m_linesPerPage
;
4656 void wxListMainWindow::GetVisibleLinesRange(size_t *from
, size_t *to
)
4658 wxASSERT_MSG( InReportView(), _T("this is for report mode only") );
4660 if ( m_lineFrom
== (size_t)-1 )
4662 size_t count
= GetItemCount();
4665 m_lineFrom
= GetScrollPos(wxVERTICAL
);
4667 // this may happen if SetScrollbars() hadn't been called yet
4668 if ( m_lineFrom
>= count
)
4669 m_lineFrom
= count
- 1;
4671 // we redraw one extra line but this is needed to make the redrawing
4672 // logic work when there is a fractional number of lines on screen
4673 m_lineTo
= m_lineFrom
+ m_linesPerPage
;
4674 if ( m_lineTo
>= count
)
4675 m_lineTo
= count
- 1;
4677 else // empty control
4680 m_lineTo
= (size_t)-1;
4684 wxASSERT_MSG( IsEmpty() ||
4685 (m_lineFrom
<= m_lineTo
&& m_lineTo
< GetItemCount()),
4686 _T("GetVisibleLinesRange() returns incorrect result") );
4694 // -------------------------------------------------------------------------------------
4695 // wxGenericListCtrl
4696 // -------------------------------------------------------------------------------------
4698 IMPLEMENT_DYNAMIC_CLASS(wxGenericListCtrl
, wxControl
)
4700 BEGIN_EVENT_TABLE(wxGenericListCtrl
,wxControl
)
4701 EVT_SIZE(wxGenericListCtrl::OnSize
)
4704 wxGenericListCtrl::wxGenericListCtrl()
4706 m_imageListNormal
= (wxImageListType
*) NULL
;
4707 m_imageListSmall
= (wxImageListType
*) NULL
;
4708 m_imageListState
= (wxImageListType
*) NULL
;
4710 m_ownsImageListNormal
=
4711 m_ownsImageListSmall
=
4712 m_ownsImageListState
= false;
4714 m_mainWin
= (wxListMainWindow
*) NULL
;
4715 m_headerWin
= (wxListHeaderWindow
*) NULL
;
4719 wxGenericListCtrl::~wxGenericListCtrl()
4721 if (m_ownsImageListNormal
)
4722 delete m_imageListNormal
;
4723 if (m_ownsImageListSmall
)
4724 delete m_imageListSmall
;
4725 if (m_ownsImageListState
)
4726 delete m_imageListState
;
4729 void wxGenericListCtrl::CalculateAndSetHeaderHeight()
4735 GetThemeMetric( kThemeMetricListHeaderHeight
, &h
);
4737 // we use 'g' to get the descent, too
4739 m_headerWin
->GetTextExtent(wxT("Hg"), &w
, &h
, &d
);
4740 h
+= d
+ 2 * HEADER_OFFSET_Y
+ EXTRA_HEIGHT
;
4743 // only update if changed
4744 if ( h
!= m_headerHeight
)
4749 ResizeReportView(true);
4750 else //why is this needed if it doesn't have a header?
4751 m_headerWin
->SetSize(m_headerWin
->GetSize().x
, m_headerHeight
);
4756 void wxGenericListCtrl::CreateHeaderWindow()
4758 m_headerWin
= new wxListHeaderWindow
4760 this, wxID_ANY
, m_mainWin
,
4762 wxSize(GetClientSize().x
, m_headerHeight
),
4765 CalculateAndSetHeaderHeight();
4768 bool wxGenericListCtrl::Create(wxWindow
*parent
,
4773 const wxValidator
&validator
,
4774 const wxString
&name
)
4778 m_imageListState
= (wxImageListType
*) NULL
;
4779 m_ownsImageListNormal
=
4780 m_ownsImageListSmall
=
4781 m_ownsImageListState
= false;
4783 m_mainWin
= (wxListMainWindow
*) NULL
;
4784 m_headerWin
= (wxListHeaderWindow
*) NULL
;
4788 if ( !(style
& wxLC_MASK_TYPE
) )
4790 style
= style
| wxLC_LIST
;
4793 if ( !wxControl::Create( parent
, id
, pos
, size
, style
, validator
, name
) )
4796 // don't create the inner window with the border
4797 style
&= ~wxBORDER_MASK
;
4799 m_mainWin
= new wxListMainWindow( this, wxID_ANY
, wxPoint(0, 0), size
, style
);
4801 #ifdef __WXMAC_CARBON__
4802 // Human Interface Guidelines ask us for a special font in this case
4803 if ( GetWindowVariant() == wxWINDOW_VARIANT_NORMAL
)
4806 font
.MacCreateThemeFont( kThemeViewsFont
);
4811 if ( InReportView() )
4813 CreateHeaderWindow();
4815 #ifdef __WXMAC_CARBON__
4819 font
.MacCreateThemeFont( kThemeSmallSystemFont
);
4820 m_headerWin
->SetFont( font
);
4821 CalculateAndSetHeaderHeight();
4825 if ( HasFlag(wxLC_NO_HEADER
) )
4826 // VZ: why do we create it at all then?
4827 m_headerWin
->Show( false );
4835 void wxGenericListCtrl::SetSingleStyle( long style
, bool add
)
4837 wxASSERT_MSG( !(style
& wxLC_VIRTUAL
),
4838 _T("wxLC_VIRTUAL can't be [un]set") );
4840 long flag
= GetWindowStyle();
4844 if (style
& wxLC_MASK_TYPE
)
4845 flag
&= ~(wxLC_MASK_TYPE
| wxLC_VIRTUAL
);
4846 if (style
& wxLC_MASK_ALIGN
)
4847 flag
&= ~wxLC_MASK_ALIGN
;
4848 if (style
& wxLC_MASK_SORT
)
4849 flag
&= ~wxLC_MASK_SORT
;
4857 SetWindowStyleFlag( flag
);
4860 void wxGenericListCtrl::SetWindowStyleFlag( long flag
)
4864 m_mainWin
->DeleteEverything();
4866 // has the header visibility changed?
4867 bool hasHeader
= HasHeader();
4868 bool willHaveHeader
= (flag
& wxLC_REPORT
) && !(flag
& wxLC_NO_HEADER
);
4870 if ( hasHeader
!= willHaveHeader
)
4877 // don't delete, just hide, as we can reuse it later
4878 m_headerWin
->Show(false);
4880 //else: nothing to do
4882 else // must show header
4886 CreateHeaderWindow();
4888 else // already have it, just show
4890 m_headerWin
->Show( true );
4894 ResizeReportView(willHaveHeader
);
4898 wxWindow::SetWindowStyleFlag( flag
);
4901 bool wxGenericListCtrl::GetColumn(int col
, wxListItem
&item
) const
4903 m_mainWin
->GetColumn( col
, item
);
4907 bool wxGenericListCtrl::SetColumn( int col
, wxListItem
& item
)
4909 m_mainWin
->SetColumn( col
, item
);
4913 int wxGenericListCtrl::GetColumnWidth( int col
) const
4915 return m_mainWin
->GetColumnWidth( col
);
4918 bool wxGenericListCtrl::SetColumnWidth( int col
, int width
)
4920 m_mainWin
->SetColumnWidth( col
, width
);
4924 int wxGenericListCtrl::GetCountPerPage() const
4926 return m_mainWin
->GetCountPerPage(); // different from Windows ?
4929 bool wxGenericListCtrl::GetItem( wxListItem
&info
) const
4931 m_mainWin
->GetItem( info
);
4935 bool wxGenericListCtrl::SetItem( wxListItem
&info
)
4937 m_mainWin
->SetItem( info
);
4941 long wxGenericListCtrl::SetItem( long index
, int col
, const wxString
& label
, int imageId
)
4944 info
.m_text
= label
;
4945 info
.m_mask
= wxLIST_MASK_TEXT
;
4946 info
.m_itemId
= index
;
4950 info
.m_image
= imageId
;
4951 info
.m_mask
|= wxLIST_MASK_IMAGE
;
4954 m_mainWin
->SetItem(info
);
4958 int wxGenericListCtrl::GetItemState( long item
, long stateMask
) const
4960 return m_mainWin
->GetItemState( item
, stateMask
);
4963 bool wxGenericListCtrl::SetItemState( long item
, long state
, long stateMask
)
4965 m_mainWin
->SetItemState( item
, state
, stateMask
);
4970 wxGenericListCtrl::SetItemImage( long item
, int image
, int WXUNUSED(selImage
) )
4972 return SetItemColumnImage(item
, 0, image
);
4976 wxGenericListCtrl::SetItemColumnImage( long item
, long column
, int image
)
4979 info
.m_image
= image
;
4980 info
.m_mask
= wxLIST_MASK_IMAGE
;
4981 info
.m_itemId
= item
;
4982 info
.m_col
= column
;
4983 m_mainWin
->SetItem( info
);
4987 wxString
wxGenericListCtrl::GetItemText( long item
) const
4989 return m_mainWin
->GetItemText(item
);
4992 void wxGenericListCtrl::SetItemText( long item
, const wxString
& str
)
4994 m_mainWin
->SetItemText(item
, str
);
4997 wxUIntPtr
wxGenericListCtrl::GetItemData( long item
) const
5000 info
.m_mask
= wxLIST_MASK_DATA
;
5001 info
.m_itemId
= item
;
5002 m_mainWin
->GetItem( info
);
5006 bool wxGenericListCtrl::SetItemData( long item
, long data
)
5009 info
.m_mask
= wxLIST_MASK_DATA
;
5010 info
.m_itemId
= item
;
5012 m_mainWin
->SetItem( info
);
5016 wxRect
wxGenericListCtrl::GetViewRect() const
5018 return m_mainWin
->GetViewRect();
5021 bool wxGenericListCtrl::GetItemRect( long item
, wxRect
&rect
, int WXUNUSED(code
) ) const
5023 m_mainWin
->GetItemRect( item
, rect
);
5024 if ( m_mainWin
->HasHeader() )
5025 rect
.y
+= m_headerHeight
+ 1;
5029 bool wxGenericListCtrl::GetItemPosition( long item
, wxPoint
& pos
) const
5031 m_mainWin
->GetItemPosition( item
, pos
);
5035 bool wxGenericListCtrl::SetItemPosition( long WXUNUSED(item
), const wxPoint
& WXUNUSED(pos
) )
5040 int wxGenericListCtrl::GetItemCount() const
5042 return m_mainWin
->GetItemCount();
5045 int wxGenericListCtrl::GetColumnCount() const
5047 return m_mainWin
->GetColumnCount();
5050 void wxGenericListCtrl::SetItemSpacing( int spacing
, bool isSmall
)
5052 m_mainWin
->SetItemSpacing( spacing
, isSmall
);
5055 wxSize
wxGenericListCtrl::GetItemSpacing() const
5057 const int spacing
= m_mainWin
->GetItemSpacing(HasFlag(wxLC_SMALL_ICON
));
5059 return wxSize(spacing
, spacing
);
5062 #if WXWIN_COMPATIBILITY_2_6
5063 int wxGenericListCtrl::GetItemSpacing( bool isSmall
) const
5065 return m_mainWin
->GetItemSpacing( isSmall
);
5067 #endif // WXWIN_COMPATIBILITY_2_6
5069 void wxGenericListCtrl::SetItemTextColour( long item
, const wxColour
&col
)
5072 info
.m_itemId
= item
;
5073 info
.SetTextColour( col
);
5074 m_mainWin
->SetItem( info
);
5077 wxColour
wxGenericListCtrl::GetItemTextColour( long item
) const
5080 info
.m_itemId
= item
;
5081 m_mainWin
->GetItem( info
);
5082 return info
.GetTextColour();
5085 void wxGenericListCtrl::SetItemBackgroundColour( long item
, const wxColour
&col
)
5088 info
.m_itemId
= item
;
5089 info
.SetBackgroundColour( col
);
5090 m_mainWin
->SetItem( info
);
5093 wxColour
wxGenericListCtrl::GetItemBackgroundColour( long item
) const
5096 info
.m_itemId
= item
;
5097 m_mainWin
->GetItem( info
);
5098 return info
.GetBackgroundColour();
5101 void wxGenericListCtrl::SetItemFont( long item
, const wxFont
&f
)
5104 info
.m_itemId
= item
;
5106 m_mainWin
->SetItem( info
);
5109 wxFont
wxGenericListCtrl::GetItemFont( long item
) const
5112 info
.m_itemId
= item
;
5113 m_mainWin
->GetItem( info
);
5114 return info
.GetFont();
5117 int wxGenericListCtrl::GetSelectedItemCount() const
5119 return m_mainWin
->GetSelectedItemCount();
5122 wxColour
wxGenericListCtrl::GetTextColour() const
5124 return GetForegroundColour();
5127 void wxGenericListCtrl::SetTextColour(const wxColour
& col
)
5129 SetForegroundColour(col
);
5132 long wxGenericListCtrl::GetTopItem() const
5135 m_mainWin
->GetVisibleLinesRange(&top
, NULL
);
5139 long wxGenericListCtrl::GetNextItem( long item
, int geom
, int state
) const
5141 return m_mainWin
->GetNextItem( item
, geom
, state
);
5144 wxImageListType
*wxGenericListCtrl::GetImageList(int which
) const
5146 if (which
== wxIMAGE_LIST_NORMAL
)
5147 return m_imageListNormal
;
5148 else if (which
== wxIMAGE_LIST_SMALL
)
5149 return m_imageListSmall
;
5150 else if (which
== wxIMAGE_LIST_STATE
)
5151 return m_imageListState
;
5153 return (wxImageListType
*) NULL
;
5156 void wxGenericListCtrl::SetImageList( wxImageListType
*imageList
, int which
)
5158 if ( which
== wxIMAGE_LIST_NORMAL
)
5160 if (m_ownsImageListNormal
)
5161 delete m_imageListNormal
;
5162 m_imageListNormal
= imageList
;
5163 m_ownsImageListNormal
= false;
5165 else if ( which
== wxIMAGE_LIST_SMALL
)
5167 if (m_ownsImageListSmall
)
5168 delete m_imageListSmall
;
5169 m_imageListSmall
= imageList
;
5170 m_ownsImageListSmall
= false;
5172 else if ( which
== wxIMAGE_LIST_STATE
)
5174 if (m_ownsImageListState
)
5175 delete m_imageListState
;
5176 m_imageListState
= imageList
;
5177 m_ownsImageListState
= false;
5180 m_mainWin
->SetImageList( imageList
, which
);
5183 void wxGenericListCtrl::AssignImageList(wxImageListType
*imageList
, int which
)
5185 SetImageList(imageList
, which
);
5186 if ( which
== wxIMAGE_LIST_NORMAL
)
5187 m_ownsImageListNormal
= true;
5188 else if ( which
== wxIMAGE_LIST_SMALL
)
5189 m_ownsImageListSmall
= true;
5190 else if ( which
== wxIMAGE_LIST_STATE
)
5191 m_ownsImageListState
= true;
5194 bool wxGenericListCtrl::Arrange( int WXUNUSED(flag
) )
5199 bool wxGenericListCtrl::DeleteItem( long item
)
5201 m_mainWin
->DeleteItem( item
);
5205 bool wxGenericListCtrl::DeleteAllItems()
5207 m_mainWin
->DeleteAllItems();
5211 bool wxGenericListCtrl::DeleteAllColumns()
5213 size_t count
= m_mainWin
->m_columns
.GetCount();
5214 for ( size_t n
= 0; n
< count
; n
++ )
5219 void wxGenericListCtrl::ClearAll()
5221 m_mainWin
->DeleteEverything();
5224 bool wxGenericListCtrl::DeleteColumn( int col
)
5226 m_mainWin
->DeleteColumn( col
);
5228 // if we don't have the header any longer, we need to relayout the window
5229 if ( !GetColumnCount() )
5230 ResizeReportView(false /* no header */);
5234 wxTextCtrl
*wxGenericListCtrl::EditLabel(long item
,
5235 wxClassInfo
* textControlClass
)
5237 return m_mainWin
->EditLabel( item
, textControlClass
);
5240 wxTextCtrl
*wxGenericListCtrl::GetEditControl() const
5242 return m_mainWin
->GetEditControl();
5245 bool wxGenericListCtrl::EnsureVisible( long item
)
5247 m_mainWin
->EnsureVisible( item
);
5251 long wxGenericListCtrl::FindItem( long start
, const wxString
& str
, bool partial
)
5253 return m_mainWin
->FindItem( start
, str
, partial
);
5256 long wxGenericListCtrl::FindItem( long start
, wxUIntPtr data
)
5258 return m_mainWin
->FindItem( start
, data
);
5261 long wxGenericListCtrl::FindItem( long WXUNUSED(start
), const wxPoint
& pt
,
5262 int WXUNUSED(direction
))
5264 return m_mainWin
->FindItem( pt
);
5267 // TODO: sub item hit testing
5268 long wxGenericListCtrl::HitTest(const wxPoint
& point
, int& flags
, long *) const
5270 return m_mainWin
->HitTest( (int)point
.x
, (int)point
.y
, flags
);
5273 long wxGenericListCtrl::InsertItem( wxListItem
& info
)
5275 m_mainWin
->InsertItem( info
);
5276 return info
.m_itemId
;
5279 long wxGenericListCtrl::InsertItem( long index
, const wxString
&label
)
5282 info
.m_text
= label
;
5283 info
.m_mask
= wxLIST_MASK_TEXT
;
5284 info
.m_itemId
= index
;
5285 return InsertItem( info
);
5288 long wxGenericListCtrl::InsertItem( long index
, int imageIndex
)
5291 info
.m_mask
= wxLIST_MASK_IMAGE
;
5292 info
.m_image
= imageIndex
;
5293 info
.m_itemId
= index
;
5294 return InsertItem( info
);
5297 long wxGenericListCtrl::InsertItem( long index
, const wxString
&label
, int imageIndex
)
5300 info
.m_text
= label
;
5301 info
.m_image
= imageIndex
;
5302 info
.m_mask
= wxLIST_MASK_TEXT
| wxLIST_MASK_IMAGE
;
5303 info
.m_itemId
= index
;
5304 return InsertItem( info
);
5307 long wxGenericListCtrl::InsertColumn( long col
, wxListItem
&item
)
5309 wxCHECK_MSG( m_headerWin
, -1, _T("can't add column in non report mode") );
5311 m_mainWin
->InsertColumn( col
, item
);
5313 // if we hadn't had a header before but have one now
5314 // then we need to relayout the window
5315 if ( GetColumnCount() == 1 && m_mainWin
->HasHeader() )
5316 ResizeReportView(true /* have header */);
5318 m_headerWin
->Refresh();
5323 long wxGenericListCtrl::InsertColumn( long col
, const wxString
&heading
,
5324 int format
, int width
)
5327 item
.m_mask
= wxLIST_MASK_TEXT
| wxLIST_MASK_FORMAT
;
5328 item
.m_text
= heading
;
5331 item
.m_mask
|= wxLIST_MASK_WIDTH
;
5332 item
.m_width
= width
;
5335 item
.m_format
= format
;
5337 return InsertColumn( col
, item
);
5340 bool wxGenericListCtrl::ScrollList( int WXUNUSED(dx
), int WXUNUSED(dy
) )
5346 // fn is a function which takes 3 long arguments: item1, item2, data.
5347 // item1 is the long data associated with a first item (NOT the index).
5348 // item2 is the long data associated with a second item (NOT the index).
5349 // data is the same value as passed to SortItems.
5350 // The return value is a negative number if the first item should precede the second
5351 // item, a positive number of the second item should precede the first,
5352 // or zero if the two items are equivalent.
5353 // data is arbitrary data to be passed to the sort function.
5355 bool wxGenericListCtrl::SortItems( wxListCtrlCompare fn
, long data
)
5357 m_mainWin
->SortItems( fn
, data
);
5361 // ----------------------------------------------------------------------------
5363 // ----------------------------------------------------------------------------
5365 void wxGenericListCtrl::OnSize(wxSizeEvent
& WXUNUSED(event
))
5370 ResizeReportView(m_mainWin
->HasHeader());
5371 m_mainWin
->RecalculatePositions();
5374 void wxGenericListCtrl::ResizeReportView(bool showHeader
)
5377 GetClientSize( &cw
, &ch
);
5381 m_headerWin
->SetSize( 0, 0, cw
, m_headerHeight
);
5382 if(ch
> m_headerHeight
)
5383 m_mainWin
->SetSize( 0, m_headerHeight
+ 1,
5384 cw
, ch
- m_headerHeight
- 1 );
5386 m_mainWin
->SetSize( 0, m_headerHeight
+ 1,
5389 else // no header window
5391 m_mainWin
->SetSize( 0, 0, cw
, ch
);
5395 void wxGenericListCtrl::OnInternalIdle()
5397 wxWindow::OnInternalIdle();
5399 // do it only if needed
5400 if ( !m_mainWin
->m_dirty
)
5403 m_mainWin
->RecalculatePositions();
5406 // ----------------------------------------------------------------------------
5408 // ----------------------------------------------------------------------------
5410 bool wxGenericListCtrl::SetBackgroundColour( const wxColour
&colour
)
5414 m_mainWin
->SetBackgroundColour( colour
);
5415 m_mainWin
->m_dirty
= true;
5421 bool wxGenericListCtrl::SetForegroundColour( const wxColour
&colour
)
5423 if ( !wxWindow::SetForegroundColour( colour
) )
5428 m_mainWin
->SetForegroundColour( colour
);
5429 m_mainWin
->m_dirty
= true;
5433 m_headerWin
->SetForegroundColour( colour
);
5438 bool wxGenericListCtrl::SetFont( const wxFont
&font
)
5440 if ( !wxWindow::SetFont( font
) )
5445 m_mainWin
->SetFont( font
);
5446 m_mainWin
->m_dirty
= true;
5451 m_headerWin
->SetFont( font
);
5452 CalculateAndSetHeaderHeight();
5462 wxGenericListCtrl::GetClassDefaultAttributes(wxWindowVariant variant
)
5465 // Use the same color scheme as wxListBox
5466 return wxListBox::GetClassDefaultAttributes(variant
);
5468 wxUnusedVar(variant
);
5469 wxVisualAttributes attr
;
5470 attr
.colFg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
5471 attr
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX
);
5472 attr
.font
= wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
5477 // ----------------------------------------------------------------------------
5478 // methods forwarded to m_mainWin
5479 // ----------------------------------------------------------------------------
5481 #if wxUSE_DRAG_AND_DROP
5483 void wxGenericListCtrl::SetDropTarget( wxDropTarget
*dropTarget
)
5485 m_mainWin
->SetDropTarget( dropTarget
);
5488 wxDropTarget
*wxGenericListCtrl::GetDropTarget() const
5490 return m_mainWin
->GetDropTarget();
5495 bool wxGenericListCtrl::SetCursor( const wxCursor
&cursor
)
5497 return m_mainWin
? m_mainWin
->wxWindow::SetCursor(cursor
) : false;
5500 wxColour
wxGenericListCtrl::GetBackgroundColour() const
5502 return m_mainWin
? m_mainWin
->GetBackgroundColour() : wxColour();
5505 wxColour
wxGenericListCtrl::GetForegroundColour() const
5507 return m_mainWin
? m_mainWin
->GetForegroundColour() : wxColour();
5510 bool wxGenericListCtrl::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
5513 return m_mainWin
->PopupMenu( menu
, x
, y
);
5519 void wxGenericListCtrl::DoClientToScreen( int *x
, int *y
) const
5521 m_mainWin
->DoClientToScreen(x
, y
);
5524 void wxGenericListCtrl::DoScreenToClient( int *x
, int *y
) const
5526 m_mainWin
->DoScreenToClient(x
, y
);
5529 void wxGenericListCtrl::SetFocus()
5531 // The test in window.cpp fails as we are a composite
5532 // window, so it checks against "this", but not m_mainWin.
5533 if ( DoFindFocus() != this )
5534 m_mainWin
->SetFocus();
5537 wxSize
wxGenericListCtrl::DoGetBestSize() const
5539 // Something is better than nothing...
5540 // 100x80 is what the MSW version will get from the default
5541 // wxControl::DoGetBestSize
5542 return wxSize(100, 80);
5545 // ----------------------------------------------------------------------------
5546 // virtual list control support
5547 // ----------------------------------------------------------------------------
5549 wxString
wxGenericListCtrl::OnGetItemText(long WXUNUSED(item
), long WXUNUSED(col
)) const
5551 // this is a pure virtual function, in fact - which is not really pure
5552 // because the controls which are not virtual don't need to implement it
5553 wxFAIL_MSG( _T("wxGenericListCtrl::OnGetItemText not supposed to be called") );
5555 return wxEmptyString
;
5558 int wxGenericListCtrl::OnGetItemImage(long WXUNUSED(item
)) const
5560 wxCHECK_MSG(!GetImageList(wxIMAGE_LIST_SMALL
),
5562 wxT("List control has an image list, OnGetItemImage or OnGetItemColumnImage should be overridden."));
5566 int wxGenericListCtrl::OnGetItemColumnImage(long item
, long column
) const
5569 return OnGetItemImage(item
);
5575 wxGenericListCtrl::OnGetItemAttr(long WXUNUSED_UNLESS_DEBUG(item
)) const
5577 wxASSERT_MSG( item
>= 0 && item
< GetItemCount(),
5578 _T("invalid item index in OnGetItemAttr()") );
5580 // no attributes by default
5584 void wxGenericListCtrl::SetItemCount(long count
)
5586 wxASSERT_MSG( IsVirtual(), _T("this is for virtual controls only") );
5588 m_mainWin
->SetItemCount(count
);
5591 void wxGenericListCtrl::RefreshItem(long item
)
5593 m_mainWin
->RefreshLine(item
);
5596 void wxGenericListCtrl::RefreshItems(long itemFrom
, long itemTo
)
5598 m_mainWin
->RefreshLines(itemFrom
, itemTo
);
5601 // Generic wxListCtrl is more or less a container for two other
5602 // windows which drawings are done upon. These are namely
5603 // 'm_headerWin' and 'm_mainWin'.
5604 // Here we override 'virtual wxWindow::Refresh()' to mimic the
5605 // behaviour wxListCtrl has under wxMSW.
5607 void wxGenericListCtrl::Refresh(bool eraseBackground
, const wxRect
*rect
)
5611 // The easy case, no rectangle specified.
5613 m_headerWin
->Refresh(eraseBackground
);
5616 m_mainWin
->Refresh(eraseBackground
);
5620 // Refresh the header window
5623 wxRect rectHeader
= m_headerWin
->GetRect();
5624 rectHeader
.Intersect(*rect
);
5625 if (rectHeader
.GetWidth() && rectHeader
.GetHeight())
5628 m_headerWin
->GetPosition(&x
, &y
);
5629 rectHeader
.Offset(-x
, -y
);
5630 m_headerWin
->Refresh(eraseBackground
, &rectHeader
);
5634 // Refresh the main window
5637 wxRect rectMain
= m_mainWin
->GetRect();
5638 rectMain
.Intersect(*rect
);
5639 if (rectMain
.GetWidth() && rectMain
.GetHeight())
5642 m_mainWin
->GetPosition(&x
, &y
);
5643 rectMain
.Offset(-x
, -y
);
5644 m_mainWin
->Refresh(eraseBackground
, &rectMain
);
5650 void wxGenericListCtrl::Freeze()
5652 m_mainWin
->Freeze();
5655 void wxGenericListCtrl::Thaw()
5660 #endif // wxUSE_LISTCTRL