1 /////////////////////////////////////////////////////////////////////////////
2 // Name: 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 /////////////////////////////////////////////////////////////////////////////
14 1. we need to implement searching/sorting for virtual controls somehow
15 ?2. when changing selection the lines are refreshed twice
18 // ============================================================================
20 // ============================================================================
22 // ----------------------------------------------------------------------------
24 // ----------------------------------------------------------------------------
26 #if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
27 #pragma implementation "listctrl.h"
28 #pragma implementation "listctrlbase.h"
31 // For compilers that support precompilation, includes "wx.h".
32 #include "wx/wxprec.h"
43 #include "wx/dynarray.h"
45 #include "wx/dcscreen.h"
47 #include "wx/textctrl.h"
50 // under Win32 we always use the native version and also may use the generic
51 // one, however some things should be done only if we use only the generic
53 #if defined(__WIN32__) && !defined(__WXUNIVERSAL__)
54 #define HAVE_NATIVE_LISTCTRL
57 // if we have the native control, wx/listctrl.h declares it and not this one
58 #ifdef HAVE_NATIVE_LISTCTRL
59 #include "wx/generic/listctrl.h"
60 #else // !HAVE_NATIVE_LISTCTRL
61 #include "wx/listctrl.h"
63 // if we have a native version, its implementation file does all this
64 IMPLEMENT_DYNAMIC_CLASS(wxListItem
, wxObject
)
65 IMPLEMENT_DYNAMIC_CLASS(wxListView
, wxListCtrl
)
66 IMPLEMENT_DYNAMIC_CLASS(wxListEvent
, wxNotifyEvent
)
68 IMPLEMENT_DYNAMIC_CLASS(wxListCtrl
, wxGenericListCtrl
)
69 #endif // HAVE_NATIVE_LISTCTRL/!HAVE_NATIVE_LISTCTRL
71 #include "wx/selstore.h"
73 #include "wx/renderer.h"
76 #include "wx/mac/private.h"
82 // NOTE: If using the wxListBox visual attributes works everywhere then this can
83 // be removed, as well as the #else case below.
84 #define _USE_VISATTR 0
87 // ----------------------------------------------------------------------------
89 // ----------------------------------------------------------------------------
91 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_DRAG
)
92 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_RDRAG
)
93 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT
)
94 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_END_LABEL_EDIT
)
95 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_DELETE_ITEM
)
96 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS
)
97 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_GET_INFO
)
98 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_SET_INFO
)
99 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_SELECTED
)
100 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_DESELECTED
)
101 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_KEY_DOWN
)
102 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_INSERT_ITEM
)
103 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_CLICK
)
104 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_RIGHT_CLICK
)
105 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_BEGIN_DRAG
)
106 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_DRAGGING
)
107 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_END_DRAG
)
108 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
)
109 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK
)
110 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_ACTIVATED
)
111 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_FOCUSED
)
112 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_CACHE_HINT
)
114 // ----------------------------------------------------------------------------
116 // ----------------------------------------------------------------------------
118 // // the height of the header window (FIXME: should depend on its font!)
119 // static const int HEADER_HEIGHT = 23;
121 static const int SCROLL_UNIT_X
= 15;
123 // the spacing between the lines (in report mode)
124 static const int LINE_SPACING
= 0;
126 // extra margins around the text label
127 static const int EXTRA_WIDTH
= 4;
128 static const int EXTRA_HEIGHT
= 4;
130 // margin between the window and the items
131 static const int EXTRA_BORDER_X
= 2;
132 static const int EXTRA_BORDER_Y
= 2;
134 // offset for the header window
135 static const int HEADER_OFFSET_X
= 1;
136 static const int HEADER_OFFSET_Y
= 1;
138 // margin between rows of icons in [small] icon view
139 static const int MARGIN_BETWEEN_ROWS
= 6;
141 // when autosizing the columns, add some slack
142 static const int AUTOSIZE_COL_MARGIN
= 10;
144 // default and minimal widths for the header columns
145 static const int WIDTH_COL_DEFAULT
= 80;
146 static const int WIDTH_COL_MIN
= 10;
148 // the space between the image and the text in the report mode
149 static const int IMAGE_MARGIN_IN_REPORT_MODE
= 5;
151 // ============================================================================
153 // ============================================================================
155 //-----------------------------------------------------------------------------
156 // wxListItemData (internal)
157 //-----------------------------------------------------------------------------
159 class WXDLLEXPORT wxListItemData
162 wxListItemData(wxListMainWindow
*owner
);
165 void SetItem( const wxListItem
&info
);
166 void SetImage( int image
) { m_image
= image
; }
167 void SetData( long data
) { m_data
= data
; }
168 void SetPosition( int x
, int y
);
169 void SetSize( int width
, int height
);
171 bool HasText() const { return !m_text
.empty(); }
172 const wxString
& GetText() const { return m_text
; }
173 void SetText(const wxString
& text
) { m_text
= text
; }
175 // we can't use empty string for measuring the string width/height, so
176 // always return something
177 wxString
GetTextForMeasuring() const
179 wxString s
= GetText();
186 bool IsHit( int x
, int y
) const;
190 int GetWidth() const;
191 int GetHeight() const;
193 int GetImage() const { return m_image
; }
194 bool HasImage() const { return GetImage() != -1; }
196 void GetItem( wxListItem
&info
) const;
198 void SetAttr(wxListItemAttr
*attr
) { m_attr
= attr
; }
199 wxListItemAttr
*GetAttr() const { return m_attr
; }
202 // the item image or -1
205 // user data associated with the item
208 // the item coordinates are not used in report mode, instead this pointer
209 // is NULL and the owner window is used to retrieve the item position and
213 // the list ctrl we are in
214 wxListMainWindow
*m_owner
;
216 // custom attributes or NULL
217 wxListItemAttr
*m_attr
;
220 // common part of all ctors
226 //-----------------------------------------------------------------------------
227 // wxListHeaderData (internal)
228 //-----------------------------------------------------------------------------
230 class WXDLLEXPORT wxListHeaderData
: public wxObject
234 wxListHeaderData( const wxListItem
&info
);
235 void SetItem( const wxListItem
&item
);
236 void SetPosition( int x
, int y
);
237 void SetWidth( int w
);
238 void SetFormat( int format
);
239 void SetHeight( int h
);
240 bool HasImage() const;
242 bool HasText() const { return !m_text
.empty(); }
243 const wxString
& GetText() const { return m_text
; }
244 void SetText(const wxString
& text
) { m_text
= text
; }
246 void GetItem( wxListItem
&item
);
248 bool IsHit( int x
, int y
) const;
249 int GetImage() const;
250 int GetWidth() const;
251 int GetFormat() const;
267 //-----------------------------------------------------------------------------
268 // wxListLineData (internal)
269 //-----------------------------------------------------------------------------
271 WX_DECLARE_LIST(wxListItemData
, wxListItemDataList
);
272 #include "wx/listimpl.cpp"
273 WX_DEFINE_LIST(wxListItemDataList
);
278 // the list of subitems: only may have more than one item in report mode
279 wxListItemDataList m_items
;
281 // this is not used in report view
293 // the part to be highlighted
294 wxRect m_rectHighlight
;
296 // extend all our rects to be centered inside theo ne of given width
297 void ExtendWidth(wxCoord w
)
299 wxASSERT_MSG( m_rectAll
.width
<= w
,
300 _T("width can only be increased") );
303 m_rectLabel
.x
= m_rectAll
.x
+ (w
- m_rectLabel
.width
)/2;
304 m_rectIcon
.x
= m_rectAll
.x
+ (w
- m_rectIcon
.width
)/2;
305 m_rectHighlight
.x
= m_rectAll
.x
+ (w
- m_rectHighlight
.width
)/2;
309 // is this item selected? [NB: not used in virtual mode]
312 // back pointer to the list ctrl
313 wxListMainWindow
*m_owner
;
316 wxListLineData(wxListMainWindow
*owner
);
320 WX_CLEAR_LIST(wxListItemDataList
, m_items
);
324 // are we in report mode?
325 inline bool InReportView() const;
327 // are we in virtual report mode?
328 inline bool IsVirtual() const;
330 // these 2 methods shouldn't be called for report view controls, in that
331 // case we determine our position/size ourselves
333 // calculate the size of the line
334 void CalculateSize( wxDC
*dc
, int spacing
);
336 // remember the position this line appears at
337 void SetPosition( int x
, int y
, int spacing
);
341 void SetImage( int image
) { SetImage(0, image
); }
342 int GetImage() const { return GetImage(0); }
343 bool HasImage() const { return GetImage() != -1; }
344 bool HasText() const { return !GetText(0).empty(); }
346 void SetItem( int index
, const wxListItem
&info
);
347 void GetItem( int index
, wxListItem
&info
);
349 wxString
GetText(int index
) const;
350 void SetText( int index
, const wxString s
);
352 wxListItemAttr
*GetAttr() const;
353 void SetAttr(wxListItemAttr
*attr
);
355 // return true if the highlighting really changed
356 bool Highlight( bool on
);
358 void ReverseHighlight();
360 bool IsHighlighted() const
362 wxASSERT_MSG( !IsVirtual(), _T("unexpected call to IsHighlighted") );
364 return m_highlighted
;
367 // draw the line on the given DC in icon/list mode
368 void Draw( wxDC
*dc
);
370 // the same in report mode
371 void DrawInReportMode( wxDC
*dc
,
373 const wxRect
& rectHL
,
377 // set the line to contain num items (only can be > 1 in report mode)
378 void InitItems( int num
);
380 // get the mode (i.e. style) of the list control
381 inline int GetMode() const;
383 // prepare the DC for drawing with these item's attributes, return true if
384 // we need to draw the items background to highlight it, false otherwise
385 bool SetAttributes(wxDC
*dc
,
386 const wxListItemAttr
*attr
,
389 // draw the text on the DC with the correct justification; also add an
390 // ellipsis if the text is too large to fit in the current width
391 void DrawTextFormatted(wxDC
*dc
, const wxString
&text
, int col
, int x
, int y
, int width
);
393 // these are only used by GetImage/SetImage above, we don't support images
394 // with subitems at the public API level yet
395 void SetImage( int index
, int image
);
396 int GetImage( int index
) const;
399 WX_DECLARE_EXPORTED_OBJARRAY(wxListLineData
, wxListLineDataArray
);
400 #include "wx/arrimpl.cpp"
401 WX_DEFINE_OBJARRAY(wxListLineDataArray
);
403 //-----------------------------------------------------------------------------
404 // wxListHeaderWindow (internal)
405 //-----------------------------------------------------------------------------
407 class WXDLLEXPORT wxListHeaderWindow
: public wxWindow
410 wxListMainWindow
*m_owner
;
411 wxCursor
*m_currentCursor
;
412 wxCursor
*m_resizeCursor
;
415 // column being resized or -1
418 // divider line position in logical (unscrolled) coords
421 // minimal position beyond which the divider line can't be dragged in
426 wxListHeaderWindow();
428 wxListHeaderWindow( wxWindow
*win
,
430 wxListMainWindow
*owner
,
431 const wxPoint
&pos
= wxDefaultPosition
,
432 const wxSize
&size
= wxDefaultSize
,
434 const wxString
&name
= wxT("wxlistctrlcolumntitles") );
436 virtual ~wxListHeaderWindow();
439 void AdjustDC(wxDC
& dc
);
441 void OnPaint( wxPaintEvent
&event
);
442 void OnMouse( wxMouseEvent
&event
);
443 void OnSetFocus( wxFocusEvent
&event
);
449 // common part of all ctors
452 // generate and process the list event of the given type, return true if
453 // it wasn't vetoed, i.e. if we should proceed
454 bool SendListEvent(wxEventType type
, wxPoint pos
);
456 DECLARE_DYNAMIC_CLASS(wxListHeaderWindow
)
457 DECLARE_EVENT_TABLE()
460 //-----------------------------------------------------------------------------
461 // wxListRenameTimer (internal)
462 //-----------------------------------------------------------------------------
464 class WXDLLEXPORT wxListRenameTimer
: public wxTimer
467 wxListMainWindow
*m_owner
;
470 wxListRenameTimer( wxListMainWindow
*owner
);
474 //-----------------------------------------------------------------------------
475 // wxListTextCtrl (internal)
476 //-----------------------------------------------------------------------------
478 class WXDLLEXPORT wxListTextCtrl
: public wxTextCtrl
481 wxListTextCtrl(wxListMainWindow
*owner
, size_t itemEdit
);
484 void OnChar( wxKeyEvent
&event
);
485 void OnKeyUp( wxKeyEvent
&event
);
486 void OnKillFocus( wxFocusEvent
&event
);
488 bool AcceptChanges();
492 wxListMainWindow
*m_owner
;
493 wxString m_startValue
;
497 DECLARE_EVENT_TABLE()
500 //-----------------------------------------------------------------------------
501 // wxListMainWindow (internal)
502 //-----------------------------------------------------------------------------
504 WX_DECLARE_LIST(wxListHeaderData
, wxListHeaderDataList
);
505 #include "wx/listimpl.cpp"
506 WX_DEFINE_LIST(wxListHeaderDataList
);
508 class wxListMainWindow
: public wxScrolledWindow
512 wxListMainWindow( wxWindow
*parent
,
514 const wxPoint
& pos
= wxDefaultPosition
,
515 const wxSize
& size
= wxDefaultSize
,
517 const wxString
&name
= _T("listctrlmainwindow") );
519 virtual ~wxListMainWindow();
521 bool HasFlag(int flag
) const { return m_parent
->HasFlag(flag
); }
523 // return true if this is a virtual list control
524 bool IsVirtual() const { return HasFlag(wxLC_VIRTUAL
); }
526 // return true if the control is in report mode
527 bool InReportView() const { return HasFlag(wxLC_REPORT
); }
529 // return true if we are in single selection mode, false if multi sel
530 bool IsSingleSel() const { return HasFlag(wxLC_SINGLE_SEL
); }
532 // do we have a header window?
533 bool HasHeader() const
534 { return InReportView() && !HasFlag(wxLC_NO_HEADER
); }
536 void HighlightAll( bool on
);
538 // all these functions only do something if the line is currently visible
540 // change the line "selected" state, return true if it really changed
541 bool HighlightLine( size_t line
, bool highlight
= true);
543 // as HighlightLine() but do it for the range of lines: this is incredibly
544 // more efficient for virtual list controls!
546 // NB: unlike HighlightLine() this one does refresh the lines on screen
547 void HighlightLines( size_t lineFrom
, size_t lineTo
, bool on
= true );
549 // toggle the line state and refresh it
550 void ReverseHighlight( size_t line
)
551 { HighlightLine(line
, !IsHighlighted(line
)); RefreshLine(line
); }
553 // return true if the line is highlighted
554 bool IsHighlighted(size_t line
) const;
556 // refresh one or several lines at once
557 void RefreshLine( size_t line
);
558 void RefreshLines( size_t lineFrom
, size_t lineTo
);
560 // refresh all selected items
561 void RefreshSelected();
563 // refresh all lines below the given one: the difference with
564 // RefreshLines() is that the index here might not be a valid one (happens
565 // when the last line is deleted)
566 void RefreshAfter( size_t lineFrom
);
568 // the methods which are forwarded to wxListLineData itself in list/icon
569 // modes but are here because the lines don't store their positions in the
572 // get the bound rect for the entire line
573 wxRect
GetLineRect(size_t line
) const;
575 // get the bound rect of the label
576 wxRect
GetLineLabelRect(size_t line
) const;
578 // get the bound rect of the items icon (only may be called if we do have
580 wxRect
GetLineIconRect(size_t line
) const;
582 // get the rect to be highlighted when the item has focus
583 wxRect
GetLineHighlightRect(size_t line
) const;
585 // get the size of the total line rect
586 wxSize
GetLineSize(size_t line
) const
587 { return GetLineRect(line
).GetSize(); }
589 // return the hit code for the corresponding position (in this line)
590 long HitTestLine(size_t line
, int x
, int y
) const;
592 // bring the selected item into view, scrolling to it if necessary
593 void MoveToItem(size_t item
);
595 // bring the current item into view
596 void MoveToFocus() { MoveToItem(m_current
); }
598 // start editing the label of the given item
599 void EditLabel( long item
);
601 // suspend/resume redrawing the control
607 void OnRenameTimer();
608 bool OnRenameAccept(size_t itemEdit
, const wxString
& value
);
609 void OnRenameCancelled(size_t itemEdit
);
611 void OnMouse( wxMouseEvent
&event
);
613 // called to switch the selection from the current item to newCurrent,
614 void OnArrowChar( size_t newCurrent
, const wxKeyEvent
& event
);
616 void OnChar( wxKeyEvent
&event
);
617 void OnKeyDown( wxKeyEvent
&event
);
618 void OnSetFocus( wxFocusEvent
&event
);
619 void OnKillFocus( wxFocusEvent
&event
);
620 void OnScroll(wxScrollWinEvent
& event
) ;
622 void OnPaint( wxPaintEvent
&event
);
624 void DrawImage( int index
, wxDC
*dc
, int x
, int y
);
625 void GetImageSize( int index
, int &width
, int &height
) const;
626 int GetTextLength( const wxString
&s
) const;
628 void SetImageList( wxImageListType
*imageList
, int which
);
629 void SetItemSpacing( int spacing
, bool isSmall
= false );
630 int GetItemSpacing( bool isSmall
= false );
632 void SetColumn( int col
, wxListItem
&item
);
633 void SetColumnWidth( int col
, int width
);
634 void GetColumn( int col
, wxListItem
&item
) const;
635 int GetColumnWidth( int col
) const;
636 int GetColumnCount() const { return m_columns
.GetCount(); }
638 // returns the sum of the heights of all columns
639 int GetHeaderWidth() const;
641 int GetCountPerPage() const;
643 void SetItem( wxListItem
&item
);
644 void GetItem( wxListItem
&item
) const;
645 void SetItemState( long item
, long state
, long stateMask
);
646 int GetItemState( long item
, long stateMask
) const;
647 void GetItemRect( long index
, wxRect
&rect
) const;
648 wxRect
GetViewRect() const;
649 bool GetItemPosition( long item
, wxPoint
& pos
) const;
650 int GetSelectedItemCount() const;
652 wxString
GetItemText(long item
) const
655 info
.m_itemId
= item
;
660 void SetItemText(long item
, const wxString
& value
)
663 info
.m_mask
= wxLIST_MASK_TEXT
;
664 info
.m_itemId
= item
;
669 // set the scrollbars and update the positions of the items
670 void RecalculatePositions(bool noRefresh
= false);
672 // refresh the window and the header
675 long GetNextItem( long item
, int geometry
, int state
) const;
676 void DeleteItem( long index
);
677 void DeleteAllItems();
678 void DeleteColumn( int col
);
679 void DeleteEverything();
680 void EnsureVisible( long index
);
681 long FindItem( long start
, const wxString
& str
, bool partial
= false );
682 long FindItem( long start
, long data
);
683 long FindItem( const wxPoint
& pt
);
684 long HitTest( int x
, int y
, int &flags
);
685 void InsertItem( wxListItem
&item
);
686 void InsertColumn( long col
, wxListItem
&item
);
687 void SortItems( wxListCtrlCompare fn
, long data
);
689 size_t GetItemCount() const;
690 bool IsEmpty() const { return GetItemCount() == 0; }
691 void SetItemCount(long count
);
693 // change the current (== focused) item, send a notification event
694 void ChangeCurrent(size_t current
);
695 void ResetCurrent() { ChangeCurrent((size_t)-1); }
696 bool HasCurrent() const { return m_current
!= (size_t)-1; }
698 // send out a wxListEvent
699 void SendNotify( size_t line
,
701 wxPoint point
= wxDefaultPosition
);
703 // override base class virtual to reset m_lineHeight when the font changes
704 virtual bool SetFont(const wxFont
& font
)
706 if ( !wxScrolledWindow::SetFont(font
) )
714 // these are for wxListLineData usage only
716 // get the backpointer to the list ctrl
717 wxGenericListCtrl
*GetListCtrl() const
719 return wxStaticCast(GetParent(), wxGenericListCtrl
);
722 // get the height of all lines (assuming they all do have the same height)
723 wxCoord
GetLineHeight() const;
725 // get the y position of the given line (only for report view)
726 wxCoord
GetLineY(size_t line
) const;
728 // get the brush to use for the item highlighting
729 wxBrush
*GetHighlightBrush() const
731 return m_hasFocus
? m_highlightBrush
: m_highlightUnfocusedBrush
;
735 // the array of all line objects for a non virtual list control (for the
736 // virtual list control we only ever use m_lines[0])
737 wxListLineDataArray m_lines
;
739 // the list of column objects
740 wxListHeaderDataList m_columns
;
742 // currently focused item or -1
745 // the number of lines per page
748 // this flag is set when something which should result in the window
749 // redrawing happens (i.e. an item was added or deleted, or its appearance
750 // changed) and OnPaint() doesn't redraw the window while it is set which
751 // allows to minimize the number of repaintings when a lot of items are
752 // being added. The real repainting occurs only after the next OnIdle()
756 wxColour
*m_highlightColour
;
757 wxImageListType
*m_small_image_list
;
758 wxImageListType
*m_normal_image_list
;
760 int m_normal_spacing
;
764 wxTimer
*m_renameTimer
;
769 // for double click logic
770 size_t m_lineLastClicked
,
771 m_lineBeforeLastClicked
;
774 // the total count of items in a virtual list control
777 // the object maintaining the items selection state, only used in virtual
779 wxSelectionStore m_selStore
;
781 // common part of all ctors
784 // get the line data for the given index
785 wxListLineData
*GetLine(size_t n
) const
787 wxASSERT_MSG( n
!= (size_t)-1, _T("invalid line index") );
791 wxConstCast(this, wxListMainWindow
)->CacheLineData(n
);
799 // get a dummy line which can be used for geometry calculations and such:
800 // you must use GetLine() if you want to really draw the line
801 wxListLineData
*GetDummyLine() const;
803 // cache the line data of the n-th line in m_lines[0]
804 void CacheLineData(size_t line
);
806 // get the range of visible lines
807 void GetVisibleLinesRange(size_t *from
, size_t *to
);
809 // force us to recalculate the range of visible lines
810 void ResetVisibleLinesRange() { m_lineFrom
= (size_t)-1; }
812 // get the colour to be used for drawing the rules
813 wxColour
GetRuleColour() const
818 return wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT
);
823 // initialize the current item if needed
824 void UpdateCurrent();
826 // delete all items but don't refresh: called from dtor
827 void DoDeleteAllItems();
829 // the height of one line using the current font
830 wxCoord m_lineHeight
;
832 // the total header width or 0 if not calculated yet
833 wxCoord m_headerWidth
;
835 // the first and last lines being shown on screen right now (inclusive),
836 // both may be -1 if they must be calculated so never access them directly:
837 // use GetVisibleLinesRange() above instead
841 // the brushes to use for item highlighting when we do/don't have focus
842 wxBrush
*m_highlightBrush
,
843 *m_highlightUnfocusedBrush
;
845 // if this is > 0, the control is frozen and doesn't redraw itself
846 size_t m_freezeCount
;
848 DECLARE_DYNAMIC_CLASS(wxListMainWindow
)
849 DECLARE_EVENT_TABLE()
851 friend class wxGenericListCtrl
;
854 // ============================================================================
856 // ============================================================================
858 //-----------------------------------------------------------------------------
860 //-----------------------------------------------------------------------------
862 wxListItemData::~wxListItemData()
864 // in the virtual list control the attributes are managed by the main
865 // program, so don't delete them
866 if ( !m_owner
->IsVirtual() )
874 void wxListItemData::Init()
882 wxListItemData::wxListItemData(wxListMainWindow
*owner
)
888 if ( owner
->InReportView() )
898 void wxListItemData::SetItem( const wxListItem
&info
)
900 if ( info
.m_mask
& wxLIST_MASK_TEXT
)
901 SetText(info
.m_text
);
902 if ( info
.m_mask
& wxLIST_MASK_IMAGE
)
903 m_image
= info
.m_image
;
904 if ( info
.m_mask
& wxLIST_MASK_DATA
)
905 m_data
= info
.m_data
;
907 if ( info
.HasAttributes() )
910 *m_attr
= *info
.GetAttributes();
912 m_attr
= new wxListItemAttr(*info
.GetAttributes());
920 m_rect
->width
= info
.m_width
;
924 void wxListItemData::SetPosition( int x
, int y
)
926 wxCHECK_RET( m_rect
, _T("unexpected SetPosition() call") );
932 void wxListItemData::SetSize( int width
, int height
)
934 wxCHECK_RET( m_rect
, _T("unexpected SetSize() call") );
937 m_rect
->width
= width
;
939 m_rect
->height
= height
;
942 bool wxListItemData::IsHit( int x
, int y
) const
944 wxCHECK_MSG( m_rect
, false, _T("can't be called in this mode") );
946 return wxRect(GetX(), GetY(), GetWidth(), GetHeight()).Inside(x
, y
);
949 int wxListItemData::GetX() const
951 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
956 int wxListItemData::GetY() const
958 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
963 int wxListItemData::GetWidth() const
965 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
967 return m_rect
->width
;
970 int wxListItemData::GetHeight() const
972 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
974 return m_rect
->height
;
977 void wxListItemData::GetItem( wxListItem
&info
) const
979 info
.m_text
= m_text
;
980 info
.m_image
= m_image
;
981 info
.m_data
= m_data
;
985 if ( m_attr
->HasTextColour() )
986 info
.SetTextColour(m_attr
->GetTextColour());
987 if ( m_attr
->HasBackgroundColour() )
988 info
.SetBackgroundColour(m_attr
->GetBackgroundColour());
989 if ( m_attr
->HasFont() )
990 info
.SetFont(m_attr
->GetFont());
994 //-----------------------------------------------------------------------------
996 //-----------------------------------------------------------------------------
998 void wxListHeaderData::Init()
1009 wxListHeaderData::wxListHeaderData()
1014 wxListHeaderData::wxListHeaderData( const wxListItem
&item
)
1021 void wxListHeaderData::SetItem( const wxListItem
&item
)
1023 m_mask
= item
.m_mask
;
1025 if ( m_mask
& wxLIST_MASK_TEXT
)
1026 m_text
= item
.m_text
;
1028 if ( m_mask
& wxLIST_MASK_IMAGE
)
1029 m_image
= item
.m_image
;
1031 if ( m_mask
& wxLIST_MASK_FORMAT
)
1032 m_format
= item
.m_format
;
1034 if ( m_mask
& wxLIST_MASK_WIDTH
)
1035 SetWidth(item
.m_width
);
1038 void wxListHeaderData::SetPosition( int x
, int y
)
1044 void wxListHeaderData::SetHeight( int h
)
1049 void wxListHeaderData::SetWidth( int w
)
1053 m_width
= WIDTH_COL_DEFAULT
;
1054 else if (m_width
< WIDTH_COL_MIN
)
1055 m_width
= WIDTH_COL_MIN
;
1058 void wxListHeaderData::SetFormat( int format
)
1063 bool wxListHeaderData::HasImage() const
1065 return m_image
!= -1;
1068 bool wxListHeaderData::IsHit( int x
, int y
) const
1070 return ((x
>= m_xpos
) && (x
<= m_xpos
+m_width
) && (y
>= m_ypos
) && (y
<= m_ypos
+m_height
));
1073 void wxListHeaderData::GetItem( wxListItem
& item
)
1075 item
.m_mask
= m_mask
;
1076 item
.m_text
= m_text
;
1077 item
.m_image
= m_image
;
1078 item
.m_format
= m_format
;
1079 item
.m_width
= m_width
;
1082 int wxListHeaderData::GetImage() const
1087 int wxListHeaderData::GetWidth() const
1092 int wxListHeaderData::GetFormat() const
1097 //-----------------------------------------------------------------------------
1099 //-----------------------------------------------------------------------------
1101 inline int wxListLineData::GetMode() const
1103 return m_owner
->GetListCtrl()->GetWindowStyleFlag() & wxLC_MASK_TYPE
;
1106 inline bool wxListLineData::InReportView() const
1108 return m_owner
->HasFlag(wxLC_REPORT
);
1111 inline bool wxListLineData::IsVirtual() const
1113 return m_owner
->IsVirtual();
1116 wxListLineData::wxListLineData( wxListMainWindow
*owner
)
1120 if ( InReportView() )
1126 m_gi
= new GeometryInfo
;
1129 m_highlighted
= false;
1131 InitItems( GetMode() == wxLC_REPORT
? m_owner
->GetColumnCount() : 1 );
1134 void wxListLineData::CalculateSize( wxDC
*dc
, int spacing
)
1136 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1137 wxCHECK_RET( node
, _T("no subitems at all??") );
1139 wxListItemData
*item
= node
->GetData();
1144 switch ( GetMode() )
1147 case wxLC_SMALL_ICON
:
1148 m_gi
->m_rectAll
.width
= spacing
;
1150 s
= item
->GetText();
1155 m_gi
->m_rectLabel
.width
=
1156 m_gi
->m_rectLabel
.height
= 0;
1160 dc
->GetTextExtent( s
, &lw
, &lh
);
1164 m_gi
->m_rectAll
.height
= spacing
+ lh
;
1166 m_gi
->m_rectAll
.width
= lw
;
1168 m_gi
->m_rectLabel
.width
= lw
;
1169 m_gi
->m_rectLabel
.height
= lh
;
1172 if (item
->HasImage())
1175 m_owner
->GetImageSize( item
->GetImage(), w
, h
);
1176 m_gi
->m_rectIcon
.width
= w
+ 8;
1177 m_gi
->m_rectIcon
.height
= h
+ 8;
1179 if ( m_gi
->m_rectIcon
.width
> m_gi
->m_rectAll
.width
)
1180 m_gi
->m_rectAll
.width
= m_gi
->m_rectIcon
.width
;
1181 if ( m_gi
->m_rectIcon
.height
+ lh
> m_gi
->m_rectAll
.height
- 4 )
1182 m_gi
->m_rectAll
.height
= m_gi
->m_rectIcon
.height
+ lh
+ 4;
1185 if ( item
->HasText() )
1187 m_gi
->m_rectHighlight
.width
= m_gi
->m_rectLabel
.width
;
1188 m_gi
->m_rectHighlight
.height
= m_gi
->m_rectLabel
.height
;
1190 else // no text, highlight the icon
1192 m_gi
->m_rectHighlight
.width
= m_gi
->m_rectIcon
.width
;
1193 m_gi
->m_rectHighlight
.height
= m_gi
->m_rectIcon
.height
;
1198 s
= item
->GetTextForMeasuring();
1200 dc
->GetTextExtent( s
, &lw
, &lh
);
1204 m_gi
->m_rectLabel
.width
= lw
;
1205 m_gi
->m_rectLabel
.height
= lh
;
1207 m_gi
->m_rectAll
.width
= lw
;
1208 m_gi
->m_rectAll
.height
= lh
;
1210 if (item
->HasImage())
1213 m_owner
->GetImageSize( item
->GetImage(), w
, h
);
1214 m_gi
->m_rectIcon
.width
= w
;
1215 m_gi
->m_rectIcon
.height
= h
;
1217 m_gi
->m_rectAll
.width
+= 4 + w
;
1218 if (h
> m_gi
->m_rectAll
.height
)
1219 m_gi
->m_rectAll
.height
= h
;
1222 m_gi
->m_rectHighlight
.width
= m_gi
->m_rectAll
.width
;
1223 m_gi
->m_rectHighlight
.height
= m_gi
->m_rectAll
.height
;
1227 wxFAIL_MSG( _T("unexpected call to SetSize") );
1231 wxFAIL_MSG( _T("unknown mode") );
1235 void wxListLineData::SetPosition( int x
, int y
, int spacing
)
1237 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1238 wxCHECK_RET( node
, _T("no subitems at all??") );
1240 wxListItemData
*item
= node
->GetData();
1242 switch ( GetMode() )
1245 case wxLC_SMALL_ICON
:
1246 m_gi
->m_rectAll
.x
= x
;
1247 m_gi
->m_rectAll
.y
= y
;
1249 if ( item
->HasImage() )
1251 m_gi
->m_rectIcon
.x
= m_gi
->m_rectAll
.x
+ 4 +
1252 (m_gi
->m_rectAll
.width
- m_gi
->m_rectIcon
.width
) / 2;
1253 m_gi
->m_rectIcon
.y
= m_gi
->m_rectAll
.y
+ 4;
1256 if ( item
->HasText() )
1258 if (m_gi
->m_rectAll
.width
> spacing
)
1259 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ 2;
1261 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ 2 + (spacing
/2) - (m_gi
->m_rectLabel
.width
/2);
1262 m_gi
->m_rectLabel
.y
= m_gi
->m_rectAll
.y
+ m_gi
->m_rectAll
.height
+ 2 - m_gi
->m_rectLabel
.height
;
1263 m_gi
->m_rectHighlight
.x
= m_gi
->m_rectLabel
.x
- 2;
1264 m_gi
->m_rectHighlight
.y
= m_gi
->m_rectLabel
.y
- 2;
1266 else // no text, highlight the icon
1268 m_gi
->m_rectHighlight
.x
= m_gi
->m_rectIcon
.x
- 4;
1269 m_gi
->m_rectHighlight
.y
= m_gi
->m_rectIcon
.y
- 4;
1274 m_gi
->m_rectAll
.x
= x
;
1275 m_gi
->m_rectAll
.y
= y
;
1277 m_gi
->m_rectHighlight
.x
= m_gi
->m_rectAll
.x
;
1278 m_gi
->m_rectHighlight
.y
= m_gi
->m_rectAll
.y
;
1279 m_gi
->m_rectLabel
.y
= m_gi
->m_rectAll
.y
+ 2;
1281 if (item
->HasImage())
1283 m_gi
->m_rectIcon
.x
= m_gi
->m_rectAll
.x
+ 2;
1284 m_gi
->m_rectIcon
.y
= m_gi
->m_rectAll
.y
+ 2;
1285 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ 6 + m_gi
->m_rectIcon
.width
;
1289 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ 2;
1294 wxFAIL_MSG( _T("unexpected call to SetPosition") );
1298 wxFAIL_MSG( _T("unknown mode") );
1302 void wxListLineData::InitItems( int num
)
1304 for (int i
= 0; i
< num
; i
++)
1305 m_items
.Append( new wxListItemData(m_owner
) );
1308 void wxListLineData::SetItem( int index
, const wxListItem
&info
)
1310 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1311 wxCHECK_RET( node
, _T("invalid column index in SetItem") );
1313 wxListItemData
*item
= node
->GetData();
1314 item
->SetItem( info
);
1317 void wxListLineData::GetItem( int index
, wxListItem
&info
)
1319 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1322 wxListItemData
*item
= node
->GetData();
1323 item
->GetItem( info
);
1327 wxString
wxListLineData::GetText(int index
) const
1331 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1334 wxListItemData
*item
= node
->GetData();
1335 s
= item
->GetText();
1341 void wxListLineData::SetText( int index
, const wxString s
)
1343 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1346 wxListItemData
*item
= node
->GetData();
1351 void wxListLineData::SetImage( int index
, int image
)
1353 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1354 wxCHECK_RET( node
, _T("invalid column index in SetImage()") );
1356 wxListItemData
*item
= node
->GetData();
1357 item
->SetImage(image
);
1360 int wxListLineData::GetImage( int index
) const
1362 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1363 wxCHECK_MSG( node
, -1, _T("invalid column index in GetImage()") );
1365 wxListItemData
*item
= node
->GetData();
1366 return item
->GetImage();
1369 wxListItemAttr
*wxListLineData::GetAttr() const
1371 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1372 wxCHECK_MSG( node
, NULL
, _T("invalid column index in GetAttr()") );
1374 wxListItemData
*item
= node
->GetData();
1375 return item
->GetAttr();
1378 void wxListLineData::SetAttr(wxListItemAttr
*attr
)
1380 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1381 wxCHECK_RET( node
, _T("invalid column index in SetAttr()") );
1383 wxListItemData
*item
= node
->GetData();
1384 item
->SetAttr(attr
);
1387 bool wxListLineData::SetAttributes(wxDC
*dc
,
1388 const wxListItemAttr
*attr
,
1391 wxWindow
*listctrl
= m_owner
->GetParent();
1395 // don't use foreground colour for drawing highlighted items - this might
1396 // make them completely invisible (and there is no way to do bit
1397 // arithmetics on wxColour, unfortunately)
1401 colText
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
);
1405 if ( attr
&& attr
->HasTextColour() )
1407 colText
= attr
->GetTextColour();
1411 colText
= listctrl
->GetForegroundColour();
1415 dc
->SetTextForeground(colText
);
1419 if ( attr
&& attr
->HasFont() )
1421 font
= attr
->GetFont();
1425 font
= listctrl
->GetFont();
1431 bool hasBgCol
= attr
&& attr
->HasBackgroundColour();
1432 if ( highlighted
|| hasBgCol
)
1436 dc
->SetBrush( *m_owner
->GetHighlightBrush() );
1440 dc
->SetBrush(wxBrush(attr
->GetBackgroundColour(), wxSOLID
));
1443 dc
->SetPen( *wxTRANSPARENT_PEN
);
1451 void wxListLineData::Draw( wxDC
*dc
)
1453 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1454 wxCHECK_RET( node
, _T("no subitems at all??") );
1456 bool highlighted
= IsHighlighted();
1458 wxListItemAttr
*attr
= GetAttr();
1460 if ( SetAttributes(dc
, attr
, highlighted
) )
1462 dc
->DrawRectangle( m_gi
->m_rectHighlight
);
1465 // just for debugging to better see where the items are
1467 dc
->SetPen(*wxRED_PEN
);
1468 dc
->SetBrush(*wxTRANSPARENT_BRUSH
);
1469 dc
->DrawRectangle( m_gi
->m_rectAll
);
1470 dc
->SetPen(*wxGREEN_PEN
);
1471 dc
->DrawRectangle( m_gi
->m_rectIcon
);
1474 wxListItemData
*item
= node
->GetData();
1475 if (item
->HasImage())
1477 // centre the image inside our rectangle, this looks nicer when items
1478 // ae aligned in a row
1479 const wxRect
& rectIcon
= m_gi
->m_rectIcon
;
1481 m_owner
->DrawImage(item
->GetImage(), dc
, rectIcon
.x
, rectIcon
.y
);
1484 if (item
->HasText())
1486 const wxRect
& rectLabel
= m_gi
->m_rectLabel
;
1488 wxDCClipper
clipper(*dc
, rectLabel
);
1489 dc
->DrawText(item
->GetText(), rectLabel
.x
, rectLabel
.y
);
1493 void wxListLineData::DrawInReportMode( wxDC
*dc
,
1495 const wxRect
& rectHL
,
1498 // TODO: later we should support setting different attributes for
1499 // different columns - to do it, just add "col" argument to
1500 // GetAttr() and move these lines into the loop below
1501 wxListItemAttr
*attr
= GetAttr();
1502 if ( SetAttributes(dc
, attr
, highlighted
) )
1504 dc
->DrawRectangle( rectHL
);
1507 wxCoord x
= rect
.x
+ HEADER_OFFSET_X
,
1508 y
= rect
.y
+ (LINE_SPACING
+ EXTRA_HEIGHT
) / 2;
1511 for ( wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1513 node
= node
->GetNext(), col
++ )
1515 wxListItemData
*item
= node
->GetData();
1517 int width
= m_owner
->GetColumnWidth(col
);
1521 if ( item
->HasImage() )
1524 m_owner
->DrawImage( item
->GetImage(), dc
, xOld
, y
);
1525 m_owner
->GetImageSize( item
->GetImage(), ix
, iy
);
1527 ix
+= IMAGE_MARGIN_IN_REPORT_MODE
;
1533 wxDCClipper
clipper(*dc
, xOld
, y
, width
- 8, rect
.height
);
1535 if ( item
->HasText() )
1537 DrawTextFormatted(dc
, item
->GetText(), col
, xOld
, y
, width
- 8);
1542 void wxListLineData::DrawTextFormatted(wxDC
*dc
,
1543 const wxString
&text
,
1549 wxString drawntext
, ellipsis
;
1550 wxCoord w
, h
, base_w
;
1553 // determine if the string can fit inside the current width
1554 dc
->GetTextExtent(text
, &w
, &h
);
1557 // it can, draw it using the items alignment
1558 m_owner
->GetColumn(col
, item
);
1559 switch ( item
.GetAlign() )
1562 wxFAIL_MSG( _T("unknown list item format") );
1565 case wxLIST_FORMAT_LEFT
:
1569 case wxLIST_FORMAT_RIGHT
:
1573 case wxLIST_FORMAT_CENTER
:
1574 x
+= (width
- w
) / 2;
1578 dc
->DrawText(text
, x
, y
);
1580 else // otherwise, truncate and add an ellipsis if possible
1582 // determine the base width
1583 ellipsis
= wxString(wxT("..."));
1584 dc
->GetTextExtent(ellipsis
, &base_w
, &h
);
1586 // continue until we have enough space or only one character left
1588 size_t len
= text
.Length();
1589 drawntext
= text
.Left(len
);
1592 dc
->GetTextExtent(drawntext
.Last(), &w_c
, &h_c
);
1593 drawntext
.RemoveLast();
1596 if (w
+ base_w
<= width
)
1600 // if still not enough space, remove ellipsis characters
1601 while (ellipsis
.Length() > 0 && w
+ base_w
> width
)
1603 ellipsis
= ellipsis
.Left(ellipsis
.Length() - 1);
1604 dc
->GetTextExtent(ellipsis
, &base_w
, &h
);
1607 // now draw the text
1608 dc
->DrawText(drawntext
, x
, y
);
1609 dc
->DrawText(ellipsis
, x
+ w
, y
);
1613 bool wxListLineData::Highlight( bool on
)
1615 wxCHECK_MSG( !IsVirtual(), false, _T("unexpected call to Highlight") );
1617 if ( on
== m_highlighted
)
1625 void wxListLineData::ReverseHighlight( void )
1627 Highlight(!IsHighlighted());
1630 //-----------------------------------------------------------------------------
1631 // wxListHeaderWindow
1632 //-----------------------------------------------------------------------------
1634 IMPLEMENT_DYNAMIC_CLASS(wxListHeaderWindow
,wxWindow
)
1636 BEGIN_EVENT_TABLE(wxListHeaderWindow
,wxWindow
)
1637 EVT_PAINT (wxListHeaderWindow::OnPaint
)
1638 EVT_MOUSE_EVENTS (wxListHeaderWindow::OnMouse
)
1639 EVT_SET_FOCUS (wxListHeaderWindow::OnSetFocus
)
1642 void wxListHeaderWindow::Init()
1644 m_currentCursor
= (wxCursor
*) NULL
;
1645 m_isDragging
= false;
1649 wxListHeaderWindow::wxListHeaderWindow()
1653 m_owner
= (wxListMainWindow
*) NULL
;
1654 m_resizeCursor
= (wxCursor
*) NULL
;
1657 wxListHeaderWindow::wxListHeaderWindow( wxWindow
*win
,
1659 wxListMainWindow
*owner
,
1663 const wxString
&name
)
1664 : wxWindow( win
, id
, pos
, size
, style
, name
)
1669 m_resizeCursor
= new wxCursor( wxCURSOR_SIZEWE
);
1672 wxVisualAttributes attr
= wxPanel::GetClassDefaultAttributes();
1673 SetOwnForegroundColour( attr
.colFg
);
1674 SetOwnBackgroundColour( attr
.colBg
);
1676 SetOwnFont( attr
.font
);
1678 SetOwnForegroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
));
1679 SetOwnBackgroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
));
1681 SetOwnFont( wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
));
1685 wxListHeaderWindow::~wxListHeaderWindow()
1687 delete m_resizeCursor
;
1690 #ifdef __WXUNIVERSAL__
1691 #include "wx/univ/renderer.h"
1692 #include "wx/univ/theme.h"
1695 // shift the DC origin to match the position of the main window horz
1696 // scrollbar: this allows us to always use logical coords
1697 void wxListHeaderWindow::AdjustDC(wxDC
& dc
)
1700 m_owner
->GetScrollPixelsPerUnit( &xpix
, NULL
);
1703 m_owner
->GetViewStart( &x
, NULL
);
1705 // account for the horz scrollbar offset
1706 dc
.SetDeviceOrigin( -x
* xpix
, 0 );
1709 void wxListHeaderWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
1711 wxPaintDC
dc( this );
1718 dc
.SetFont( GetFont() );
1720 // width and height of the entire header window
1722 GetClientSize( &w
, &h
);
1723 m_owner
->CalcUnscrolledPosition(w
, 0, &w
, NULL
);
1725 dc
.SetBackgroundMode(wxTRANSPARENT
);
1727 dc
.SetTextForeground(GetForegroundColour());
1729 int x
= HEADER_OFFSET_X
;
1731 int numColumns
= m_owner
->GetColumnCount();
1733 for ( int i
= 0; i
< numColumns
&& x
< w
; i
++ )
1735 m_owner
->GetColumn( i
, item
);
1736 int wCol
= item
.m_width
;
1738 // the width of the rect to draw: make it smaller to fit entirely
1739 // inside the column rect
1742 wxRendererNative::Get().DrawHeaderButton
1746 wxRect(x
, HEADER_OFFSET_Y
, cw
, h
- 2),
1747 m_parent
->IsEnabled() ? 0
1748 : wxCONTROL_DISABLED
1751 // see if we have enough space for the column label
1753 // for this we need the width of the text
1756 dc
.GetTextExtent(item
.GetText(), &wLabel
, &hLabel
);
1757 wLabel
+= 2*EXTRA_WIDTH
;
1759 // and the width of the icon, if any
1760 static const int MARGIN_BETWEEN_TEXT_AND_ICON
= 2;
1761 int ix
= 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;
1801 // if we have an image, draw it on the right of the label
1808 xAligned
+ wLabel
- ix
- MARGIN_BETWEEN_TEXT_AND_ICON
,
1809 HEADER_OFFSET_Y
+ (h
- 4 - iy
)/2,
1810 wxIMAGELIST_DRAW_TRANSPARENT
1813 cw
-= ix
+ MARGIN_BETWEEN_TEXT_AND_ICON
;
1816 // draw the text clipping it so that it doesn't overwrite the column
1818 wxDCClipper
clipper(dc
, x
, HEADER_OFFSET_Y
, cw
, h
- 4 );
1820 dc
.DrawText( item
.GetText(),
1821 xAligned
+ EXTRA_WIDTH
, h
/ 2 - hLabel
/ 2 ); //HEADER_OFFSET_Y + EXTRA_HEIGHT );
1829 void wxListHeaderWindow::DrawCurrent()
1831 int x1
= m_currentX
;
1833 m_owner
->ClientToScreen( &x1
, &y1
);
1835 int x2
= m_currentX
;
1837 m_owner
->GetClientSize( NULL
, &y2
);
1838 m_owner
->ClientToScreen( &x2
, &y2
);
1841 dc
.SetLogicalFunction( wxINVERT
);
1842 dc
.SetPen( wxPen( *wxBLACK
, 2, wxSOLID
) );
1843 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
1847 dc
.DrawLine( x1
, y1
, x2
, y2
);
1849 dc
.SetLogicalFunction( wxCOPY
);
1851 dc
.SetPen( wxNullPen
);
1852 dc
.SetBrush( wxNullBrush
);
1855 void wxListHeaderWindow::OnMouse( wxMouseEvent
&event
)
1857 // we want to work with logical coords
1859 m_owner
->CalcUnscrolledPosition(event
.GetX(), 0, &x
, NULL
);
1860 int y
= event
.GetY();
1864 SendListEvent(wxEVT_COMMAND_LIST_COL_DRAGGING
, event
.GetPosition());
1866 // we don't draw the line beyond our window, but we allow dragging it
1869 GetClientSize( &w
, NULL
);
1870 m_owner
->CalcUnscrolledPosition(w
, 0, &w
, NULL
);
1873 // erase the line if it was drawn
1874 if ( m_currentX
< w
)
1877 if (event
.ButtonUp())
1880 m_isDragging
= false;
1882 m_owner
->SetColumnWidth( m_column
, m_currentX
- m_minX
);
1883 SendListEvent(wxEVT_COMMAND_LIST_COL_END_DRAG
, event
.GetPosition());
1890 m_currentX
= m_minX
+ 7;
1892 // draw in the new location
1893 if ( m_currentX
< w
)
1897 else // not dragging
1900 bool hit_border
= false;
1902 // end of the current column
1905 // find the column where this event occured
1907 countCol
= m_owner
->GetColumnCount();
1908 for (col
= 0; col
< countCol
; col
++)
1910 xpos
+= m_owner
->GetColumnWidth( col
);
1913 if ( (abs(x
-xpos
) < 3) && (y
< 22) )
1915 // near the column border
1922 // inside the column
1929 if ( col
== countCol
)
1932 if (event
.LeftDown() || event
.RightUp())
1934 if (hit_border
&& event
.LeftDown())
1936 if ( SendListEvent(wxEVT_COMMAND_LIST_COL_BEGIN_DRAG
,
1937 event
.GetPosition()) )
1939 m_isDragging
= true;
1944 //else: column resizing was vetoed by the user code
1946 else // click on a column
1948 SendListEvent( event
.LeftDown()
1949 ? wxEVT_COMMAND_LIST_COL_CLICK
1950 : wxEVT_COMMAND_LIST_COL_RIGHT_CLICK
,
1951 event
.GetPosition());
1954 else if (event
.Moving())
1959 setCursor
= m_currentCursor
== wxSTANDARD_CURSOR
;
1960 m_currentCursor
= m_resizeCursor
;
1964 setCursor
= m_currentCursor
!= wxSTANDARD_CURSOR
;
1965 m_currentCursor
= wxSTANDARD_CURSOR
;
1969 SetCursor(*m_currentCursor
);
1974 void wxListHeaderWindow::OnSetFocus( wxFocusEvent
&WXUNUSED(event
) )
1976 m_owner
->SetFocus();
1980 bool wxListHeaderWindow::SendListEvent(wxEventType type
, wxPoint pos
)
1982 wxWindow
*parent
= GetParent();
1983 wxListEvent
le( type
, parent
->GetId() );
1984 le
.SetEventObject( parent
);
1985 le
.m_pointDrag
= pos
;
1987 // the position should be relative to the parent window, not
1988 // this one for compatibility with MSW and common sense: the
1989 // user code doesn't know anything at all about this header
1990 // window, so why should it get positions relative to it?
1991 le
.m_pointDrag
.y
-= GetSize().y
;
1993 le
.m_col
= m_column
;
1994 return !parent
->GetEventHandler()->ProcessEvent( le
) || le
.IsAllowed();
1997 //-----------------------------------------------------------------------------
1998 // wxListRenameTimer (internal)
1999 //-----------------------------------------------------------------------------
2001 wxListRenameTimer::wxListRenameTimer( wxListMainWindow
*owner
)
2006 void wxListRenameTimer::Notify()
2008 m_owner
->OnRenameTimer();
2011 //-----------------------------------------------------------------------------
2012 // wxListTextCtrl (internal)
2013 //-----------------------------------------------------------------------------
2015 BEGIN_EVENT_TABLE(wxListTextCtrl
,wxTextCtrl
)
2016 EVT_CHAR (wxListTextCtrl::OnChar
)
2017 EVT_KEY_UP (wxListTextCtrl::OnKeyUp
)
2018 EVT_KILL_FOCUS (wxListTextCtrl::OnKillFocus
)
2021 wxListTextCtrl::wxListTextCtrl(wxListMainWindow
*owner
, size_t itemEdit
)
2022 : m_startValue(owner
->GetItemText(itemEdit
)),
2023 m_itemEdited(itemEdit
)
2028 wxRect rectLabel
= owner
->GetLineLabelRect(itemEdit
);
2030 m_owner
->CalcScrolledPosition(rectLabel
.x
, rectLabel
.y
,
2031 &rectLabel
.x
, &rectLabel
.y
);
2033 (void)Create(owner
, wxID_ANY
, m_startValue
,
2034 wxPoint(rectLabel
.x
-4,rectLabel
.y
-4),
2035 wxSize(rectLabel
.width
+11,rectLabel
.height
+8));
2038 void wxListTextCtrl::Finish()
2042 wxPendingDelete
.Append(this);
2046 m_owner
->SetFocus();
2050 bool wxListTextCtrl::AcceptChanges()
2052 const wxString value
= GetValue();
2054 if ( value
== m_startValue
)
2056 // nothing changed, always accept
2060 if ( !m_owner
->OnRenameAccept(m_itemEdited
, value
) )
2062 // vetoed by the user
2066 // accepted, do rename the item
2067 m_owner
->SetItemText(m_itemEdited
, value
);
2072 void wxListTextCtrl::OnChar( wxKeyEvent
&event
)
2074 switch ( event
.m_keyCode
)
2077 if ( AcceptChanges() )
2079 // Close the text control, changes were accepted
2082 // else do nothing, do not accept and do not close
2088 m_owner
->OnRenameCancelled( m_itemEdited
);
2096 void wxListTextCtrl::OnKeyUp( wxKeyEvent
&event
)
2104 // auto-grow the textctrl:
2105 wxSize parentSize
= m_owner
->GetSize();
2106 wxPoint myPos
= GetPosition();
2107 wxSize mySize
= GetSize();
2109 GetTextExtent(GetValue() + _T("MM"), &sx
, &sy
);
2110 if (myPos
.x
+ sx
> parentSize
.x
)
2111 sx
= parentSize
.x
- myPos
.x
;
2114 SetSize(sx
, wxDefaultCoord
);
2119 void wxListTextCtrl::OnKillFocus( wxFocusEvent
&event
)
2123 // We must finish regardless of success, otherwise we'll get
2127 if ( !AcceptChanges() )
2128 m_owner
->OnRenameCancelled( m_itemEdited
);
2131 // We must let the native text control handle focus, too, otherwise
2132 // it could have problems with the cursor (e.g., in wxGTK):
2136 //-----------------------------------------------------------------------------
2138 //-----------------------------------------------------------------------------
2140 IMPLEMENT_DYNAMIC_CLASS(wxListMainWindow
,wxScrolledWindow
)
2142 BEGIN_EVENT_TABLE(wxListMainWindow
,wxScrolledWindow
)
2143 EVT_PAINT (wxListMainWindow::OnPaint
)
2144 EVT_MOUSE_EVENTS (wxListMainWindow::OnMouse
)
2145 EVT_CHAR (wxListMainWindow::OnChar
)
2146 EVT_KEY_DOWN (wxListMainWindow::OnKeyDown
)
2147 EVT_SET_FOCUS (wxListMainWindow::OnSetFocus
)
2148 EVT_KILL_FOCUS (wxListMainWindow::OnKillFocus
)
2149 EVT_SCROLLWIN (wxListMainWindow::OnScroll
)
2152 void wxListMainWindow::Init()
2157 m_lineTo
= (size_t)-1;
2163 m_small_image_list
= (wxImageListType
*) NULL
;
2164 m_normal_image_list
= (wxImageListType
*) NULL
;
2166 m_small_spacing
= 30;
2167 m_normal_spacing
= 40;
2171 m_isCreated
= false;
2173 m_lastOnSame
= false;
2174 m_renameTimer
= new wxListRenameTimer( this );
2178 m_lineBeforeLastClicked
= (size_t)-1;
2183 wxListMainWindow::wxListMainWindow()
2188 m_highlightUnfocusedBrush
= (wxBrush
*) NULL
;
2191 wxListMainWindow::wxListMainWindow( wxWindow
*parent
,
2196 const wxString
&name
)
2197 : wxScrolledWindow( parent
, id
, pos
, size
,
2198 style
| wxHSCROLL
| wxVSCROLL
, name
)
2202 m_highlightBrush
= new wxBrush
2204 wxSystemSettings::GetColour
2206 wxSYS_COLOUR_HIGHLIGHT
2211 m_highlightUnfocusedBrush
= new wxBrush
2213 wxSystemSettings::GetColour
2215 wxSYS_COLOUR_BTNSHADOW
2223 SetScrollbars( 0, 0, 0, 0, 0, 0 );
2225 wxVisualAttributes attr
= wxGenericListCtrl::GetClassDefaultAttributes();
2226 SetOwnForegroundColour( attr
.colFg
);
2227 SetOwnBackgroundColour( attr
.colBg
);
2229 SetOwnFont( attr
.font
);
2232 wxListMainWindow::~wxListMainWindow()
2235 WX_CLEAR_LIST(wxListHeaderDataList
, m_columns
);
2237 delete m_highlightBrush
;
2238 delete m_highlightUnfocusedBrush
;
2240 delete m_renameTimer
;
2243 void wxListMainWindow::CacheLineData(size_t line
)
2245 wxGenericListCtrl
*listctrl
= GetListCtrl();
2247 wxListLineData
*ld
= GetDummyLine();
2249 size_t countCol
= GetColumnCount();
2250 for ( size_t col
= 0; col
< countCol
; col
++ )
2252 ld
->SetText(col
, listctrl
->OnGetItemText(line
, col
));
2255 ld
->SetImage(listctrl
->OnGetItemImage(line
));
2256 ld
->SetAttr(listctrl
->OnGetItemAttr(line
));
2259 wxListLineData
*wxListMainWindow::GetDummyLine() const
2261 wxASSERT_MSG( !IsEmpty(), _T("invalid line index") );
2263 wxASSERT_MSG( IsVirtual(), _T("GetDummyLine() shouldn't be called") );
2265 wxListMainWindow
*self
= wxConstCast(this, wxListMainWindow
);
2267 // we need to recreate the dummy line if the number of columns in the
2268 // control changed as it would have the incorrect number of fields
2270 if ( !m_lines
.IsEmpty() &&
2271 m_lines
[0].m_items
.GetCount() != (size_t)GetColumnCount() )
2273 self
->m_lines
.Clear();
2276 if ( m_lines
.IsEmpty() )
2278 wxListLineData
*line
= new wxListLineData(self
);
2279 self
->m_lines
.Add(line
);
2281 // don't waste extra memory -- there never going to be anything
2282 // else/more in this array
2283 self
->m_lines
.Shrink();
2289 // ----------------------------------------------------------------------------
2290 // line geometry (report mode only)
2291 // ----------------------------------------------------------------------------
2293 wxCoord
wxListMainWindow::GetLineHeight() const
2295 // we cache the line height as calling GetTextExtent() is slow
2296 if ( !m_lineHeight
)
2298 wxListMainWindow
*self
= wxConstCast(this, wxListMainWindow
);
2300 wxClientDC
dc( self
);
2301 dc
.SetFont( GetFont() );
2304 dc
.GetTextExtent(_T("H"), NULL
, &y
);
2306 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
).Inside(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
.Inside(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
) )
2455 bool wxListMainWindow::HighlightLine( size_t line
, bool highlight
)
2461 changed
= m_selStore
.SelectItem(line
, highlight
);
2465 wxListLineData
*ld
= GetLine(line
);
2466 wxCHECK_MSG( ld
, false, _T("invalid index in HighlightLine") );
2468 changed
= ld
->Highlight(highlight
);
2473 SendNotify( line
, highlight
? wxEVT_COMMAND_LIST_ITEM_SELECTED
2474 : wxEVT_COMMAND_LIST_ITEM_DESELECTED
);
2480 void wxListMainWindow::RefreshLine( size_t line
)
2482 if ( InReportView() )
2484 size_t visibleFrom
, visibleTo
;
2485 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2487 if ( line
< visibleFrom
|| line
> visibleTo
)
2491 wxRect rect
= GetLineRect(line
);
2493 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2494 RefreshRect( rect
);
2497 void wxListMainWindow::RefreshLines( size_t lineFrom
, size_t lineTo
)
2499 // we suppose that they are ordered by caller
2500 wxASSERT_MSG( lineFrom
<= lineTo
, _T("indices in disorder") );
2502 wxASSERT_MSG( lineTo
< GetItemCount(), _T("invalid line range") );
2504 if ( InReportView() )
2506 size_t visibleFrom
, visibleTo
;
2507 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2509 if ( lineFrom
< visibleFrom
)
2510 lineFrom
= visibleFrom
;
2511 if ( lineTo
> visibleTo
)
2516 rect
.y
= GetLineY(lineFrom
);
2517 rect
.width
= GetClientSize().x
;
2518 rect
.height
= GetLineY(lineTo
) - rect
.y
+ GetLineHeight();
2520 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2521 RefreshRect( rect
);
2525 // TODO: this should be optimized...
2526 for ( size_t line
= lineFrom
; line
<= lineTo
; line
++ )
2533 void wxListMainWindow::RefreshAfter( size_t lineFrom
)
2535 if ( InReportView() )
2537 size_t visibleFrom
, visibleTo
;
2538 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2540 if ( lineFrom
< visibleFrom
)
2541 lineFrom
= visibleFrom
;
2542 else if ( lineFrom
> visibleTo
)
2547 rect
.y
= GetLineY(lineFrom
);
2548 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2550 wxSize size
= GetClientSize();
2551 rect
.width
= size
.x
;
2552 // refresh till the bottom of the window
2553 rect
.height
= size
.y
- rect
.y
;
2555 RefreshRect( rect
);
2559 // TODO: how to do it more efficiently?
2564 void wxListMainWindow::RefreshSelected()
2570 if ( InReportView() )
2572 GetVisibleLinesRange(&from
, &to
);
2577 to
= GetItemCount() - 1;
2580 if ( HasCurrent() && m_current
>= from
&& m_current
<= to
)
2582 RefreshLine(m_current
);
2585 for ( size_t line
= from
; line
<= to
; line
++ )
2587 // NB: the test works as expected even if m_current == -1
2588 if ( line
!= m_current
&& IsHighlighted(line
) )
2595 void wxListMainWindow::Freeze()
2600 void wxListMainWindow::Thaw()
2602 wxCHECK_RET( m_freezeCount
> 0, _T("thawing unfrozen list control?") );
2604 if ( !--m_freezeCount
)
2610 void wxListMainWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
2612 // Note: a wxPaintDC must be constructed even if no drawing is
2613 // done (a Windows requirement).
2614 wxPaintDC
dc( this );
2616 if ( IsEmpty() || m_freezeCount
)
2618 // nothing to draw or not the moment to draw it
2624 // delay the repainting until we calculate all the items positions
2631 CalcScrolledPosition( 0, 0, &dev_x
, &dev_y
);
2635 dc
.SetFont( GetFont() );
2637 if ( InReportView() )
2639 int lineHeight
= GetLineHeight();
2641 size_t visibleFrom
, visibleTo
;
2642 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2645 wxCoord xOrig
, yOrig
;
2646 CalcUnscrolledPosition(0, 0, &xOrig
, &yOrig
);
2648 // tell the caller cache to cache the data
2651 wxListEvent
evCache(wxEVT_COMMAND_LIST_CACHE_HINT
,
2652 GetParent()->GetId());
2653 evCache
.SetEventObject( GetParent() );
2654 evCache
.m_oldItemIndex
= visibleFrom
;
2655 evCache
.m_itemIndex
= visibleTo
;
2656 GetParent()->GetEventHandler()->ProcessEvent( evCache
);
2659 for ( size_t line
= visibleFrom
; line
<= visibleTo
; line
++ )
2661 rectLine
= GetLineRect(line
);
2663 if ( !IsExposed(rectLine
.x
- xOrig
, rectLine
.y
- yOrig
,
2664 rectLine
.width
, rectLine
.height
) )
2666 // don't redraw unaffected lines to avoid flicker
2670 GetLine(line
)->DrawInReportMode( &dc
,
2672 GetLineHighlightRect(line
),
2673 IsHighlighted(line
) );
2676 if ( HasFlag(wxLC_HRULES
) )
2678 wxPen
pen(GetRuleColour(), 1, wxSOLID
);
2679 wxSize clientSize
= GetClientSize();
2681 // Don't draw the first one
2682 for ( size_t i
= visibleFrom
+1; i
<= visibleTo
; i
++ )
2685 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
2686 dc
.DrawLine(0 - dev_x
, i
*lineHeight
,
2687 clientSize
.x
- dev_x
, i
*lineHeight
);
2690 // Draw last horizontal rule
2691 if ( visibleTo
== GetItemCount() - 1 )
2694 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
2695 dc
.DrawLine(0 - dev_x
, (m_lineTo
+1)*lineHeight
,
2696 clientSize
.x
- dev_x
, (m_lineTo
+1)*lineHeight
);
2700 // Draw vertical rules if required
2701 if ( HasFlag(wxLC_VRULES
) && !IsEmpty() )
2703 wxPen
pen(GetRuleColour(), 1, wxSOLID
);
2705 wxRect firstItemRect
;
2706 wxRect lastItemRect
;
2707 GetItemRect(visibleFrom
, firstItemRect
);
2708 GetItemRect(visibleTo
, lastItemRect
);
2709 int x
= firstItemRect
.GetX();
2711 dc
.SetBrush(* wxTRANSPARENT_BRUSH
);
2712 for (int col
= 0; col
< GetColumnCount(); col
++)
2714 int colWidth
= GetColumnWidth(col
);
2716 dc
.DrawLine(x
- dev_x
- 2, firstItemRect
.GetY() - 1 - dev_y
,
2717 x
- dev_x
- 2, lastItemRect
.GetBottom() + 1 - dev_y
);
2723 size_t count
= GetItemCount();
2724 for ( size_t i
= 0; i
< count
; i
++ )
2726 GetLine(i
)->Draw( &dc
);
2731 // Don't draw rect outline under Mac at all.
2736 dc
.SetPen( *wxBLACK_PEN
);
2737 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
2738 dc
.DrawRectangle( GetLineHighlightRect(m_current
) );
2746 void wxListMainWindow::HighlightAll( bool on
)
2748 if ( IsSingleSel() )
2750 wxASSERT_MSG( !on
, _T("can't do this in a single sel control") );
2752 // we just have one item to turn off
2753 if ( HasCurrent() && IsHighlighted(m_current
) )
2755 HighlightLine(m_current
, false);
2756 RefreshLine(m_current
);
2761 HighlightLines(0, GetItemCount() - 1, on
);
2765 void wxListMainWindow::SendNotify( size_t line
,
2766 wxEventType command
,
2769 wxListEvent
le( command
, GetParent()->GetId() );
2770 le
.SetEventObject( GetParent() );
2771 le
.m_itemIndex
= line
;
2773 // set only for events which have position
2774 if ( point
!= wxDefaultPosition
)
2775 le
.m_pointDrag
= point
;
2777 // don't try to get the line info for virtual list controls: the main
2778 // program has it anyhow and if we did it would result in accessing all
2779 // the lines, even those which are not visible now and this is precisely
2780 // what we're trying to avoid
2781 if ( !IsVirtual() && (command
!= wxEVT_COMMAND_LIST_DELETE_ITEM
) )
2783 if ( line
!= (size_t)-1 )
2785 GetLine(line
)->GetItem( 0, le
.m_item
);
2787 //else: this happens for wxEVT_COMMAND_LIST_ITEM_FOCUSED event
2789 //else: there may be no more such item
2791 GetParent()->GetEventHandler()->ProcessEvent( le
);
2794 void wxListMainWindow::ChangeCurrent(size_t current
)
2796 m_current
= current
;
2798 SendNotify(current
, wxEVT_COMMAND_LIST_ITEM_FOCUSED
);
2801 void wxListMainWindow::EditLabel( long item
)
2803 wxCHECK_RET( (item
>= 0) && ((size_t)item
< GetItemCount()),
2804 wxT("wrong index in wxGenericListCtrl::EditLabel()") );
2806 size_t itemEdit
= (size_t)item
;
2808 wxListEvent
le( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT
, GetParent()->GetId() );
2809 le
.SetEventObject( GetParent() );
2810 le
.m_itemIndex
= item
;
2811 wxListLineData
*data
= GetLine(itemEdit
);
2812 wxCHECK_RET( data
, _T("invalid index in EditLabel()") );
2813 data
->GetItem( 0, le
.m_item
);
2814 if ( GetParent()->GetEventHandler()->ProcessEvent( le
) && !le
.IsAllowed() )
2816 // vetoed by user code
2820 // We have to call this here because the label in question might just have
2821 // been added and no screen update taken place.
2825 wxListTextCtrl
*text
= new wxListTextCtrl(this, itemEdit
);
2830 void wxListMainWindow::OnRenameTimer()
2832 wxCHECK_RET( HasCurrent(), wxT("unexpected rename timer") );
2834 EditLabel( m_current
);
2837 bool wxListMainWindow::OnRenameAccept(size_t itemEdit
, const wxString
& value
)
2839 wxListEvent
le( wxEVT_COMMAND_LIST_END_LABEL_EDIT
, GetParent()->GetId() );
2840 le
.SetEventObject( GetParent() );
2841 le
.m_itemIndex
= itemEdit
;
2843 wxListLineData
*data
= GetLine(itemEdit
);
2844 wxCHECK_MSG( data
, false, _T("invalid index in OnRenameAccept()") );
2846 data
->GetItem( 0, le
.m_item
);
2847 le
.m_item
.m_text
= value
;
2848 return !GetParent()->GetEventHandler()->ProcessEvent( le
) ||
2852 void wxListMainWindow::OnRenameCancelled(size_t itemEdit
)
2854 // let owner know that the edit was cancelled
2855 wxListEvent
le( wxEVT_COMMAND_LIST_END_LABEL_EDIT
, GetParent()->GetId() );
2857 le
.SetEditCanceled(true);
2859 le
.SetEventObject( GetParent() );
2860 le
.m_itemIndex
= itemEdit
;
2862 wxListLineData
*data
= GetLine(itemEdit
);
2863 wxCHECK_RET( data
, _T("invalid index in OnRenameCancelled()") );
2865 data
->GetItem( 0, le
.m_item
);
2867 GetEventHandler()->ProcessEvent( le
);
2870 void wxListMainWindow::OnMouse( wxMouseEvent
&event
)
2872 event
.SetEventObject( GetParent() );
2873 if ( GetParent()->GetEventHandler()->ProcessEvent( event
) )
2876 if ( !HasCurrent() || IsEmpty() )
2882 if ( !(event
.Dragging() || event
.ButtonDown() || event
.LeftUp() ||
2883 event
.ButtonDClick()) )
2886 int x
= event
.GetX();
2887 int y
= event
.GetY();
2888 CalcUnscrolledPosition( x
, y
, &x
, &y
);
2890 // where did we hit it (if we did)?
2893 size_t count
= GetItemCount(),
2896 if ( InReportView() )
2898 current
= y
/ GetLineHeight();
2899 if ( current
< count
)
2900 hitResult
= HitTestLine(current
, x
, y
);
2904 // TODO: optimize it too! this is less simple than for report view but
2905 // enumerating all items is still not a way to do it!!
2906 for ( current
= 0; current
< count
; current
++ )
2908 hitResult
= HitTestLine(current
, x
, y
);
2914 if (event
.Dragging())
2916 if (m_dragCount
== 0)
2918 // we have to report the raw, physical coords as we want to be
2919 // able to call HitTest(event.m_pointDrag) from the user code to
2920 // get the item being dragged
2921 m_dragStart
= event
.GetPosition();
2926 if (m_dragCount
!= 3)
2929 int command
= event
.RightIsDown() ? wxEVT_COMMAND_LIST_BEGIN_RDRAG
2930 : wxEVT_COMMAND_LIST_BEGIN_DRAG
;
2932 wxListEvent
le( command
, GetParent()->GetId() );
2933 le
.SetEventObject( GetParent() );
2934 le
.m_itemIndex
= current
;
2935 le
.m_pointDrag
= m_dragStart
;
2936 GetParent()->GetEventHandler()->ProcessEvent( le
);
2947 // outside of any item
2951 bool forceClick
= false;
2952 if (event
.ButtonDClick())
2954 m_renameTimer
->Stop();
2955 m_lastOnSame
= false;
2957 if ( current
== m_lineLastClicked
)
2959 SendNotify( current
, wxEVT_COMMAND_LIST_ITEM_ACTIVATED
);
2965 // the first click was on another item, so don't interpret this as
2966 // a double click, but as a simple click instead
2971 if (event
.LeftUp() && m_lastOnSame
)
2973 if ((current
== m_current
) &&
2974 (hitResult
== wxLIST_HITTEST_ONITEMLABEL
) &&
2975 HasFlag(wxLC_EDIT_LABELS
) )
2977 m_renameTimer
->Start( 100, true );
2979 m_lastOnSame
= false;
2981 else if (event
.RightDown())
2983 SendNotify( current
, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
,
2984 event
.GetPosition() );
2986 else if (event
.MiddleDown())
2988 SendNotify( current
, wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK
);
2990 else if ( event
.LeftDown() || forceClick
)
2992 m_lineBeforeLastClicked
= m_lineLastClicked
;
2993 m_lineLastClicked
= current
;
2995 size_t oldCurrent
= m_current
;
2996 bool cmdModifierDown
= event
.CmdDown();
2997 if ( IsSingleSel() || !(cmdModifierDown
|| event
.ShiftDown()) )
2999 HighlightAll( false );
3001 ChangeCurrent(current
);
3003 ReverseHighlight(m_current
);
3005 else // multi sel & either ctrl or shift is down
3007 if (cmdModifierDown
)
3009 ChangeCurrent(current
);
3011 ReverseHighlight(m_current
);
3013 else if (event
.ShiftDown())
3015 ChangeCurrent(current
);
3017 size_t lineFrom
= oldCurrent
,
3020 if ( lineTo
< lineFrom
)
3023 lineFrom
= m_current
;
3026 HighlightLines(lineFrom
, lineTo
);
3028 else // !ctrl, !shift
3030 // test in the enclosing if should make it impossible
3031 wxFAIL_MSG( _T("how did we get here?") );
3035 if (m_current
!= oldCurrent
)
3037 RefreshLine( oldCurrent
);
3040 // forceClick is only set if the previous click was on another item
3041 m_lastOnSame
= !forceClick
&& (m_current
== oldCurrent
);
3045 void wxListMainWindow::MoveToItem(size_t item
)
3047 if ( item
== (size_t)-1 )
3050 wxRect rect
= GetLineRect(item
);
3052 int client_w
, client_h
;
3053 GetClientSize( &client_w
, &client_h
);
3055 const int hLine
= GetLineHeight();
3057 int view_x
= SCROLL_UNIT_X
*GetScrollPos( wxHORIZONTAL
);
3058 int view_y
= hLine
*GetScrollPos( wxVERTICAL
);
3060 if ( InReportView() )
3062 // the next we need the range of lines shown it might be different, so
3064 ResetVisibleLinesRange();
3066 if (rect
.y
< view_y
)
3067 Scroll( -1, rect
.y
/hLine
);
3068 if (rect
.y
+rect
.height
+5 > view_y
+client_h
)
3069 Scroll( -1, (rect
.y
+rect
.height
-client_h
+hLine
)/hLine
);
3073 if (rect
.x
-view_x
< 5)
3074 Scroll( (rect
.x
-5)/SCROLL_UNIT_X
, -1 );
3075 if (rect
.x
+rect
.width
-5 > view_x
+client_w
)
3076 Scroll( (rect
.x
+rect
.width
-client_w
+SCROLL_UNIT_X
)/SCROLL_UNIT_X
, -1 );
3080 // ----------------------------------------------------------------------------
3081 // keyboard handling
3082 // ----------------------------------------------------------------------------
3084 void wxListMainWindow::OnArrowChar(size_t newCurrent
, const wxKeyEvent
& event
)
3086 wxCHECK_RET( newCurrent
< (size_t)GetItemCount(),
3087 _T("invalid item index in OnArrowChar()") );
3089 size_t oldCurrent
= m_current
;
3091 // in single selection we just ignore Shift as we can't select several
3093 if ( event
.ShiftDown() && !IsSingleSel() )
3095 ChangeCurrent(newCurrent
);
3097 // refresh the old focus to remove it
3098 RefreshLine( oldCurrent
);
3100 // select all the items between the old and the new one
3101 if ( oldCurrent
> newCurrent
)
3103 newCurrent
= oldCurrent
;
3104 oldCurrent
= m_current
;
3107 HighlightLines(oldCurrent
, newCurrent
);
3111 // all previously selected items are unselected unless ctrl is held
3112 if ( !event
.ControlDown() )
3113 HighlightAll(false);
3115 ChangeCurrent(newCurrent
);
3117 // refresh the old focus to remove it
3118 RefreshLine( oldCurrent
);
3120 if ( !event
.ControlDown() )
3122 HighlightLine( m_current
, true );
3126 RefreshLine( m_current
);
3131 void wxListMainWindow::OnKeyDown( wxKeyEvent
&event
)
3133 wxWindow
*parent
= GetParent();
3135 /* we propagate the key event up */
3136 wxKeyEvent
ke( wxEVT_KEY_DOWN
);
3137 ke
.m_shiftDown
= event
.m_shiftDown
;
3138 ke
.m_controlDown
= event
.m_controlDown
;
3139 ke
.m_altDown
= event
.m_altDown
;
3140 ke
.m_metaDown
= event
.m_metaDown
;
3141 ke
.m_keyCode
= event
.m_keyCode
;
3144 ke
.SetEventObject( parent
);
3145 if (parent
->GetEventHandler()->ProcessEvent( ke
)) return;
3150 void wxListMainWindow::OnChar( wxKeyEvent
&event
)
3152 wxWindow
*parent
= GetParent();
3154 /* we send a list_key event up */
3157 wxListEvent
le( wxEVT_COMMAND_LIST_KEY_DOWN
, GetParent()->GetId() );
3158 le
.m_itemIndex
= m_current
;
3159 GetLine(m_current
)->GetItem( 0, le
.m_item
);
3160 le
.m_code
= event
.GetKeyCode();
3161 le
.SetEventObject( parent
);
3162 parent
->GetEventHandler()->ProcessEvent( le
);
3165 /* we propagate the char event up */
3166 wxKeyEvent
ke( wxEVT_CHAR
);
3167 ke
.m_shiftDown
= event
.m_shiftDown
;
3168 ke
.m_controlDown
= event
.m_controlDown
;
3169 ke
.m_altDown
= event
.m_altDown
;
3170 ke
.m_metaDown
= event
.m_metaDown
;
3171 ke
.m_keyCode
= event
.m_keyCode
;
3174 ke
.SetEventObject( parent
);
3175 if (parent
->GetEventHandler()->ProcessEvent( ke
)) return;
3177 if (event
.GetKeyCode() == WXK_TAB
)
3179 wxNavigationKeyEvent nevent
;
3180 nevent
.SetWindowChange( event
.ControlDown() );
3181 nevent
.SetDirection( !event
.ShiftDown() );
3182 nevent
.SetEventObject( GetParent()->GetParent() );
3183 nevent
.SetCurrentFocus( m_parent
);
3184 if (GetParent()->GetParent()->GetEventHandler()->ProcessEvent( nevent
))
3188 /* no item -> nothing to do */
3195 switch (event
.GetKeyCode())
3198 if ( m_current
> 0 )
3199 OnArrowChar( m_current
- 1, event
);
3203 if ( m_current
< (size_t)GetItemCount() - 1 )
3204 OnArrowChar( m_current
+ 1, event
);
3209 OnArrowChar( GetItemCount() - 1, event
);
3214 OnArrowChar( 0, event
);
3219 int steps
= InReportView() ? m_linesPerPage
- 1 : m_current
% m_linesPerPage
;
3221 int index
= m_current
- steps
;
3225 OnArrowChar( index
, event
);
3231 int steps
= InReportView()
3232 ? m_linesPerPage
- 1
3233 : m_linesPerPage
- (m_current
% m_linesPerPage
) - 1;
3235 size_t index
= m_current
+ steps
;
3236 size_t count
= GetItemCount();
3237 if ( index
>= count
)
3240 OnArrowChar( index
, event
);
3245 if ( !InReportView() )
3247 int index
= m_current
- m_linesPerPage
;
3251 OnArrowChar( index
, event
);
3256 if ( !InReportView() )
3258 size_t index
= m_current
+ m_linesPerPage
;
3260 size_t count
= GetItemCount();
3261 if ( index
>= count
)
3264 OnArrowChar( index
, event
);
3269 if ( IsSingleSel() )
3271 SendNotify( m_current
, wxEVT_COMMAND_LIST_ITEM_ACTIVATED
);
3273 if ( IsHighlighted(m_current
) )
3275 // don't unselect the item in single selection mode
3278 //else: select it in ReverseHighlight() below if unselected
3281 ReverseHighlight(m_current
);
3286 SendNotify( m_current
, wxEVT_COMMAND_LIST_ITEM_ACTIVATED
);
3294 // ----------------------------------------------------------------------------
3296 // ----------------------------------------------------------------------------
3298 void wxListMainWindow::SetFocus()
3300 // VS: wxListMainWindow derives from wxPanel (via wxScrolledWindow) and wxPanel
3301 // overrides SetFocus in such way that it does never change focus from
3302 // panel's child to the panel itself. Unfortunately, we must be able to change
3303 // focus to the panel from wxListTextCtrl because the text control should
3304 // disappear when the user clicks outside it.
3306 wxWindow
*oldFocus
= FindFocus();
3308 if ( oldFocus
&& oldFocus
->GetParent() == this )
3310 wxWindow::SetFocus();
3314 wxScrolledWindow::SetFocus();
3318 void wxListMainWindow::OnSetFocus( wxFocusEvent
&WXUNUSED(event
) )
3322 wxFocusEvent
event( wxEVT_SET_FOCUS
, GetParent()->GetId() );
3323 event
.SetEventObject( GetParent() );
3324 if ( GetParent()->GetEventHandler()->ProcessEvent( event
) )
3328 // wxGTK sends us EVT_SET_FOCUS events even if we had never got
3329 // EVT_KILL_FOCUS before which means that we finish by redrawing the items
3330 // which are already drawn correctly resulting in horrible flicker - avoid
3340 void wxListMainWindow::OnKillFocus( wxFocusEvent
&WXUNUSED(event
) )
3344 wxFocusEvent
event( wxEVT_KILL_FOCUS
, GetParent()->GetId() );
3345 event
.SetEventObject( GetParent() );
3346 if ( GetParent()->GetEventHandler()->ProcessEvent( event
) )
3353 void wxListMainWindow::DrawImage( int index
, wxDC
*dc
, int x
, int y
)
3355 if ( HasFlag(wxLC_ICON
) && (m_normal_image_list
))
3357 m_normal_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3359 else if ( HasFlag(wxLC_SMALL_ICON
) && (m_small_image_list
))
3361 m_small_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3363 else if ( HasFlag(wxLC_LIST
) && (m_small_image_list
))
3365 m_small_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3367 else if ( InReportView() && (m_small_image_list
))
3369 m_small_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3373 void wxListMainWindow::GetImageSize( int index
, int &width
, int &height
) const
3375 if ( HasFlag(wxLC_ICON
) && m_normal_image_list
)
3377 m_normal_image_list
->GetSize( index
, width
, height
);
3379 else if ( HasFlag(wxLC_SMALL_ICON
) && m_small_image_list
)
3381 m_small_image_list
->GetSize( index
, width
, height
);
3383 else if ( HasFlag(wxLC_LIST
) && m_small_image_list
)
3385 m_small_image_list
->GetSize( index
, width
, height
);
3387 else if ( InReportView() && m_small_image_list
)
3389 m_small_image_list
->GetSize( index
, width
, height
);
3398 int wxListMainWindow::GetTextLength( const wxString
&s
) const
3400 wxClientDC
dc( wxConstCast(this, wxListMainWindow
) );
3401 dc
.SetFont( GetFont() );
3404 dc
.GetTextExtent( s
, &lw
, NULL
);
3406 return lw
+ AUTOSIZE_COL_MARGIN
;
3409 void wxListMainWindow::SetImageList( wxImageListType
*imageList
, int which
)
3413 // calc the spacing from the icon size
3416 if ((imageList
) && (imageList
->GetImageCount()) )
3418 imageList
->GetSize(0, width
, height
);
3421 if (which
== wxIMAGE_LIST_NORMAL
)
3423 m_normal_image_list
= imageList
;
3424 m_normal_spacing
= width
+ 8;
3427 if (which
== wxIMAGE_LIST_SMALL
)
3429 m_small_image_list
= imageList
;
3430 m_small_spacing
= width
+ 14;
3431 m_lineHeight
= 0; // ensure that the line height will be recalc'd
3435 void wxListMainWindow::SetItemSpacing( int spacing
, bool isSmall
)
3440 m_small_spacing
= spacing
;
3444 m_normal_spacing
= spacing
;
3448 int wxListMainWindow::GetItemSpacing( bool isSmall
)
3450 return isSmall
? m_small_spacing
: m_normal_spacing
;
3453 // ----------------------------------------------------------------------------
3455 // ----------------------------------------------------------------------------
3457 void wxListMainWindow::SetColumn( int col
, wxListItem
&item
)
3459 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
3461 wxCHECK_RET( node
, _T("invalid column index in SetColumn") );
3463 if ( item
.m_width
== wxLIST_AUTOSIZE_USEHEADER
)
3464 item
.m_width
= GetTextLength( item
.m_text
);
3466 wxListHeaderData
*column
= node
->GetData();
3467 column
->SetItem( item
);
3469 wxListHeaderWindow
*headerWin
= GetListCtrl()->m_headerWin
;
3471 headerWin
->m_dirty
= true;
3475 // invalidate it as it has to be recalculated
3479 void wxListMainWindow::SetColumnWidth( int col
, int width
)
3481 wxCHECK_RET( col
>= 0 && col
< GetColumnCount(),
3482 _T("invalid column index") );
3484 wxCHECK_RET( InReportView(),
3485 _T("SetColumnWidth() can only be called in report mode.") );
3488 wxListHeaderWindow
*headerWin
= GetListCtrl()->m_headerWin
;
3490 headerWin
->m_dirty
= true;
3492 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
3493 wxCHECK_RET( node
, _T("no column?") );
3495 wxListHeaderData
*column
= node
->GetData();
3497 size_t count
= GetItemCount();
3499 if (width
== wxLIST_AUTOSIZE_USEHEADER
)
3501 width
= GetTextLength(column
->GetText());
3503 else if ( width
== wxLIST_AUTOSIZE
)
3507 // TODO: determine the max width somehow...
3508 width
= WIDTH_COL_DEFAULT
;
3512 wxClientDC
dc(this);
3513 dc
.SetFont( GetFont() );
3515 int max
= AUTOSIZE_COL_MARGIN
;
3517 for ( size_t i
= 0; i
< count
; i
++ )
3519 wxListLineData
*line
= GetLine(i
);
3520 wxListItemDataList::compatibility_iterator n
= line
->m_items
.Item( col
);
3522 wxCHECK_RET( n
, _T("no subitem?") );
3524 wxListItemData
*item
= n
->GetData();
3527 if (item
->HasImage())
3530 GetImageSize( item
->GetImage(), ix
, iy
);
3534 if (item
->HasText())
3537 dc
.GetTextExtent( item
->GetText(), &w
, NULL
);
3545 width
= max
+ AUTOSIZE_COL_MARGIN
;
3549 column
->SetWidth( width
);
3551 // invalidate it as it has to be recalculated
3555 int wxListMainWindow::GetHeaderWidth() const
3557 if ( !m_headerWidth
)
3559 wxListMainWindow
*self
= wxConstCast(this, wxListMainWindow
);
3561 size_t count
= GetColumnCount();
3562 for ( size_t col
= 0; col
< count
; col
++ )
3564 self
->m_headerWidth
+= GetColumnWidth(col
);
3568 return m_headerWidth
;
3571 void wxListMainWindow::GetColumn( int col
, wxListItem
&item
) const
3573 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
3574 wxCHECK_RET( node
, _T("invalid column index in GetColumn") );
3576 wxListHeaderData
*column
= node
->GetData();
3577 column
->GetItem( item
);
3580 int wxListMainWindow::GetColumnWidth( int col
) const
3582 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
3583 wxCHECK_MSG( node
, 0, _T("invalid column index") );
3585 wxListHeaderData
*column
= node
->GetData();
3586 return column
->GetWidth();
3589 // ----------------------------------------------------------------------------
3591 // ----------------------------------------------------------------------------
3593 void wxListMainWindow::SetItem( wxListItem
&item
)
3595 long id
= item
.m_itemId
;
3596 wxCHECK_RET( id
>= 0 && (size_t)id
< GetItemCount(),
3597 _T("invalid item index in SetItem") );
3601 wxListLineData
*line
= GetLine((size_t)id
);
3602 line
->SetItem( item
.m_col
, item
);
3605 // update the item on screen
3607 GetItemRect(id
, rectItem
);
3608 RefreshRect(rectItem
);
3611 void wxListMainWindow::SetItemState( long litem
, long state
, long stateMask
)
3613 wxCHECK_RET( litem
>= 0 && (size_t)litem
< GetItemCount(),
3614 _T("invalid list ctrl item index in SetItem") );
3616 size_t oldCurrent
= m_current
;
3617 size_t item
= (size_t)litem
; // safe because of the check above
3619 // do we need to change the focus?
3620 if ( stateMask
& wxLIST_STATE_FOCUSED
)
3622 if ( state
& wxLIST_STATE_FOCUSED
)
3624 // don't do anything if this item is already focused
3625 if ( item
!= m_current
)
3627 ChangeCurrent(item
);
3629 if ( oldCurrent
!= (size_t)-1 )
3631 if ( IsSingleSel() )
3633 HighlightLine(oldCurrent
, false);
3636 RefreshLine(oldCurrent
);
3639 RefreshLine( m_current
);
3644 // don't do anything if this item is not focused
3645 if ( item
== m_current
)
3649 if ( IsSingleSel() )
3651 // we must unselect the old current item as well or we
3652 // might end up with more than one selected item in a
3653 // single selection control
3654 HighlightLine(oldCurrent
, false);
3657 RefreshLine( oldCurrent
);
3662 // do we need to change the selection state?
3663 if ( stateMask
& wxLIST_STATE_SELECTED
)
3665 bool on
= (state
& wxLIST_STATE_SELECTED
) != 0;
3667 if ( IsSingleSel() )
3671 // selecting the item also makes it the focused one in the
3673 if ( m_current
!= item
)
3675 ChangeCurrent(item
);
3677 if ( oldCurrent
!= (size_t)-1 )
3679 HighlightLine( oldCurrent
, false );
3680 RefreshLine( oldCurrent
);
3686 // only the current item may be selected anyhow
3687 if ( item
!= m_current
)
3692 if ( HighlightLine(item
, on
) )
3699 int wxListMainWindow::GetItemState( long item
, long stateMask
) const
3701 wxCHECK_MSG( item
>= 0 && (size_t)item
< GetItemCount(), 0,
3702 _T("invalid list ctrl item index in GetItemState()") );
3704 int ret
= wxLIST_STATE_DONTCARE
;
3706 if ( stateMask
& wxLIST_STATE_FOCUSED
)
3708 if ( (size_t)item
== m_current
)
3709 ret
|= wxLIST_STATE_FOCUSED
;
3712 if ( stateMask
& wxLIST_STATE_SELECTED
)
3714 if ( IsHighlighted(item
) )
3715 ret
|= wxLIST_STATE_SELECTED
;
3721 void wxListMainWindow::GetItem( wxListItem
&item
) const
3723 wxCHECK_RET( item
.m_itemId
>= 0 && (size_t)item
.m_itemId
< GetItemCount(),
3724 _T("invalid item index in GetItem") );
3726 wxListLineData
*line
= GetLine((size_t)item
.m_itemId
);
3727 line
->GetItem( item
.m_col
, item
);
3730 // ----------------------------------------------------------------------------
3732 // ----------------------------------------------------------------------------
3734 size_t wxListMainWindow::GetItemCount() const
3736 return IsVirtual() ? m_countVirt
: m_lines
.GetCount();
3739 void wxListMainWindow::SetItemCount(long count
)
3741 m_selStore
.SetItemCount(count
);
3742 m_countVirt
= count
;
3744 ResetVisibleLinesRange();
3746 // scrollbars must be reset
3750 int wxListMainWindow::GetSelectedItemCount() const
3752 // deal with the quick case first
3753 if ( IsSingleSel() )
3755 return HasCurrent() ? IsHighlighted(m_current
) : false;
3758 // virtual controls remmebers all its selections itself
3760 return m_selStore
.GetSelectedCount();
3762 // TODO: we probably should maintain the number of items selected even for
3763 // non virtual controls as enumerating all lines is really slow...
3764 size_t countSel
= 0;
3765 size_t count
= GetItemCount();
3766 for ( size_t line
= 0; line
< count
; line
++ )
3768 if ( GetLine(line
)->IsHighlighted() )
3775 // ----------------------------------------------------------------------------
3776 // item position/size
3777 // ----------------------------------------------------------------------------
3779 wxRect
wxListMainWindow::GetViewRect() const
3781 wxASSERT_MSG( !HasFlag(wxLC_REPORT
| wxLC_LIST
),
3782 _T("wxListCtrl::GetViewRect() only works in icon mode") );
3784 // we need to find the longest/tallest label
3787 const int count
= GetItemCount();
3790 for ( int i
= 0; i
< count
; i
++ )
3795 wxCoord x
= r
.GetRight(),
3805 // some fudge needed to make it look prettier
3806 xMax
+= 2*EXTRA_BORDER_X
;
3807 yMax
+= 2*EXTRA_BORDER_Y
;
3809 // account for the scrollbars if necessary
3810 const wxSize sizeAll
= GetClientSize();
3811 if ( xMax
> sizeAll
.x
)
3812 yMax
+= wxSystemSettings::GetMetric(wxSYS_HSCROLL_Y
);
3813 if ( yMax
> sizeAll
.y
)
3814 xMax
+= wxSystemSettings::GetMetric(wxSYS_VSCROLL_X
);
3816 return wxRect(0, 0, xMax
, yMax
);
3819 void wxListMainWindow::GetItemRect( long index
, wxRect
&rect
) const
3821 wxCHECK_RET( index
>= 0 && (size_t)index
< GetItemCount(),
3822 _T("invalid index in GetItemRect") );
3824 // ensure that we're laid out, otherwise we could return nonsense
3827 wxConstCast(this, wxListMainWindow
)->
3828 RecalculatePositions(true /* no refresh */);
3831 rect
= GetLineRect((size_t)index
);
3833 CalcScrolledPosition(rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
3836 bool wxListMainWindow::GetItemPosition(long item
, wxPoint
& pos
) const
3839 GetItemRect(item
, rect
);
3847 // ----------------------------------------------------------------------------
3848 // geometry calculation
3849 // ----------------------------------------------------------------------------
3851 void wxListMainWindow::RecalculatePositions(bool noRefresh
)
3853 wxClientDC
dc( this );
3854 dc
.SetFont( GetFont() );
3856 const size_t count
= GetItemCount();
3859 if ( HasFlag(wxLC_ICON
) )
3860 iconSpacing
= m_normal_spacing
;
3861 else if ( HasFlag(wxLC_SMALL_ICON
) )
3862 iconSpacing
= m_small_spacing
;
3866 // Note that we do not call GetClientSize() here but
3867 // GetSize() and substract the border size for sunken
3868 // borders manually. This is technically incorrect,
3869 // but we need to know the client area's size WITHOUT
3870 // scrollbars here. Since we don't know if there are
3871 // any scrollbars, we use GetSize() instead. Another
3872 // solution would be to call SetScrollbars() here to
3873 // remove the scrollbars and call GetClientSize() then,
3874 // but this might result in flicker and - worse - will
3875 // reset the scrollbars to 0 which is not good at all
3876 // if you resize a dialog/window, but don't want to
3877 // reset the window scrolling. RR.
3878 // Furthermore, we actually do NOT subtract the border
3879 // width as 2 pixels is just the extra space which we
3880 // need around the actual content in the window. Other-
3881 // wise the text would e.g. touch the upper border. RR.
3884 GetSize( &clientWidth
, &clientHeight
);
3886 const int lineHeight
= GetLineHeight();
3888 if ( InReportView() )
3890 // all lines have the same height and we scroll one line per step
3891 int entireHeight
= count
*lineHeight
+ LINE_SPACING
;
3893 m_linesPerPage
= clientHeight
/ lineHeight
;
3895 ResetVisibleLinesRange();
3897 SetScrollbars( SCROLL_UNIT_X
, lineHeight
,
3898 GetHeaderWidth() / SCROLL_UNIT_X
,
3899 (entireHeight
+ lineHeight
- 1) / lineHeight
,
3900 GetScrollPos(wxHORIZONTAL
),
3901 GetScrollPos(wxVERTICAL
),
3906 // we have 3 different layout strategies: either layout all items
3907 // horizontally/vertically (wxLC_ALIGN_XXX styles explicitly given) or
3908 // to arrange them in top to bottom, left to right (don't ask me why
3909 // not the other way round...) order
3910 if ( HasFlag(wxLC_ALIGN_LEFT
| wxLC_ALIGN_TOP
) )
3912 int x
= EXTRA_BORDER_X
;
3913 int y
= EXTRA_BORDER_Y
;
3915 wxCoord widthMax
= 0;
3918 for ( i
= 0; i
< count
; i
++ )
3920 wxListLineData
*line
= GetLine(i
);
3921 line
->CalculateSize( &dc
, iconSpacing
);
3922 line
->SetPosition( x
, y
, iconSpacing
);
3924 wxSize sizeLine
= GetLineSize(i
);
3926 if ( HasFlag(wxLC_ALIGN_TOP
) )
3928 if ( sizeLine
.x
> widthMax
)
3929 widthMax
= sizeLine
.x
;
3933 else // wxLC_ALIGN_LEFT
3935 x
+= sizeLine
.x
+ MARGIN_BETWEEN_ROWS
;
3939 if ( HasFlag(wxLC_ALIGN_TOP
) )
3941 // traverse the items again and tweak their sizes so that they are
3942 // all the same in a row
3943 for ( i
= 0; i
< count
; i
++ )
3945 wxListLineData
*line
= GetLine(i
);
3946 line
->m_gi
->ExtendWidth(widthMax
);
3955 (x
+ SCROLL_UNIT_X
) / SCROLL_UNIT_X
,
3956 (y
+ lineHeight
) / lineHeight
,
3957 GetScrollPos( wxHORIZONTAL
),
3958 GetScrollPos( wxVERTICAL
),
3962 else // "flowed" arrangement, the most complicated case
3964 // at first we try without any scrollbars, if the items don't fit into
3965 // the window, we recalculate after subtracting the space taken by the
3968 int entireWidth
= 0;
3970 for (int tries
= 0; tries
< 2; tries
++)
3972 entireWidth
= 2*EXTRA_BORDER_X
;
3976 // Now we have decided that the items do not fit into the
3977 // client area, so we need a scrollbar
3978 entireWidth
+= SCROLL_UNIT_X
;
3981 int x
= EXTRA_BORDER_X
;
3982 int y
= EXTRA_BORDER_Y
;
3983 int maxWidthInThisRow
= 0;
3986 int currentlyVisibleLines
= 0;
3988 for (size_t i
= 0; i
< count
; i
++)
3990 currentlyVisibleLines
++;
3991 wxListLineData
*line
= GetLine(i
);
3992 line
->CalculateSize( &dc
, iconSpacing
);
3993 line
->SetPosition( x
, y
, iconSpacing
);
3995 wxSize sizeLine
= GetLineSize(i
);
3997 if ( maxWidthInThisRow
< sizeLine
.x
)
3998 maxWidthInThisRow
= sizeLine
.x
;
4001 if (currentlyVisibleLines
> m_linesPerPage
)
4002 m_linesPerPage
= currentlyVisibleLines
;
4004 if ( y
+ sizeLine
.y
>= clientHeight
)
4006 currentlyVisibleLines
= 0;
4008 maxWidthInThisRow
+= MARGIN_BETWEEN_ROWS
;
4009 x
+= maxWidthInThisRow
;
4010 entireWidth
+= maxWidthInThisRow
;
4011 maxWidthInThisRow
= 0;
4014 // We have reached the last item.
4015 if ( i
== count
- 1 )
4016 entireWidth
+= maxWidthInThisRow
;
4018 if ( (tries
== 0) &&
4019 (entireWidth
+ SCROLL_UNIT_X
> clientWidth
) )
4021 clientHeight
-= wxSystemSettings::
4022 GetMetric(wxSYS_HSCROLL_Y
);
4027 if ( i
== count
- 1 )
4028 tries
= 1; // Everything fits, no second try required.
4036 (entireWidth
+ SCROLL_UNIT_X
) / SCROLL_UNIT_X
,
4038 GetScrollPos( wxHORIZONTAL
),
4047 // FIXME: why should we call it from here?
4054 void wxListMainWindow::RefreshAll()
4059 wxListHeaderWindow
*headerWin
= GetListCtrl()->m_headerWin
;
4060 if ( headerWin
&& headerWin
->m_dirty
)
4062 headerWin
->m_dirty
= false;
4063 headerWin
->Refresh();
4067 void wxListMainWindow::UpdateCurrent()
4069 if ( !HasCurrent() && !IsEmpty() )
4075 long wxListMainWindow::GetNextItem( long item
,
4076 int WXUNUSED(geometry
),
4080 max
= GetItemCount();
4081 wxCHECK_MSG( (ret
== -1) || (ret
< max
), -1,
4082 _T("invalid listctrl index in GetNextItem()") );
4084 // notice that we start with the next item (or the first one if item == -1)
4085 // and this is intentional to allow writing a simple loop to iterate over
4086 // all selected items
4090 // this is not an error because the index was ok initially, just no
4101 size_t count
= GetItemCount();
4102 for ( size_t line
= (size_t)ret
; line
< count
; line
++ )
4104 if ( (state
& wxLIST_STATE_FOCUSED
) && (line
== m_current
) )
4107 if ( (state
& wxLIST_STATE_SELECTED
) && IsHighlighted(line
) )
4114 // ----------------------------------------------------------------------------
4116 // ----------------------------------------------------------------------------
4118 void wxListMainWindow::DeleteItem( long lindex
)
4120 size_t count
= GetItemCount();
4122 wxCHECK_RET( (lindex
>= 0) && ((size_t)lindex
< count
),
4123 _T("invalid item index in DeleteItem") );
4125 size_t index
= (size_t)lindex
;
4127 // we don't need to adjust the index for the previous items
4128 if ( HasCurrent() && m_current
>= index
)
4130 // if the current item is being deleted, we want the next one to
4131 // become selected - unless there is no next one - so don't adjust
4132 // m_current in this case
4133 if ( m_current
!= index
|| m_current
== count
- 1 )
4139 if ( InReportView() )
4141 ResetVisibleLinesRange();
4148 m_selStore
.OnItemDelete(index
);
4152 m_lines
.RemoveAt( index
);
4155 // we need to refresh the (vert) scrollbar as the number of items changed
4158 SendNotify( index
, wxEVT_COMMAND_LIST_DELETE_ITEM
);
4160 RefreshAfter(index
);
4163 void wxListMainWindow::DeleteColumn( int col
)
4165 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
4167 wxCHECK_RET( node
, wxT("invalid column index in DeleteColumn()") );
4170 delete node
->GetData();
4171 m_columns
.Erase( node
);
4175 // update all the items
4176 for ( size_t i
= 0; i
< m_lines
.GetCount(); i
++ )
4178 wxListLineData
* const line
= GetLine(i
);
4179 wxListItemDataList::compatibility_iterator n
= line
->m_items
.Item( col
);
4180 delete n
->GetData();
4181 line
->m_items
.Erase(n
);
4185 // invalidate it as it has to be recalculated
4189 void wxListMainWindow::DoDeleteAllItems()
4193 // nothing to do - in particular, don't send the event
4199 // to make the deletion of all items faster, we don't send the
4200 // notifications for each item deletion in this case but only one event
4201 // for all of them: this is compatible with wxMSW and documented in
4202 // DeleteAllItems() description
4204 wxListEvent
event( wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS
, GetParent()->GetId() );
4205 event
.SetEventObject( GetParent() );
4206 GetParent()->GetEventHandler()->ProcessEvent( event
);
4215 if ( InReportView() )
4217 ResetVisibleLinesRange();
4223 void wxListMainWindow::DeleteAllItems()
4227 RecalculatePositions();
4230 void wxListMainWindow::DeleteEverything()
4232 WX_CLEAR_LIST(wxListHeaderDataList
, m_columns
);
4237 // ----------------------------------------------------------------------------
4238 // scanning for an item
4239 // ----------------------------------------------------------------------------
4241 void wxListMainWindow::EnsureVisible( long index
)
4243 wxCHECK_RET( index
>= 0 && (size_t)index
< GetItemCount(),
4244 _T("invalid index in EnsureVisible") );
4246 // We have to call this here because the label in question might just have
4247 // been added and its position is not known yet
4250 RecalculatePositions(true /* no refresh */);
4253 MoveToItem((size_t)index
);
4256 long wxListMainWindow::FindItem(long start
, const wxString
& str
, bool WXUNUSED(partial
) )
4263 size_t count
= GetItemCount();
4264 for ( size_t i
= (size_t)pos
; i
< count
; i
++ )
4266 wxListLineData
*line
= GetLine(i
);
4267 if ( line
->GetText(0) == tmp
)
4274 long wxListMainWindow::FindItem(long start
, long data
)
4280 size_t count
= GetItemCount();
4281 for (size_t i
= (size_t)pos
; i
< count
; i
++)
4283 wxListLineData
*line
= GetLine(i
);
4285 line
->GetItem( 0, item
);
4286 if (item
.m_data
== data
)
4293 long wxListMainWindow::FindItem( const wxPoint
& pt
)
4296 GetVisibleLinesRange(&topItem
, NULL
);
4299 GetItemPosition( GetItemCount()-1, p
);
4302 long id
= (long) floor( pt
.y
*double(GetItemCount()-topItem
-1)/p
.y
+topItem
);
4303 if( id
>= 0 && id
< (long)GetItemCount() )
4309 long wxListMainWindow::HitTest( int x
, int y
, int &flags
)
4311 CalcUnscrolledPosition( x
, y
, &x
, &y
);
4313 size_t count
= GetItemCount();
4315 if ( InReportView() )
4317 size_t current
= y
/ GetLineHeight();
4318 if ( current
< count
)
4320 flags
= HitTestLine(current
, x
, y
);
4327 // TODO: optimize it too! this is less simple than for report view but
4328 // enumerating all items is still not a way to do it!!
4329 for ( size_t current
= 0; current
< count
; current
++ )
4331 flags
= HitTestLine(current
, x
, y
);
4340 // ----------------------------------------------------------------------------
4342 // ----------------------------------------------------------------------------
4344 void wxListMainWindow::InsertItem( wxListItem
&item
)
4346 wxASSERT_MSG( !IsVirtual(), _T("can't be used with virtual control") );
4348 int count
= GetItemCount();
4349 wxCHECK_RET( item
.m_itemId
>= 0, _T("invalid item index") );
4351 if (item
.m_itemId
> count
)
4352 item
.m_itemId
= count
;
4354 size_t id
= item
.m_itemId
;
4359 // this is unused variable
4362 if ( InReportView() )
4365 // this is unused variable
4368 ResetVisibleLinesRange();
4370 else if ( HasFlag(wxLC_LIST
) )
4372 // this is unused variable
4377 else if ( HasFlag(wxLC_ICON
) )
4379 // this is unused variable
4384 else if ( HasFlag(wxLC_SMALL_ICON
) )
4386 // this is unused variable
4387 mode
= wxLC_ICON
; // no typo
4393 wxFAIL_MSG( _T("unknown mode") );
4396 wxListLineData
*line
= new wxListLineData(this);
4398 line
->SetItem( 0, item
);
4400 m_lines
.Insert( line
, id
);
4404 // If an item is selected at or below the point of insertion, we need to
4405 // increment the member variables because the current row's index has gone
4407 if ( HasCurrent() && m_current
>= id
)
4412 SendNotify(id
, wxEVT_COMMAND_LIST_INSERT_ITEM
);
4414 RefreshLines(id
, GetItemCount() - 1);
4417 void wxListMainWindow::InsertColumn( long col
, wxListItem
&item
)
4420 if ( InReportView() )
4422 if (item
.m_width
== wxLIST_AUTOSIZE_USEHEADER
)
4423 item
.m_width
= GetTextLength( item
.m_text
);
4425 wxListHeaderData
*column
= new wxListHeaderData( item
);
4426 bool insert
= (col
>= 0) && ((size_t)col
< m_columns
.GetCount());
4429 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
4430 m_columns
.Insert( node
, column
);
4434 m_columns
.Append( column
);
4439 // update all the items
4440 for ( size_t i
= 0; i
< m_lines
.GetCount(); i
++ )
4442 wxListLineData
* const line
= GetLine(i
);
4443 wxListItemData
* const data
= new wxListItemData(this);
4445 line
->m_items
.Insert(col
, data
);
4447 line
->m_items
.Append(data
);
4451 // invalidate it as it has to be recalculated
4456 // ----------------------------------------------------------------------------
4458 // ----------------------------------------------------------------------------
4460 wxListCtrlCompare list_ctrl_compare_func_2
;
4461 long list_ctrl_compare_data
;
4463 int LINKAGEMODE
list_ctrl_compare_func_1( wxListLineData
**arg1
, wxListLineData
**arg2
)
4465 wxListLineData
*line1
= *arg1
;
4466 wxListLineData
*line2
= *arg2
;
4468 line1
->GetItem( 0, item
);
4469 long data1
= item
.m_data
;
4470 line2
->GetItem( 0, item
);
4471 long data2
= item
.m_data
;
4472 return list_ctrl_compare_func_2( data1
, data2
, list_ctrl_compare_data
);
4475 void wxListMainWindow::SortItems( wxListCtrlCompare fn
, long data
)
4477 list_ctrl_compare_func_2
= fn
;
4478 list_ctrl_compare_data
= data
;
4479 m_lines
.Sort( list_ctrl_compare_func_1
);
4483 // ----------------------------------------------------------------------------
4485 // ----------------------------------------------------------------------------
4487 void wxListMainWindow::OnScroll(wxScrollWinEvent
& event
)
4489 // update our idea of which lines are shown when we redraw the window the
4491 ResetVisibleLinesRange();
4494 #if defined(__WXGTK__) && !defined(__WXUNIVERSAL__)
4495 wxScrolledWindow::OnScroll(event
);
4497 HandleOnScroll( event
);
4500 if ( event
.GetOrientation() == wxHORIZONTAL
&& HasHeader() )
4502 wxGenericListCtrl
* lc
= GetListCtrl();
4503 wxCHECK_RET( lc
, _T("no listctrl window?") );
4505 lc
->m_headerWin
->Refresh();
4506 lc
->m_headerWin
->Update();
4510 int wxListMainWindow::GetCountPerPage() const
4512 if ( !m_linesPerPage
)
4514 wxConstCast(this, wxListMainWindow
)->
4515 m_linesPerPage
= GetClientSize().y
/ GetLineHeight();
4518 return m_linesPerPage
;
4521 void wxListMainWindow::GetVisibleLinesRange(size_t *from
, size_t *to
)
4523 wxASSERT_MSG( InReportView(), _T("this is for report mode only") );
4525 if ( m_lineFrom
== (size_t)-1 )
4527 size_t count
= GetItemCount();
4530 m_lineFrom
= GetScrollPos(wxVERTICAL
);
4532 // this may happen if SetScrollbars() hadn't been called yet
4533 if ( m_lineFrom
>= count
)
4534 m_lineFrom
= count
- 1;
4536 // we redraw one extra line but this is needed to make the redrawing
4537 // logic work when there is a fractional number of lines on screen
4538 m_lineTo
= m_lineFrom
+ m_linesPerPage
;
4539 if ( m_lineTo
>= count
)
4540 m_lineTo
= count
- 1;
4542 else // empty control
4545 m_lineTo
= (size_t)-1;
4549 wxASSERT_MSG( IsEmpty() ||
4550 (m_lineFrom
<= m_lineTo
&& m_lineTo
< GetItemCount()),
4551 _T("GetVisibleLinesRange() returns incorrect result") );
4559 // -------------------------------------------------------------------------------------
4560 // wxGenericListCtrl
4561 // -------------------------------------------------------------------------------------
4563 IMPLEMENT_DYNAMIC_CLASS(wxGenericListCtrl
, wxControl
)
4565 BEGIN_EVENT_TABLE(wxGenericListCtrl
,wxControl
)
4566 EVT_SIZE(wxGenericListCtrl::OnSize
)
4569 wxGenericListCtrl::wxGenericListCtrl()
4571 m_imageListNormal
= (wxImageListType
*) NULL
;
4572 m_imageListSmall
= (wxImageListType
*) NULL
;
4573 m_imageListState
= (wxImageListType
*) NULL
;
4575 m_ownsImageListNormal
=
4576 m_ownsImageListSmall
=
4577 m_ownsImageListState
= false;
4579 m_mainWin
= (wxListMainWindow
*) NULL
;
4580 m_headerWin
= (wxListHeaderWindow
*) NULL
;
4584 wxGenericListCtrl::~wxGenericListCtrl()
4586 if (m_ownsImageListNormal
)
4587 delete m_imageListNormal
;
4588 if (m_ownsImageListSmall
)
4589 delete m_imageListSmall
;
4590 if (m_ownsImageListState
)
4591 delete m_imageListState
;
4594 void wxGenericListCtrl::CalculateAndSetHeaderHeight()
4598 // we use 'g' to get the descent, too
4600 m_headerWin
->GetTextExtent(wxT("Hg"), &w
, &h
, &d
);
4601 h
+= d
+ 2 * HEADER_OFFSET_Y
+ EXTRA_HEIGHT
;
4603 // only update if changed
4604 if ( h
!= m_headerHeight
)
4608 m_headerWin
->SetSize(m_headerWin
->GetSize().x
, m_headerHeight
);
4611 ResizeReportView(true);
4616 void wxGenericListCtrl::CreateHeaderWindow()
4618 m_headerWin
= new wxListHeaderWindow
4620 this, wxID_ANY
, m_mainWin
,
4622 wxSize(GetClientSize().x
, m_headerHeight
),
4625 CalculateAndSetHeaderHeight();
4628 bool wxGenericListCtrl::Create(wxWindow
*parent
,
4633 const wxValidator
&validator
,
4634 const wxString
&name
)
4638 m_imageListState
= (wxImageListType
*) NULL
;
4639 m_ownsImageListNormal
=
4640 m_ownsImageListSmall
=
4641 m_ownsImageListState
= false;
4643 m_mainWin
= (wxListMainWindow
*) NULL
;
4644 m_headerWin
= (wxListHeaderWindow
*) NULL
;
4648 if ( !(style
& wxLC_MASK_TYPE
) )
4650 style
= style
| wxLC_LIST
;
4653 if ( !wxControl::Create( parent
, id
, pos
, size
, style
, validator
, name
) )
4656 // don't create the inner window with the border
4657 style
&= ~wxBORDER_MASK
;
4659 m_mainWin
= new wxListMainWindow( this, wxID_ANY
, wxPoint(0,0), size
, style
);
4661 #if defined( __WXMAC__ ) && __WXMAC_CARBON__
4663 font
.MacCreateThemeFont( kThemeViewsFont
) ;
4666 if ( InReportView() )
4668 CreateHeaderWindow();
4670 if ( HasFlag(wxLC_NO_HEADER
) )
4672 // VZ: why do we create it at all then?
4673 m_headerWin
->Show( false );
4682 void wxGenericListCtrl::SetSingleStyle( long style
, bool add
)
4684 wxASSERT_MSG( !(style
& wxLC_VIRTUAL
),
4685 _T("wxLC_VIRTUAL can't be [un]set") );
4687 long flag
= GetWindowStyle();
4691 if (style
& wxLC_MASK_TYPE
)
4692 flag
&= ~(wxLC_MASK_TYPE
| wxLC_VIRTUAL
);
4693 if (style
& wxLC_MASK_ALIGN
)
4694 flag
&= ~wxLC_MASK_ALIGN
;
4695 if (style
& wxLC_MASK_SORT
)
4696 flag
&= ~wxLC_MASK_SORT
;
4708 SetWindowStyleFlag( flag
);
4711 void wxGenericListCtrl::SetWindowStyleFlag( long flag
)
4715 m_mainWin
->DeleteEverything();
4717 // has the header visibility changed?
4718 bool hasHeader
= HasHeader();
4719 bool willHaveHeader
= (flag
& wxLC_REPORT
) && !(flag
& wxLC_NO_HEADER
);
4721 if ( hasHeader
!= willHaveHeader
)
4728 // don't delete, just hide, as we can reuse it later
4729 m_headerWin
->Show(false);
4731 //else: nothing to do
4733 else // must show header
4737 CreateHeaderWindow();
4739 else // already have it, just show
4741 m_headerWin
->Show( true );
4745 ResizeReportView(willHaveHeader
);
4749 wxWindow::SetWindowStyleFlag( flag
);
4752 bool wxGenericListCtrl::GetColumn(int col
, wxListItem
&item
) const
4754 m_mainWin
->GetColumn( col
, item
);
4758 bool wxGenericListCtrl::SetColumn( int col
, wxListItem
& item
)
4760 m_mainWin
->SetColumn( col
, item
);
4764 int wxGenericListCtrl::GetColumnWidth( int col
) const
4766 return m_mainWin
->GetColumnWidth( col
);
4769 bool wxGenericListCtrl::SetColumnWidth( int col
, int width
)
4771 m_mainWin
->SetColumnWidth( col
, width
);
4775 int wxGenericListCtrl::GetCountPerPage() const
4777 return m_mainWin
->GetCountPerPage(); // different from Windows ?
4780 bool wxGenericListCtrl::GetItem( wxListItem
&info
) const
4782 m_mainWin
->GetItem( info
);
4786 bool wxGenericListCtrl::SetItem( wxListItem
&info
)
4788 m_mainWin
->SetItem( info
);
4792 long wxGenericListCtrl::SetItem( long index
, int col
, const wxString
& label
, int imageId
)
4795 info
.m_text
= label
;
4796 info
.m_mask
= wxLIST_MASK_TEXT
;
4797 info
.m_itemId
= index
;
4801 info
.m_image
= imageId
;
4802 info
.m_mask
|= wxLIST_MASK_IMAGE
;
4804 m_mainWin
->SetItem(info
);
4808 int wxGenericListCtrl::GetItemState( long item
, long stateMask
) const
4810 return m_mainWin
->GetItemState( item
, stateMask
);
4813 bool wxGenericListCtrl::SetItemState( long item
, long state
, long stateMask
)
4815 m_mainWin
->SetItemState( item
, state
, stateMask
);
4819 bool wxGenericListCtrl::SetItemImage( long item
, int image
, int WXUNUSED(selImage
) )
4822 info
.m_image
= image
;
4823 info
.m_mask
= wxLIST_MASK_IMAGE
;
4824 info
.m_itemId
= item
;
4825 m_mainWin
->SetItem( info
);
4829 wxString
wxGenericListCtrl::GetItemText( long item
) const
4831 return m_mainWin
->GetItemText(item
);
4834 void wxGenericListCtrl::SetItemText( long item
, const wxString
& str
)
4836 m_mainWin
->SetItemText(item
, str
);
4839 long wxGenericListCtrl::GetItemData( long item
) const
4842 info
.m_itemId
= item
;
4843 m_mainWin
->GetItem( info
);
4847 bool wxGenericListCtrl::SetItemData( long item
, long data
)
4850 info
.m_mask
= wxLIST_MASK_DATA
;
4851 info
.m_itemId
= item
;
4853 m_mainWin
->SetItem( info
);
4857 wxRect
wxGenericListCtrl::GetViewRect() const
4859 return m_mainWin
->GetViewRect();
4862 bool wxGenericListCtrl::GetItemRect( long item
, wxRect
&rect
, int WXUNUSED(code
) ) const
4864 m_mainWin
->GetItemRect( item
, rect
);
4865 if ( m_mainWin
->HasHeader() )
4866 rect
.y
+= m_headerHeight
+ 1;
4870 bool wxGenericListCtrl::GetItemPosition( long item
, wxPoint
& pos
) const
4872 m_mainWin
->GetItemPosition( item
, pos
);
4876 bool wxGenericListCtrl::SetItemPosition( long WXUNUSED(item
), const wxPoint
& WXUNUSED(pos
) )
4881 int wxGenericListCtrl::GetItemCount() const
4883 return m_mainWin
->GetItemCount();
4886 int wxGenericListCtrl::GetColumnCount() const
4888 return m_mainWin
->GetColumnCount();
4891 void wxGenericListCtrl::SetItemSpacing( int spacing
, bool isSmall
)
4893 m_mainWin
->SetItemSpacing( spacing
, isSmall
);
4896 wxSize
wxGenericListCtrl::GetItemSpacing() const
4898 const int spacing
= m_mainWin
->GetItemSpacing(HasFlag(wxLC_SMALL_ICON
));
4900 return wxSize(spacing
, spacing
);
4903 int wxGenericListCtrl::GetItemSpacing( bool isSmall
) const
4905 return m_mainWin
->GetItemSpacing( isSmall
);
4908 void wxGenericListCtrl::SetItemTextColour( long item
, const wxColour
&col
)
4911 info
.m_itemId
= item
;
4912 info
.SetTextColour( col
);
4913 m_mainWin
->SetItem( info
);
4916 wxColour
wxGenericListCtrl::GetItemTextColour( long item
) const
4919 info
.m_itemId
= item
;
4920 m_mainWin
->GetItem( info
);
4921 return info
.GetTextColour();
4924 void wxGenericListCtrl::SetItemBackgroundColour( long item
, const wxColour
&col
)
4927 info
.m_itemId
= item
;
4928 info
.SetBackgroundColour( col
);
4929 m_mainWin
->SetItem( info
);
4932 wxColour
wxGenericListCtrl::GetItemBackgroundColour( long item
) const
4935 info
.m_itemId
= item
;
4936 m_mainWin
->GetItem( info
);
4937 return info
.GetBackgroundColour();
4940 int wxGenericListCtrl::GetSelectedItemCount() const
4942 return m_mainWin
->GetSelectedItemCount();
4945 wxColour
wxGenericListCtrl::GetTextColour() const
4947 return GetForegroundColour();
4950 void wxGenericListCtrl::SetTextColour(const wxColour
& col
)
4952 SetForegroundColour(col
);
4955 long wxGenericListCtrl::GetTopItem() const
4958 m_mainWin
->GetVisibleLinesRange(&top
, NULL
);
4962 long wxGenericListCtrl::GetNextItem( long item
, int geom
, int state
) const
4964 return m_mainWin
->GetNextItem( item
, geom
, state
);
4967 wxImageListType
*wxGenericListCtrl::GetImageList(int which
) const
4969 if (which
== wxIMAGE_LIST_NORMAL
)
4971 return m_imageListNormal
;
4973 else if (which
== wxIMAGE_LIST_SMALL
)
4975 return m_imageListSmall
;
4977 else if (which
== wxIMAGE_LIST_STATE
)
4979 return m_imageListState
;
4981 return (wxImageListType
*) NULL
;
4984 void wxGenericListCtrl::SetImageList( wxImageListType
*imageList
, int which
)
4986 if ( which
== wxIMAGE_LIST_NORMAL
)
4988 if (m_ownsImageListNormal
) delete m_imageListNormal
;
4989 m_imageListNormal
= imageList
;
4990 m_ownsImageListNormal
= false;
4992 else if ( which
== wxIMAGE_LIST_SMALL
)
4994 if (m_ownsImageListSmall
) delete m_imageListSmall
;
4995 m_imageListSmall
= imageList
;
4996 m_ownsImageListSmall
= false;
4998 else if ( which
== wxIMAGE_LIST_STATE
)
5000 if (m_ownsImageListState
) delete m_imageListState
;
5001 m_imageListState
= imageList
;
5002 m_ownsImageListState
= false;
5005 m_mainWin
->SetImageList( imageList
, which
);
5008 void wxGenericListCtrl::AssignImageList(wxImageListType
*imageList
, int which
)
5010 SetImageList(imageList
, which
);
5011 if ( which
== wxIMAGE_LIST_NORMAL
)
5012 m_ownsImageListNormal
= true;
5013 else if ( which
== wxIMAGE_LIST_SMALL
)
5014 m_ownsImageListSmall
= true;
5015 else if ( which
== wxIMAGE_LIST_STATE
)
5016 m_ownsImageListState
= true;
5019 bool wxGenericListCtrl::Arrange( int WXUNUSED(flag
) )
5024 bool wxGenericListCtrl::DeleteItem( long item
)
5026 m_mainWin
->DeleteItem( item
);
5030 bool wxGenericListCtrl::DeleteAllItems()
5032 m_mainWin
->DeleteAllItems();
5036 bool wxGenericListCtrl::DeleteAllColumns()
5038 size_t count
= m_mainWin
->m_columns
.GetCount();
5039 for ( size_t n
= 0; n
< count
; n
++ )
5045 void wxGenericListCtrl::ClearAll()
5047 m_mainWin
->DeleteEverything();
5050 bool wxGenericListCtrl::DeleteColumn( int col
)
5052 m_mainWin
->DeleteColumn( col
);
5054 // if we don't have the header any longer, we need to relayout the window
5055 if ( !GetColumnCount() )
5057 ResizeReportView(false /* no header */);
5063 void wxGenericListCtrl::Edit( long item
)
5065 m_mainWin
->EditLabel( item
);
5068 bool wxGenericListCtrl::EnsureVisible( long item
)
5070 m_mainWin
->EnsureVisible( item
);
5074 long wxGenericListCtrl::FindItem( long start
, const wxString
& str
, bool partial
)
5076 return m_mainWin
->FindItem( start
, str
, partial
);
5079 long wxGenericListCtrl::FindItem( long start
, long data
)
5081 return m_mainWin
->FindItem( start
, data
);
5084 long wxGenericListCtrl::FindItem( long WXUNUSED(start
), const wxPoint
& pt
,
5085 int WXUNUSED(direction
))
5087 return m_mainWin
->FindItem( pt
);
5090 long wxGenericListCtrl::HitTest( const wxPoint
&point
, int &flags
)
5092 return m_mainWin
->HitTest( (int)point
.x
, (int)point
.y
, flags
);
5095 long wxGenericListCtrl::InsertItem( wxListItem
& info
)
5097 m_mainWin
->InsertItem( info
);
5098 return info
.m_itemId
;
5101 long wxGenericListCtrl::InsertItem( long index
, const wxString
&label
)
5104 info
.m_text
= label
;
5105 info
.m_mask
= wxLIST_MASK_TEXT
;
5106 info
.m_itemId
= index
;
5107 return InsertItem( info
);
5110 long wxGenericListCtrl::InsertItem( long index
, int imageIndex
)
5113 info
.m_mask
= wxLIST_MASK_IMAGE
;
5114 info
.m_image
= imageIndex
;
5115 info
.m_itemId
= index
;
5116 return InsertItem( info
);
5119 long wxGenericListCtrl::InsertItem( long index
, const wxString
&label
, int imageIndex
)
5122 info
.m_text
= label
;
5123 info
.m_image
= imageIndex
;
5124 info
.m_mask
= wxLIST_MASK_TEXT
| wxLIST_MASK_IMAGE
;
5125 info
.m_itemId
= index
;
5126 return InsertItem( info
);
5129 long wxGenericListCtrl::InsertColumn( long col
, wxListItem
&item
)
5131 wxCHECK_MSG( m_headerWin
, -1, _T("can't add column in non report mode") );
5133 m_mainWin
->InsertColumn( col
, item
);
5135 // if we hadn't had header before and have it now we need to relayout the
5137 if ( GetColumnCount() == 1 && m_mainWin
->HasHeader() )
5139 ResizeReportView(true /* have header */);
5142 m_headerWin
->Refresh();
5147 long wxGenericListCtrl::InsertColumn( long col
, const wxString
&heading
,
5148 int format
, int width
)
5151 item
.m_mask
= wxLIST_MASK_TEXT
| wxLIST_MASK_FORMAT
;
5152 item
.m_text
= heading
;
5155 item
.m_mask
|= wxLIST_MASK_WIDTH
;
5156 item
.m_width
= width
;
5158 item
.m_format
= format
;
5160 return InsertColumn( col
, item
);
5163 bool wxGenericListCtrl::ScrollList( int WXUNUSED(dx
), int WXUNUSED(dy
) )
5169 // fn is a function which takes 3 long arguments: item1, item2, data.
5170 // item1 is the long data associated with a first item (NOT the index).
5171 // item2 is the long data associated with a second item (NOT the index).
5172 // data is the same value as passed to SortItems.
5173 // The return value is a negative number if the first item should precede the second
5174 // item, a positive number of the second item should precede the first,
5175 // or zero if the two items are equivalent.
5176 // data is arbitrary data to be passed to the sort function.
5178 bool wxGenericListCtrl::SortItems( wxListCtrlCompare fn
, long data
)
5180 m_mainWin
->SortItems( fn
, data
);
5184 // ----------------------------------------------------------------------------
5186 // ----------------------------------------------------------------------------
5188 void wxGenericListCtrl::OnSize(wxSizeEvent
& WXUNUSED(event
))
5193 ResizeReportView(m_mainWin
->HasHeader());
5195 m_mainWin
->RecalculatePositions();
5198 void wxGenericListCtrl::ResizeReportView(bool showHeader
)
5201 GetClientSize( &cw
, &ch
);
5205 m_headerWin
->SetSize( 0, 0, cw
, m_headerHeight
);
5206 m_mainWin
->SetSize( 0, m_headerHeight
+ 1, cw
, ch
- m_headerHeight
- 1 );
5208 else // no header window
5210 m_mainWin
->SetSize( 0, 0, cw
, ch
);
5214 void wxGenericListCtrl::OnInternalIdle()
5216 wxWindow::OnInternalIdle();
5218 // do it only if needed
5219 if ( !m_mainWin
->m_dirty
)
5222 m_mainWin
->RecalculatePositions();
5225 // ----------------------------------------------------------------------------
5227 // ----------------------------------------------------------------------------
5229 bool wxGenericListCtrl::SetBackgroundColour( const wxColour
&colour
)
5233 m_mainWin
->SetBackgroundColour( colour
);
5234 m_mainWin
->m_dirty
= true;
5240 bool wxGenericListCtrl::SetForegroundColour( const wxColour
&colour
)
5242 if ( !wxWindow::SetForegroundColour( colour
) )
5247 m_mainWin
->SetForegroundColour( colour
);
5248 m_mainWin
->m_dirty
= true;
5253 m_headerWin
->SetForegroundColour( colour
);
5259 bool wxGenericListCtrl::SetFont( const wxFont
&font
)
5261 if ( !wxWindow::SetFont( font
) )
5266 m_mainWin
->SetFont( font
);
5267 m_mainWin
->m_dirty
= true;
5272 m_headerWin
->SetFont( font
);
5273 CalculateAndSetHeaderHeight();
5284 #include "wx/listbox.h"
5289 wxGenericListCtrl::GetClassDefaultAttributes(wxWindowVariant variant
)
5292 // Use the same color scheme as wxListBox
5293 return wxListBox::GetClassDefaultAttributes(variant
);
5295 wxUnusedVar(variant
);
5296 wxVisualAttributes attr
;
5297 attr
.colFg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
5298 attr
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX
);
5299 attr
.font
= wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
5304 // ----------------------------------------------------------------------------
5305 // methods forwarded to m_mainWin
5306 // ----------------------------------------------------------------------------
5308 #if wxUSE_DRAG_AND_DROP
5310 void wxGenericListCtrl::SetDropTarget( wxDropTarget
*dropTarget
)
5312 m_mainWin
->SetDropTarget( dropTarget
);
5315 wxDropTarget
*wxGenericListCtrl::GetDropTarget() const
5317 return m_mainWin
->GetDropTarget();
5320 #endif // wxUSE_DRAG_AND_DROP
5322 bool wxGenericListCtrl::SetCursor( const wxCursor
&cursor
)
5324 return m_mainWin
? m_mainWin
->wxWindow::SetCursor(cursor
) : false;
5327 wxColour
wxGenericListCtrl::GetBackgroundColour() const
5329 return m_mainWin
? m_mainWin
->GetBackgroundColour() : wxColour();
5332 wxColour
wxGenericListCtrl::GetForegroundColour() const
5334 return m_mainWin
? m_mainWin
->GetForegroundColour() : wxColour();
5337 bool wxGenericListCtrl::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
5340 return m_mainWin
->PopupMenu( menu
, x
, y
);
5343 #endif // wxUSE_MENUS
5346 void wxGenericListCtrl::SetFocus()
5348 /* The test in window.cpp fails as we are a composite
5349 window, so it checks against "this", but not m_mainWin. */
5350 if ( FindFocus() != this )
5351 m_mainWin
->SetFocus();
5354 wxSize
wxGenericListCtrl::DoGetBestSize() const
5356 // Something is better than nothing...
5357 // 100x80 is what the MSW version will get from the default
5358 // wxControl::DoGetBestSize
5359 return wxSize(100,80);
5362 // ----------------------------------------------------------------------------
5363 // virtual list control support
5364 // ----------------------------------------------------------------------------
5366 wxString
wxGenericListCtrl::OnGetItemText(long WXUNUSED(item
), long WXUNUSED(col
)) const
5368 // this is a pure virtual function, in fact - which is not really pure
5369 // because the controls which are not virtual don't need to implement it
5370 wxFAIL_MSG( _T("wxGenericListCtrl::OnGetItemText not supposed to be called") );
5372 return wxEmptyString
;
5375 int wxGenericListCtrl::OnGetItemImage(long WXUNUSED(item
)) const
5378 wxFAIL_MSG( _T("wxGenericListCtrl::OnGetItemImage not supposed to be called") );
5384 wxGenericListCtrl::OnGetItemAttr(long WXUNUSED_UNLESS_DEBUG(item
)) const
5386 wxASSERT_MSG( item
>= 0 && item
< GetItemCount(),
5387 _T("invalid item index in OnGetItemAttr()") );
5389 // no attributes by default
5393 void wxGenericListCtrl::SetItemCount(long count
)
5395 wxASSERT_MSG( IsVirtual(), _T("this is for virtual controls only") );
5397 m_mainWin
->SetItemCount(count
);
5400 void wxGenericListCtrl::RefreshItem(long item
)
5402 m_mainWin
->RefreshLine(item
);
5405 void wxGenericListCtrl::RefreshItems(long itemFrom
, long itemTo
)
5407 m_mainWin
->RefreshLines(itemFrom
, itemTo
);
5411 * Generic wxListCtrl is more or less a container for two other
5412 * windows which drawings are done upon. These are namely
5413 * 'm_headerWin' and 'm_mainWin'.
5414 * Here we override 'virtual wxWindow::Refresh()' to mimic the
5415 * behaviour wxListCtrl has under wxMSW.
5417 void wxGenericListCtrl::Refresh(bool eraseBackground
, const wxRect
*rect
)
5421 // The easy case, no rectangle specified.
5423 m_headerWin
->Refresh(eraseBackground
);
5426 m_mainWin
->Refresh(eraseBackground
);
5430 // Refresh the header window
5433 wxRect rectHeader
= m_headerWin
->GetRect();
5434 rectHeader
.Intersect(*rect
);
5435 if (rectHeader
.GetWidth() && rectHeader
.GetHeight())
5438 m_headerWin
->GetPosition(&x
, &y
);
5439 rectHeader
.Offset(-x
, -y
);
5440 m_headerWin
->Refresh(eraseBackground
, &rectHeader
);
5445 // Refresh the main window
5448 wxRect rectMain
= m_mainWin
->GetRect();
5449 rectMain
.Intersect(*rect
);
5450 if (rectMain
.GetWidth() && rectMain
.GetHeight())
5453 m_mainWin
->GetPosition(&x
, &y
);
5454 rectMain
.Offset(-x
, -y
);
5455 m_mainWin
->Refresh(eraseBackground
, &rectMain
);
5461 void wxGenericListCtrl::Freeze()
5463 m_mainWin
->Freeze();
5466 void wxGenericListCtrl::Thaw()
5471 #endif // wxUSE_LISTCTRL