1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/generic/listctrl.cpp
3 // Purpose: generic implementation of wxListCtrl
4 // Author: Robert Roebling
5 // Vadim Zeitlin (virtual list control support)
7 // Copyright: (c) 1998 Robert Roebling
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
13 // 1. we need to implement searching/sorting for virtual controls somehow
14 // 2. when changing selection the lines are refreshed twice
17 // For compilers that support precompilation, includes "wx.h".
18 #include "wx/wxprec.h"
26 #include "wx/listctrl.h"
28 #if (!defined(__WXMSW__) || defined(__WXUNIVERSAL__)) && !defined(__WXMAC__)
29 // if we have a native version, its implementation file does all this
30 IMPLEMENT_DYNAMIC_CLASS(wxListItem
, wxObject
)
31 IMPLEMENT_DYNAMIC_CLASS(wxListView
, wxListCtrl
)
32 IMPLEMENT_DYNAMIC_CLASS(wxListEvent
, wxNotifyEvent
)
34 IMPLEMENT_DYNAMIC_CLASS(wxListCtrl
, wxGenericListCtrl
)
38 #include "wx/scrolwin.h"
40 #include "wx/settings.h"
41 #include "wx/dynarray.h"
42 #include "wx/dcclient.h"
43 #include "wx/dcscreen.h"
47 #include "wx/imaglist.h"
48 #include "wx/selstore.h"
49 #include "wx/renderer.h"
52 #include "wx/mac/private.h"
56 // NOTE: If using the wxListBox visual attributes works everywhere then this can
57 // be removed, as well as the #else case below.
58 #define _USE_VISATTR 0
61 // ----------------------------------------------------------------------------
63 // ----------------------------------------------------------------------------
65 // // the height of the header window (FIXME: should depend on its font!)
66 // static const int HEADER_HEIGHT = 23;
68 static const int SCROLL_UNIT_X
= 15;
70 // the spacing between the lines (in report mode)
71 static const int LINE_SPACING
= 0;
73 // extra margins around the text label
75 static const int EXTRA_WIDTH
= 6;
77 static const int EXTRA_WIDTH
= 4;
79 static const int EXTRA_HEIGHT
= 4;
81 // margin between the window and the items
82 static const int EXTRA_BORDER_X
= 2;
83 static const int EXTRA_BORDER_Y
= 2;
85 // offset for the header window
86 static const int HEADER_OFFSET_X
= 1;
87 static const int HEADER_OFFSET_Y
= 1;
89 // margin between rows of icons in [small] icon view
90 static const int MARGIN_BETWEEN_ROWS
= 6;
92 // when autosizing the columns, add some slack
93 static const int AUTOSIZE_COL_MARGIN
= 10;
95 // default width for the header columns
96 static const int WIDTH_COL_DEFAULT
= 80;
98 // the space between the image and the text in the report mode
99 static const int IMAGE_MARGIN_IN_REPORT_MODE
= 5;
101 // ============================================================================
103 // ============================================================================
105 //-----------------------------------------------------------------------------
106 // wxColWidthInfo (internal)
107 //-----------------------------------------------------------------------------
109 struct wxColWidthInfo
112 bool bNeedsUpdate
; // only set to true when an item whose
113 // width == nMaxWidth is removed
115 wxColWidthInfo(int w
= 0, bool needsUpdate
= false)
118 bNeedsUpdate
= needsUpdate
;
122 WX_DEFINE_ARRAY_PTR(wxColWidthInfo
*, ColWidthArray
);
124 //-----------------------------------------------------------------------------
125 // wxListItemData (internal)
126 //-----------------------------------------------------------------------------
131 wxListItemData(wxListMainWindow
*owner
);
134 void SetItem( const wxListItem
&info
);
135 void SetImage( int image
) { m_image
= image
; }
136 void SetData( wxUIntPtr data
) { m_data
= data
; }
137 void SetPosition( int x
, int y
);
138 void SetSize( int width
, int height
);
140 bool HasText() const { return !m_text
.empty(); }
141 const wxString
& GetText() const { return m_text
; }
142 void SetText(const wxString
& text
) { m_text
= text
; }
144 // we can't use empty string for measuring the string width/height, so
145 // always return something
146 wxString
GetTextForMeasuring() const
148 wxString s
= GetText();
155 bool IsHit( int x
, int y
) const;
159 int GetWidth() const;
160 int GetHeight() const;
162 int GetImage() const { return m_image
; }
163 bool HasImage() const { return GetImage() != -1; }
165 void GetItem( wxListItem
&info
) const;
167 void SetAttr(wxListItemAttr
*attr
) { m_attr
= attr
; }
168 wxListItemAttr
*GetAttr() const { return m_attr
; }
171 // the item image or -1
174 // user data associated with the item
177 // the item coordinates are not used in report mode; instead this pointer is
178 // NULL and the owner window is used to retrieve the item position and size
181 // the list ctrl we are in
182 wxListMainWindow
*m_owner
;
184 // custom attributes or NULL
185 wxListItemAttr
*m_attr
;
188 // common part of all ctors
194 //-----------------------------------------------------------------------------
195 // wxListHeaderData (internal)
196 //-----------------------------------------------------------------------------
198 class wxListHeaderData
: public wxObject
202 wxListHeaderData( const wxListItem
&info
);
203 void SetItem( const wxListItem
&item
);
204 void SetPosition( int x
, int y
);
205 void SetWidth( int w
);
206 void SetState( int state
);
207 void SetFormat( int format
);
208 void SetHeight( int h
);
209 bool HasImage() const;
211 bool HasText() const { return !m_text
.empty(); }
212 const wxString
& GetText() const { return m_text
; }
213 void SetText(const wxString
& text
) { m_text
= text
; }
215 void GetItem( wxListItem
&item
);
217 bool IsHit( int x
, int y
) const;
218 int GetImage() const;
219 int GetWidth() const;
220 int GetFormat() const;
221 int GetState() const;
238 //-----------------------------------------------------------------------------
239 // wxListLineData (internal)
240 //-----------------------------------------------------------------------------
242 WX_DECLARE_EXPORTED_LIST(wxListItemData
, wxListItemDataList
);
243 #include "wx/listimpl.cpp"
244 WX_DEFINE_LIST(wxListItemDataList
)
249 // the list of subitems: only may have more than one item in report mode
250 wxListItemDataList m_items
;
252 // this is not used in report view
264 // the part to be highlighted
265 wxRect m_rectHighlight
;
267 // extend all our rects to be centered inside the one of given width
268 void ExtendWidth(wxCoord w
)
270 wxASSERT_MSG( m_rectAll
.width
<= w
,
271 _T("width can only be increased") );
274 m_rectLabel
.x
= m_rectAll
.x
+ (w
- m_rectLabel
.width
) / 2;
275 m_rectIcon
.x
= m_rectAll
.x
+ (w
- m_rectIcon
.width
) / 2;
276 m_rectHighlight
.x
= m_rectAll
.x
+ (w
- m_rectHighlight
.width
) / 2;
281 // is this item selected? [NB: not used in virtual mode]
284 // back pointer to the list ctrl
285 wxListMainWindow
*m_owner
;
288 wxListLineData(wxListMainWindow
*owner
);
292 WX_CLEAR_LIST(wxListItemDataList
, m_items
);
296 // are we in report mode?
297 inline bool InReportView() const;
299 // are we in virtual report mode?
300 inline bool IsVirtual() const;
302 // these 2 methods shouldn't be called for report view controls, in that
303 // case we determine our position/size ourselves
305 // calculate the size of the line
306 void CalculateSize( wxDC
*dc
, int spacing
);
308 // remember the position this line appears at
309 void SetPosition( int x
, int y
, int spacing
);
313 void SetImage( int image
) { SetImage(0, image
); }
314 int GetImage() const { return GetImage(0); }
315 void SetImage( int index
, int image
);
316 int GetImage( int index
) const;
318 bool HasImage() const { return GetImage() != -1; }
319 bool HasText() const { return !GetText(0).empty(); }
321 void SetItem( int index
, const wxListItem
&info
);
322 void GetItem( int index
, wxListItem
&info
);
324 wxString
GetText(int index
) const;
325 void SetText( int index
, const wxString
& s
);
327 wxListItemAttr
*GetAttr() const;
328 void SetAttr(wxListItemAttr
*attr
);
330 // return true if the highlighting really changed
331 bool Highlight( bool on
);
333 void ReverseHighlight();
335 bool IsHighlighted() const
337 wxASSERT_MSG( !IsVirtual(), _T("unexpected call to IsHighlighted") );
339 return m_highlighted
;
342 // draw the line on the given DC in icon/list mode
343 void Draw( wxDC
*dc
);
345 // the same in report mode
346 void DrawInReportMode( wxDC
*dc
,
348 const wxRect
& rectHL
,
352 // set the line to contain num items (only can be > 1 in report mode)
353 void InitItems( int num
);
355 // get the mode (i.e. style) of the list control
356 inline int GetMode() const;
358 // prepare the DC for drawing with these item's attributes, return true if
359 // we need to draw the items background to highlight it, false otherwise
360 bool SetAttributes(wxDC
*dc
,
361 const wxListItemAttr
*attr
,
364 // draw the text on the DC with the correct justification; also add an
365 // ellipsis if the text is too large to fit in the current width
366 void DrawTextFormatted(wxDC
*dc
,
367 const wxString
&text
,
370 int yMid
, // this is middle, not top, of the text
374 WX_DECLARE_EXPORTED_OBJARRAY(wxListLineData
, wxListLineDataArray
);
375 #include "wx/arrimpl.cpp"
376 WX_DEFINE_OBJARRAY(wxListLineDataArray
)
378 //-----------------------------------------------------------------------------
379 // wxListHeaderWindow (internal)
380 //-----------------------------------------------------------------------------
382 class wxListHeaderWindow
: public wxWindow
385 wxListMainWindow
*m_owner
;
386 const wxCursor
*m_currentCursor
;
387 wxCursor
*m_resizeCursor
;
390 // column being resized or -1
393 // divider line position in logical (unscrolled) coords
396 // minimal position beyond which the divider line
397 // can't be dragged in logical coords
401 wxListHeaderWindow();
403 wxListHeaderWindow( wxWindow
*win
,
405 wxListMainWindow
*owner
,
406 const wxPoint
&pos
= wxDefaultPosition
,
407 const wxSize
&size
= wxDefaultSize
,
409 const wxString
&name
= wxT("wxlistctrlcolumntitles") );
411 virtual ~wxListHeaderWindow();
414 void AdjustDC( wxDC
& dc
);
416 void OnPaint( wxPaintEvent
&event
);
417 void OnMouse( wxMouseEvent
&event
);
418 void OnSetFocus( wxFocusEvent
&event
);
424 // common part of all ctors
427 // generate and process the list event of the given type, return true if
428 // it wasn't vetoed, i.e. if we should proceed
429 bool SendListEvent(wxEventType type
, const wxPoint
& pos
);
431 DECLARE_DYNAMIC_CLASS(wxListHeaderWindow
)
432 DECLARE_EVENT_TABLE()
435 //-----------------------------------------------------------------------------
436 // wxListRenameTimer (internal)
437 //-----------------------------------------------------------------------------
439 class wxListRenameTimer
: public wxTimer
442 wxListMainWindow
*m_owner
;
445 wxListRenameTimer( wxListMainWindow
*owner
);
449 //-----------------------------------------------------------------------------
450 // wxListTextCtrlWrapper: wraps a wxTextCtrl to make it work for inline editing
451 //-----------------------------------------------------------------------------
453 class wxListTextCtrlWrapper
: public wxEvtHandler
456 // NB: text must be a valid object but not Create()d yet
457 wxListTextCtrlWrapper(wxListMainWindow
*owner
,
461 wxTextCtrl
*GetText() const { return m_text
; }
463 void AcceptChangesAndFinish();
466 void OnChar( wxKeyEvent
&event
);
467 void OnKeyUp( wxKeyEvent
&event
);
468 void OnKillFocus( wxFocusEvent
&event
);
470 bool AcceptChanges();
474 wxListMainWindow
*m_owner
;
476 wxString m_startValue
;
479 bool m_aboutToFinish
;
481 DECLARE_EVENT_TABLE()
484 //-----------------------------------------------------------------------------
485 // wxListMainWindow (internal)
486 //-----------------------------------------------------------------------------
488 WX_DECLARE_EXPORTED_LIST(wxListHeaderData
, wxListHeaderDataList
);
489 #include "wx/listimpl.cpp"
490 WX_DEFINE_LIST(wxListHeaderDataList
)
492 class wxListMainWindow
: public wxScrolledWindow
496 wxListMainWindow( wxWindow
*parent
,
498 const wxPoint
& pos
= wxDefaultPosition
,
499 const wxSize
& size
= wxDefaultSize
,
501 const wxString
&name
= _T("listctrlmainwindow") );
503 virtual ~wxListMainWindow();
505 bool HasFlag(int flag
) const { return m_parent
->HasFlag(flag
); }
507 // return true if this is a virtual list control
508 bool IsVirtual() const { return HasFlag(wxLC_VIRTUAL
); }
510 // return true if the control is in report mode
511 bool InReportView() const { return HasFlag(wxLC_REPORT
); }
513 // return true if we are in single selection mode, false if multi sel
514 bool IsSingleSel() const { return HasFlag(wxLC_SINGLE_SEL
); }
516 // do we have a header window?
517 bool HasHeader() const
518 { return InReportView() && !HasFlag(wxLC_NO_HEADER
); }
520 void HighlightAll( bool on
);
522 // all these functions only do something if the line is currently visible
524 // change the line "selected" state, return true if it really changed
525 bool HighlightLine( size_t line
, bool highlight
= true);
527 // as HighlightLine() but do it for the range of lines: this is incredibly
528 // more efficient for virtual list controls!
530 // NB: unlike HighlightLine() this one does refresh the lines on screen
531 void HighlightLines( size_t lineFrom
, size_t lineTo
, bool on
= true );
533 // toggle the line state and refresh it
534 void ReverseHighlight( size_t line
)
535 { HighlightLine(line
, !IsHighlighted(line
)); RefreshLine(line
); }
537 // return true if the line is highlighted
538 bool IsHighlighted(size_t line
) const;
540 // refresh one or several lines at once
541 void RefreshLine( size_t line
);
542 void RefreshLines( size_t lineFrom
, size_t lineTo
);
544 // refresh all selected items
545 void RefreshSelected();
547 // refresh all lines below the given one: the difference with
548 // RefreshLines() is that the index here might not be a valid one (happens
549 // when the last line is deleted)
550 void RefreshAfter( size_t lineFrom
);
552 // the methods which are forwarded to wxListLineData itself in list/icon
553 // modes but are here because the lines don't store their positions in the
556 // get the bound rect for the entire line
557 wxRect
GetLineRect(size_t line
) const;
559 // get the bound rect of the label
560 wxRect
GetLineLabelRect(size_t line
) const;
562 // get the bound rect of the items icon (only may be called if we do have
564 wxRect
GetLineIconRect(size_t line
) const;
566 // get the rect to be highlighted when the item has focus
567 wxRect
GetLineHighlightRect(size_t line
) const;
569 // get the size of the total line rect
570 wxSize
GetLineSize(size_t line
) const
571 { return GetLineRect(line
).GetSize(); }
573 // return the hit code for the corresponding position (in this line)
574 long HitTestLine(size_t line
, int x
, int y
) const;
576 // bring the selected item into view, scrolling to it if necessary
577 void MoveToItem(size_t item
);
579 // bring the current item into view
580 void MoveToFocus() { MoveToItem(m_current
); }
582 // start editing the label of the given item
583 wxTextCtrl
*EditLabel(long item
,
584 wxClassInfo
* textControlClass
= CLASSINFO(wxTextCtrl
));
585 wxTextCtrl
*GetEditControl() const
587 return m_textctrlWrapper
? m_textctrlWrapper
->GetText() : NULL
;
590 void FinishEditing(wxTextCtrl
*text
)
593 m_textctrlWrapper
= NULL
;
594 SetFocusIgnoringChildren();
597 // suspend/resume redrawing the control
601 void OnRenameTimer();
602 bool OnRenameAccept(size_t itemEdit
, const wxString
& value
);
603 void OnRenameCancelled(size_t itemEdit
);
605 void OnMouse( wxMouseEvent
&event
);
607 // called to switch the selection from the current item to newCurrent,
608 void OnArrowChar( size_t newCurrent
, const wxKeyEvent
& event
);
610 void OnChar( wxKeyEvent
&event
);
611 void OnKeyDown( wxKeyEvent
&event
);
612 void OnKeyUp( wxKeyEvent
&event
);
613 void OnSetFocus( wxFocusEvent
&event
);
614 void OnKillFocus( wxFocusEvent
&event
);
615 void OnScroll( wxScrollWinEvent
& event
);
617 void OnPaint( wxPaintEvent
&event
);
619 void DrawImage( int index
, wxDC
*dc
, int x
, int y
);
620 void GetImageSize( int index
, int &width
, int &height
) const;
621 int GetTextLength( const wxString
&s
) const;
623 void SetImageList( wxImageList
*imageList
, int which
);
624 void SetItemSpacing( int spacing
, bool isSmall
= false );
625 int GetItemSpacing( bool isSmall
= false );
627 void SetColumn( int col
, wxListItem
&item
);
628 void SetColumnWidth( int col
, int width
);
629 void GetColumn( int col
, wxListItem
&item
) const;
630 int GetColumnWidth( int col
) const;
631 int GetColumnCount() const { return m_columns
.GetCount(); }
633 // returns the sum of the heights of all columns
634 int GetHeaderWidth() const;
636 int GetCountPerPage() const;
638 void SetItem( wxListItem
&item
);
639 void GetItem( wxListItem
&item
) const;
640 void SetItemState( long item
, long state
, long stateMask
);
641 void SetItemStateAll( long state
, long stateMask
);
642 int GetItemState( long item
, long stateMask
) const;
643 void GetItemRect( long index
, wxRect
&rect
) const;
644 wxRect
GetViewRect() const;
645 bool GetItemPosition( long item
, wxPoint
& pos
) const;
646 int GetSelectedItemCount() const;
648 wxString
GetItemText(long item
) const
651 info
.m_mask
= wxLIST_MASK_TEXT
;
652 info
.m_itemId
= item
;
657 void SetItemText(long item
, const wxString
& value
)
660 info
.m_mask
= wxLIST_MASK_TEXT
;
661 info
.m_itemId
= item
;
666 // set the scrollbars and update the positions of the items
667 void RecalculatePositions(bool noRefresh
= false);
669 // refresh the window and the header
672 long GetNextItem( long item
, int geometry
, int state
) const;
673 void DeleteItem( long index
);
674 void DeleteAllItems();
675 void DeleteColumn( int col
);
676 void DeleteEverything();
677 void EnsureVisible( long index
);
678 long FindItem( long start
, const wxString
& str
, bool partial
= false );
679 long FindItem( long start
, wxUIntPtr data
);
680 long FindItem( const wxPoint
& pt
);
681 long HitTest( int x
, int y
, int &flags
) const;
682 void InsertItem( wxListItem
&item
);
683 void InsertColumn( long col
, wxListItem
&item
);
684 int GetItemWidthWithImage(wxListItem
* item
);
685 void SortItems( wxListCtrlCompare fn
, long data
);
687 size_t GetItemCount() const;
688 bool IsEmpty() const { return GetItemCount() == 0; }
689 void SetItemCount(long count
);
691 // change the current (== focused) item, send a notification event
692 void ChangeCurrent(size_t current
);
693 void ResetCurrent() { ChangeCurrent((size_t)-1); }
694 bool HasCurrent() const { return m_current
!= (size_t)-1; }
696 // send out a wxListEvent
697 void SendNotify( size_t line
,
699 const wxPoint
& point
= wxDefaultPosition
);
701 // override base class virtual to reset m_lineHeight when the font changes
702 virtual bool SetFont(const wxFont
& font
)
704 if ( !wxScrolledWindow::SetFont(font
) )
712 // these are for wxListLineData usage only
714 // get the backpointer to the list ctrl
715 wxGenericListCtrl
*GetListCtrl() const
717 return wxStaticCast(GetParent(), wxGenericListCtrl
);
720 // get the height of all lines (assuming they all do have the same height)
721 wxCoord
GetLineHeight() const;
723 // get the y position of the given line (only for report view)
724 wxCoord
GetLineY(size_t line
) const;
726 // get the brush to use for the item highlighting
727 wxBrush
*GetHighlightBrush() const
729 return m_hasFocus
? m_highlightBrush
: m_highlightUnfocusedBrush
;
732 bool HasFocus() const
738 // the array of all line objects for a non virtual list control (for the
739 // virtual list control we only ever use m_lines[0])
740 wxListLineDataArray m_lines
;
742 // the list of column objects
743 wxListHeaderDataList m_columns
;
745 // currently focused item or -1
748 // the number of lines per page
751 // this flag is set when something which should result in the window
752 // redrawing happens (i.e. an item was added or deleted, or its appearance
753 // changed) and OnPaint() doesn't redraw the window while it is set which
754 // allows to minimize the number of repaintings when a lot of items are
755 // being added. The real repainting occurs only after the next OnIdle()
759 wxColour
*m_highlightColour
;
760 wxImageList
*m_small_image_list
;
761 wxImageList
*m_normal_image_list
;
763 int m_normal_spacing
;
767 wxTimer
*m_renameTimer
;
771 ColWidthArray m_aColWidths
;
773 // for double click logic
774 size_t m_lineLastClicked
,
775 m_lineBeforeLastClicked
,
776 m_lineSelectSingleOnUp
;
779 wxWindow
*GetMainWindowOfCompositeControl() { return GetParent(); }
781 // the total count of items in a virtual list control
784 // the object maintaining the items selection state, only used in virtual
786 wxSelectionStore m_selStore
;
788 // common part of all ctors
791 // get the line data for the given index
792 wxListLineData
*GetLine(size_t n
) const
794 wxASSERT_MSG( n
!= (size_t)-1, _T("invalid line index") );
798 wxConstCast(this, wxListMainWindow
)->CacheLineData(n
);
805 // get a dummy line which can be used for geometry calculations and such:
806 // you must use GetLine() if you want to really draw the line
807 wxListLineData
*GetDummyLine() const;
809 // cache the line data of the n-th line in m_lines[0]
810 void CacheLineData(size_t line
);
812 // get the range of visible lines
813 void GetVisibleLinesRange(size_t *from
, size_t *to
);
815 // force us to recalculate the range of visible lines
816 void ResetVisibleLinesRange() { m_lineFrom
= (size_t)-1; }
818 // get the colour to be used for drawing the rules
819 wxColour
GetRuleColour() const
821 return wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT
);
825 // initialize the current item if needed
826 void UpdateCurrent();
828 // delete all items but don't refresh: called from dtor
829 void DoDeleteAllItems();
831 // the height of one line using the current font
832 wxCoord m_lineHeight
;
834 // the total header width or 0 if not calculated yet
835 wxCoord m_headerWidth
;
837 // the first and last lines being shown on screen right now (inclusive),
838 // both may be -1 if they must be calculated so never access them directly:
839 // use GetVisibleLinesRange() above instead
843 // the brushes to use for item highlighting when we do/don't have focus
844 wxBrush
*m_highlightBrush
,
845 *m_highlightUnfocusedBrush
;
847 // if this is > 0, the control is frozen and doesn't redraw itself
848 size_t m_freezeCount
;
850 // wrapper around the text control currently used for in place editing or
851 // NULL if no item is being edited
852 wxListTextCtrlWrapper
*m_textctrlWrapper
;
855 DECLARE_DYNAMIC_CLASS(wxListMainWindow
)
856 DECLARE_EVENT_TABLE()
858 friend class wxGenericListCtrl
;
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() )
872 void wxListItemData::Init()
880 wxListItemData::wxListItemData(wxListMainWindow
*owner
)
886 if ( owner
->InReportView() )
892 void wxListItemData::SetItem( const wxListItem
&info
)
894 if ( info
.m_mask
& wxLIST_MASK_TEXT
)
895 SetText(info
.m_text
);
896 if ( info
.m_mask
& wxLIST_MASK_IMAGE
)
897 m_image
= info
.m_image
;
898 if ( info
.m_mask
& wxLIST_MASK_DATA
)
899 m_data
= info
.m_data
;
901 if ( info
.HasAttributes() )
904 m_attr
->AssignFrom(*info
.GetAttributes());
906 m_attr
= new wxListItemAttr(*info
.GetAttributes());
914 m_rect
->width
= info
.m_width
;
918 void wxListItemData::SetPosition( int x
, int y
)
920 wxCHECK_RET( m_rect
, _T("unexpected SetPosition() call") );
926 void wxListItemData::SetSize( int width
, int height
)
928 wxCHECK_RET( m_rect
, _T("unexpected SetSize() call") );
931 m_rect
->width
= width
;
933 m_rect
->height
= height
;
936 bool wxListItemData::IsHit( int x
, int y
) const
938 wxCHECK_MSG( m_rect
, false, _T("can't be called in this mode") );
940 return wxRect(GetX(), GetY(), GetWidth(), GetHeight()).Contains(x
, y
);
943 int wxListItemData::GetX() const
945 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
950 int wxListItemData::GetY() const
952 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
957 int wxListItemData::GetWidth() const
959 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
961 return m_rect
->width
;
964 int wxListItemData::GetHeight() const
966 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
968 return m_rect
->height
;
971 void wxListItemData::GetItem( wxListItem
&info
) const
973 long mask
= info
.m_mask
;
975 // by default, get everything for backwards compatibility
978 if ( mask
& wxLIST_MASK_TEXT
)
979 info
.m_text
= m_text
;
980 if ( mask
& wxLIST_MASK_IMAGE
)
981 info
.m_image
= m_image
;
982 if ( mask
& wxLIST_MASK_DATA
)
983 info
.m_data
= m_data
;
987 if ( m_attr
->HasTextColour() )
988 info
.SetTextColour(m_attr
->GetTextColour());
989 if ( m_attr
->HasBackgroundColour() )
990 info
.SetBackgroundColour(m_attr
->GetBackgroundColour());
991 if ( m_attr
->HasFont() )
992 info
.SetFont(m_attr
->GetFont());
996 //-----------------------------------------------------------------------------
998 //-----------------------------------------------------------------------------
1000 void wxListHeaderData::Init()
1012 wxListHeaderData::wxListHeaderData()
1017 wxListHeaderData::wxListHeaderData( const wxListItem
&item
)
1024 void wxListHeaderData::SetItem( const wxListItem
&item
)
1026 m_mask
= item
.m_mask
;
1028 if ( m_mask
& wxLIST_MASK_TEXT
)
1029 m_text
= item
.m_text
;
1031 if ( m_mask
& wxLIST_MASK_IMAGE
)
1032 m_image
= item
.m_image
;
1034 if ( m_mask
& wxLIST_MASK_FORMAT
)
1035 m_format
= item
.m_format
;
1037 if ( m_mask
& wxLIST_MASK_WIDTH
)
1038 SetWidth(item
.m_width
);
1040 if ( m_mask
& wxLIST_MASK_STATE
)
1041 SetState(item
.m_state
);
1044 void wxListHeaderData::SetPosition( int x
, int y
)
1050 void wxListHeaderData::SetHeight( int h
)
1055 void wxListHeaderData::SetWidth( int w
)
1057 m_width
= w
< 0 ? WIDTH_COL_DEFAULT
: w
;
1060 void wxListHeaderData::SetState( int flag
)
1065 void wxListHeaderData::SetFormat( int format
)
1070 bool wxListHeaderData::HasImage() const
1072 return m_image
!= -1;
1075 bool wxListHeaderData::IsHit( int x
, int y
) const
1077 return ((x
>= m_xpos
) && (x
<= m_xpos
+m_width
) && (y
>= m_ypos
) && (y
<= m_ypos
+m_height
));
1080 void wxListHeaderData::GetItem( wxListItem
& item
)
1082 item
.m_mask
= m_mask
;
1083 item
.m_text
= m_text
;
1084 item
.m_image
= m_image
;
1085 item
.m_format
= m_format
;
1086 item
.m_width
= m_width
;
1087 item
.m_state
= m_state
;
1090 int wxListHeaderData::GetImage() const
1095 int wxListHeaderData::GetWidth() const
1100 int wxListHeaderData::GetFormat() const
1105 int wxListHeaderData::GetState() const
1110 //-----------------------------------------------------------------------------
1112 //-----------------------------------------------------------------------------
1114 inline int wxListLineData::GetMode() const
1116 return m_owner
->GetListCtrl()->GetWindowStyleFlag() & wxLC_MASK_TYPE
;
1119 inline bool wxListLineData::InReportView() const
1121 return m_owner
->HasFlag(wxLC_REPORT
);
1124 inline bool wxListLineData::IsVirtual() const
1126 return m_owner
->IsVirtual();
1129 wxListLineData::wxListLineData( wxListMainWindow
*owner
)
1133 if ( InReportView() )
1136 m_gi
= new GeometryInfo
;
1138 m_highlighted
= false;
1140 InitItems( GetMode() == wxLC_REPORT
? m_owner
->GetColumnCount() : 1 );
1143 void wxListLineData::CalculateSize( wxDC
*dc
, int spacing
)
1145 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1146 wxCHECK_RET( node
, _T("no subitems at all??") );
1148 wxListItemData
*item
= node
->GetData();
1153 switch ( GetMode() )
1156 case wxLC_SMALL_ICON
:
1157 m_gi
->m_rectAll
.width
= spacing
;
1159 s
= item
->GetText();
1164 m_gi
->m_rectLabel
.width
=
1165 m_gi
->m_rectLabel
.height
= 0;
1169 dc
->GetTextExtent( s
, &lw
, &lh
);
1173 m_gi
->m_rectAll
.height
= spacing
+ lh
;
1175 m_gi
->m_rectAll
.width
= lw
;
1177 m_gi
->m_rectLabel
.width
= lw
;
1178 m_gi
->m_rectLabel
.height
= lh
;
1181 if (item
->HasImage())
1184 m_owner
->GetImageSize( item
->GetImage(), w
, h
);
1185 m_gi
->m_rectIcon
.width
= w
+ 8;
1186 m_gi
->m_rectIcon
.height
= h
+ 8;
1188 if ( m_gi
->m_rectIcon
.width
> m_gi
->m_rectAll
.width
)
1189 m_gi
->m_rectAll
.width
= m_gi
->m_rectIcon
.width
;
1190 if ( m_gi
->m_rectIcon
.height
+ lh
> m_gi
->m_rectAll
.height
- 4 )
1191 m_gi
->m_rectAll
.height
= m_gi
->m_rectIcon
.height
+ lh
+ 4;
1194 if ( item
->HasText() )
1196 m_gi
->m_rectHighlight
.width
= m_gi
->m_rectLabel
.width
;
1197 m_gi
->m_rectHighlight
.height
= m_gi
->m_rectLabel
.height
;
1199 else // no text, highlight the icon
1201 m_gi
->m_rectHighlight
.width
= m_gi
->m_rectIcon
.width
;
1202 m_gi
->m_rectHighlight
.height
= m_gi
->m_rectIcon
.height
;
1207 s
= item
->GetTextForMeasuring();
1209 dc
->GetTextExtent( s
, &lw
, &lh
);
1213 m_gi
->m_rectLabel
.width
= lw
;
1214 m_gi
->m_rectLabel
.height
= lh
;
1216 m_gi
->m_rectAll
.width
= lw
;
1217 m_gi
->m_rectAll
.height
= lh
;
1219 if (item
->HasImage())
1222 m_owner
->GetImageSize( item
->GetImage(), w
, h
);
1223 m_gi
->m_rectIcon
.width
= w
;
1224 m_gi
->m_rectIcon
.height
= h
;
1226 m_gi
->m_rectAll
.width
+= 4 + w
;
1227 if (h
> m_gi
->m_rectAll
.height
)
1228 m_gi
->m_rectAll
.height
= h
;
1231 m_gi
->m_rectHighlight
.width
= m_gi
->m_rectAll
.width
;
1232 m_gi
->m_rectHighlight
.height
= m_gi
->m_rectAll
.height
;
1236 wxFAIL_MSG( _T("unexpected call to SetSize") );
1240 wxFAIL_MSG( _T("unknown mode") );
1245 void wxListLineData::SetPosition( int x
, int y
, int spacing
)
1247 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1248 wxCHECK_RET( node
, _T("no subitems at all??") );
1250 wxListItemData
*item
= node
->GetData();
1252 switch ( GetMode() )
1255 case wxLC_SMALL_ICON
:
1256 m_gi
->m_rectAll
.x
= x
;
1257 m_gi
->m_rectAll
.y
= y
;
1259 if ( item
->HasImage() )
1261 m_gi
->m_rectIcon
.x
= m_gi
->m_rectAll
.x
+ 4 +
1262 (m_gi
->m_rectAll
.width
- m_gi
->m_rectIcon
.width
) / 2;
1263 m_gi
->m_rectIcon
.y
= m_gi
->m_rectAll
.y
+ 4;
1266 if ( item
->HasText() )
1268 if (m_gi
->m_rectAll
.width
> spacing
)
1269 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ (EXTRA_WIDTH
/2);
1271 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ (EXTRA_WIDTH
/2) + (spacing
/ 2) - (m_gi
->m_rectLabel
.width
/ 2);
1272 m_gi
->m_rectLabel
.y
= m_gi
->m_rectAll
.y
+ m_gi
->m_rectAll
.height
+ 2 - m_gi
->m_rectLabel
.height
;
1273 m_gi
->m_rectHighlight
.x
= m_gi
->m_rectLabel
.x
- 2;
1274 m_gi
->m_rectHighlight
.y
= m_gi
->m_rectLabel
.y
- 2;
1276 else // no text, highlight the icon
1278 m_gi
->m_rectHighlight
.x
= m_gi
->m_rectIcon
.x
- 4;
1279 m_gi
->m_rectHighlight
.y
= m_gi
->m_rectIcon
.y
- 4;
1284 m_gi
->m_rectAll
.x
= x
;
1285 m_gi
->m_rectAll
.y
= y
;
1287 m_gi
->m_rectHighlight
.x
= m_gi
->m_rectAll
.x
;
1288 m_gi
->m_rectHighlight
.y
= m_gi
->m_rectAll
.y
;
1289 m_gi
->m_rectLabel
.y
= m_gi
->m_rectAll
.y
+ 2;
1291 if (item
->HasImage())
1293 m_gi
->m_rectIcon
.x
= m_gi
->m_rectAll
.x
+ 2;
1294 m_gi
->m_rectIcon
.y
= m_gi
->m_rectAll
.y
+ 2;
1295 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ 4 + (EXTRA_WIDTH
/2) + m_gi
->m_rectIcon
.width
;
1299 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ (EXTRA_WIDTH
/2);
1304 wxFAIL_MSG( _T("unexpected call to SetPosition") );
1308 wxFAIL_MSG( _T("unknown mode") );
1313 void wxListLineData::InitItems( int num
)
1315 for (int i
= 0; i
< num
; i
++)
1316 m_items
.Append( new wxListItemData(m_owner
) );
1319 void wxListLineData::SetItem( int index
, const wxListItem
&info
)
1321 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1322 wxCHECK_RET( node
, _T("invalid column index in SetItem") );
1324 wxListItemData
*item
= node
->GetData();
1325 item
->SetItem( info
);
1328 void wxListLineData::GetItem( int index
, wxListItem
&info
)
1330 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1333 wxListItemData
*item
= node
->GetData();
1334 item
->GetItem( info
);
1338 wxString
wxListLineData::GetText(int index
) const
1342 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1345 wxListItemData
*item
= node
->GetData();
1346 s
= item
->GetText();
1352 void wxListLineData::SetText( int index
, const wxString
& s
)
1354 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1357 wxListItemData
*item
= node
->GetData();
1362 void wxListLineData::SetImage( int index
, int image
)
1364 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1365 wxCHECK_RET( node
, _T("invalid column index in SetImage()") );
1367 wxListItemData
*item
= node
->GetData();
1368 item
->SetImage(image
);
1371 int wxListLineData::GetImage( int index
) const
1373 wxListItemDataList::compatibility_iterator node
= m_items
.Item( index
);
1374 wxCHECK_MSG( node
, -1, _T("invalid column index in GetImage()") );
1376 wxListItemData
*item
= node
->GetData();
1377 return item
->GetImage();
1380 wxListItemAttr
*wxListLineData::GetAttr() const
1382 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1383 wxCHECK_MSG( node
, NULL
, _T("invalid column index in GetAttr()") );
1385 wxListItemData
*item
= node
->GetData();
1386 return item
->GetAttr();
1389 void wxListLineData::SetAttr(wxListItemAttr
*attr
)
1391 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1392 wxCHECK_RET( node
, _T("invalid column index in SetAttr()") );
1394 wxListItemData
*item
= node
->GetData();
1395 item
->SetAttr(attr
);
1398 bool wxListLineData::SetAttributes(wxDC
*dc
,
1399 const wxListItemAttr
*attr
,
1402 wxWindow
*listctrl
= m_owner
->GetParent();
1406 // don't use foreground colour for drawing highlighted items - this might
1407 // make them completely invisible (and there is no way to do bit
1408 // arithmetics on wxColour, unfortunately)
1413 if (m_owner
->HasFocus()
1415 && IsControlActive( (ControlRef
)m_owner
->GetHandle() )
1423 colText
= wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT
);
1425 else if ( attr
&& attr
->HasTextColour() )
1426 colText
= attr
->GetTextColour();
1428 colText
= listctrl
->GetForegroundColour();
1430 dc
->SetTextForeground(colText
);
1434 if ( attr
&& attr
->HasFont() )
1435 font
= attr
->GetFont();
1437 font
= listctrl
->GetFont();
1442 bool hasBgCol
= attr
&& attr
->HasBackgroundColour();
1443 if ( highlighted
|| hasBgCol
)
1446 dc
->SetBrush( *m_owner
->GetHighlightBrush() );
1448 dc
->SetBrush(wxBrush(attr
->GetBackgroundColour(), wxSOLID
));
1450 dc
->SetPen( *wxTRANSPARENT_PEN
);
1458 void wxListLineData::Draw( wxDC
*dc
)
1460 wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1461 wxCHECK_RET( node
, _T("no subitems at all??") );
1463 bool highlighted
= IsHighlighted();
1465 wxListItemAttr
*attr
= GetAttr();
1467 if ( SetAttributes(dc
, attr
, highlighted
) )
1468 #if ( !defined(__WXGTK20__) && !defined(__WXMAC__) )
1470 dc
->DrawRectangle( m_gi
->m_rectHighlight
);
1476 int flags
= wxCONTROL_SELECTED
;
1477 if (m_owner
->HasFocus()
1479 && IsControlActive( (ControlRef
)m_owner
->GetHandle() )
1482 flags
|= wxCONTROL_FOCUSED
;
1483 wxRendererNative::Get().DrawItemSelectionRect( m_owner
, *dc
, m_gi
->m_rectHighlight
, flags
);
1488 dc
->DrawRectangle( m_gi
->m_rectHighlight
);
1493 // just for debugging to better see where the items are
1495 dc
->SetPen(*wxRED_PEN
);
1496 dc
->SetBrush(*wxTRANSPARENT_BRUSH
);
1497 dc
->DrawRectangle( m_gi
->m_rectAll
);
1498 dc
->SetPen(*wxGREEN_PEN
);
1499 dc
->DrawRectangle( m_gi
->m_rectIcon
);
1502 wxListItemData
*item
= node
->GetData();
1503 if (item
->HasImage())
1505 // centre the image inside our rectangle, this looks nicer when items
1506 // ae aligned in a row
1507 const wxRect
& rectIcon
= m_gi
->m_rectIcon
;
1509 m_owner
->DrawImage(item
->GetImage(), dc
, rectIcon
.x
, rectIcon
.y
);
1512 if (item
->HasText())
1514 const wxRect
& rectLabel
= m_gi
->m_rectLabel
;
1516 wxDCClipper
clipper(*dc
, rectLabel
);
1517 dc
->DrawText(item
->GetText(), rectLabel
.x
, rectLabel
.y
);
1521 void wxListLineData::DrawInReportMode( wxDC
*dc
,
1523 const wxRect
& rectHL
,
1526 // TODO: later we should support setting different attributes for
1527 // different columns - to do it, just add "col" argument to
1528 // GetAttr() and move these lines into the loop below
1529 wxListItemAttr
*attr
= GetAttr();
1530 if ( SetAttributes(dc
, attr
, highlighted
) )
1531 #if ( !defined(__WXGTK20__) && !defined(__WXMAC__) )
1533 dc
->DrawRectangle( rectHL
);
1539 int flags
= wxCONTROL_SELECTED
;
1540 if (m_owner
->HasFocus()
1542 && IsControlActive( (ControlRef
)m_owner
->GetHandle() )
1545 flags
|= wxCONTROL_FOCUSED
;
1546 wxRendererNative::Get().DrawItemSelectionRect( m_owner
, *dc
, rectHL
, flags
);
1550 dc
->DrawRectangle( rectHL
);
1555 wxCoord x
= rect
.x
+ HEADER_OFFSET_X
,
1556 yMid
= rect
.y
+ rect
.height
/2;
1558 // This probably needs to be done
1559 // on all platforms as the icons
1560 // otherwise nearly touch the border
1565 for ( wxListItemDataList::compatibility_iterator node
= m_items
.GetFirst();
1567 node
= node
->GetNext(), col
++ )
1569 wxListItemData
*item
= node
->GetData();
1571 int width
= m_owner
->GetColumnWidth(col
);
1575 if ( item
->HasImage() )
1578 m_owner
->GetImageSize( item
->GetImage(), ix
, iy
);
1579 m_owner
->DrawImage( item
->GetImage(), dc
, xOld
, yMid
- iy
/2 );
1581 ix
+= IMAGE_MARGIN_IN_REPORT_MODE
;
1587 if ( item
->HasText() )
1588 DrawTextFormatted(dc
, item
->GetText(), col
, xOld
, yMid
, width
- 8);
1592 void wxListLineData::DrawTextFormatted(wxDC
*dc
,
1593 const wxString
& textOrig
,
1599 // we don't support displaying multiple lines currently (and neither does
1600 // wxMSW FWIW) so just merge all the lines
1601 wxString
text(textOrig
);
1602 text
.Replace(_T("\n"), _T(" "));
1605 dc
->GetTextExtent(text
, &w
, &h
);
1607 const wxCoord y
= yMid
- (h
+ 1)/2;
1609 wxDCClipper
clipper(*dc
, x
, y
, width
, h
);
1611 // determine if the string can fit inside the current width
1614 // it can, draw it using the items alignment
1616 m_owner
->GetColumn(col
, item
);
1617 switch ( item
.GetAlign() )
1619 case wxLIST_FORMAT_LEFT
:
1623 case wxLIST_FORMAT_RIGHT
:
1627 case wxLIST_FORMAT_CENTER
:
1628 x
+= (width
- w
) / 2;
1632 wxFAIL_MSG( _T("unknown list item format") );
1636 dc
->DrawText(text
, x
, y
);
1638 else // otherwise, truncate and add an ellipsis if possible
1640 // determine the base width
1641 wxString
ellipsis(wxT("..."));
1643 dc
->GetTextExtent(ellipsis
, &base_w
, &h
);
1645 // continue until we have enough space or only one character left
1647 size_t len
= text
.length();
1648 wxString drawntext
= text
.Left(len
);
1651 dc
->GetTextExtent(drawntext
.Last(), &w_c
, &h_c
);
1652 drawntext
.RemoveLast();
1655 if (w
+ base_w
<= width
)
1659 // if still not enough space, remove ellipsis characters
1660 while (ellipsis
.length() > 0 && w
+ base_w
> width
)
1662 ellipsis
= ellipsis
.Left(ellipsis
.length() - 1);
1663 dc
->GetTextExtent(ellipsis
, &base_w
, &h
);
1666 // now draw the text
1667 dc
->DrawText(drawntext
, x
, y
);
1668 dc
->DrawText(ellipsis
, x
+ w
, y
);
1672 bool wxListLineData::Highlight( bool on
)
1674 wxCHECK_MSG( !IsVirtual(), false, _T("unexpected call to Highlight") );
1676 if ( on
== m_highlighted
)
1684 void wxListLineData::ReverseHighlight( void )
1686 Highlight(!IsHighlighted());
1689 //-----------------------------------------------------------------------------
1690 // wxListHeaderWindow
1691 //-----------------------------------------------------------------------------
1693 IMPLEMENT_DYNAMIC_CLASS(wxListHeaderWindow
,wxWindow
)
1695 BEGIN_EVENT_TABLE(wxListHeaderWindow
,wxWindow
)
1696 EVT_PAINT (wxListHeaderWindow::OnPaint
)
1697 EVT_MOUSE_EVENTS (wxListHeaderWindow::OnMouse
)
1698 EVT_SET_FOCUS (wxListHeaderWindow::OnSetFocus
)
1701 void wxListHeaderWindow::Init()
1703 m_currentCursor
= (wxCursor
*) NULL
;
1704 m_isDragging
= false;
1708 wxListHeaderWindow::wxListHeaderWindow()
1712 m_owner
= (wxListMainWindow
*) NULL
;
1713 m_resizeCursor
= (wxCursor
*) NULL
;
1716 wxListHeaderWindow::wxListHeaderWindow( wxWindow
*win
,
1718 wxListMainWindow
*owner
,
1722 const wxString
&name
)
1723 : wxWindow( win
, id
, pos
, size
, style
, name
)
1728 m_resizeCursor
= new wxCursor( wxCURSOR_SIZEWE
);
1731 wxVisualAttributes attr
= wxPanel::GetClassDefaultAttributes();
1732 SetOwnForegroundColour( attr
.colFg
);
1733 SetOwnBackgroundColour( attr
.colBg
);
1735 SetOwnFont( attr
.font
);
1737 SetOwnForegroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
));
1738 SetOwnBackgroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE
));
1740 SetOwnFont( wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
));
1744 wxListHeaderWindow::~wxListHeaderWindow()
1746 delete m_resizeCursor
;
1749 #ifdef __WXUNIVERSAL__
1750 #include "wx/univ/renderer.h"
1751 #include "wx/univ/theme.h"
1754 // shift the DC origin to match the position of the main window horz
1755 // scrollbar: this allows us to always use logical coords
1756 void wxListHeaderWindow::AdjustDC(wxDC
& dc
)
1759 m_owner
->GetScrollPixelsPerUnit( &xpix
, NULL
);
1762 m_owner
->GetViewStart( &view_start
, NULL
);
1767 dc
.GetDeviceOrigin( &org_x
, &org_y
);
1769 // account for the horz scrollbar offset
1771 if (GetLayoutDirection() == wxLayout_RightToLeft
)
1773 // Maybe we just have to check for m_signX
1774 // in the DC, but I leave the #ifdef __WXGTK__
1776 dc
.SetDeviceOrigin( org_x
+ (view_start
* xpix
), org_y
);
1780 dc
.SetDeviceOrigin( org_x
- (view_start
* xpix
), org_y
);
1783 void wxListHeaderWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
1785 wxPaintDC
dc( this );
1790 dc
.SetFont( GetFont() );
1792 // width and height of the entire header window
1794 GetClientSize( &w
, &h
);
1795 m_owner
->CalcUnscrolledPosition(w
, 0, &w
, NULL
);
1797 dc
.SetBackgroundMode(wxTRANSPARENT
);
1798 dc
.SetTextForeground(GetForegroundColour());
1800 int x
= HEADER_OFFSET_X
;
1801 int numColumns
= m_owner
->GetColumnCount();
1803 for ( int i
= 0; i
< numColumns
&& x
< w
; i
++ )
1805 m_owner
->GetColumn( i
, item
);
1806 int wCol
= item
.m_width
;
1808 // the width of the rect to draw: make it smaller to fit entirely
1809 // inside the column rect
1819 if (!m_parent
->IsEnabled())
1820 flags
|= wxCONTROL_DISABLED
;
1822 // NB: The code below is not really Mac-specific, but since we are close
1823 // to 2.8 release and I don't have time to test on other platforms, I
1824 // defined this only for wxMac. If this behavior is desired on
1825 // other platforms, please go ahead and revise or remove the #ifdef.
1827 if ( !m_owner
->IsVirtual() && (item
.m_mask
& wxLIST_MASK_STATE
) &&
1828 (item
.m_state
& wxLIST_STATE_SELECTED
) )
1829 flags
|= wxCONTROL_SELECTED
;
1832 wxRendererNative::Get().DrawHeaderButton
1836 wxRect(x
, HEADER_OFFSET_Y
, cw
, ch
),
1840 // see if we have enough space for the column label
1842 // for this we need the width of the text
1845 dc
.GetTextExtent(item
.GetText(), &wLabel
, &hLabel
);
1846 wLabel
+= 2 * EXTRA_WIDTH
;
1848 // and the width of the icon, if any
1849 static const int MARGIN_BETWEEN_TEXT_AND_ICON
= 2;
1850 int ix
= 0, iy
= 0; // init them just to suppress the compiler warnings
1851 const int image
= item
.m_image
;
1852 wxImageList
*imageList
;
1855 imageList
= m_owner
->m_small_image_list
;
1858 imageList
->GetSize(image
, ix
, iy
);
1859 wLabel
+= ix
+ MARGIN_BETWEEN_TEXT_AND_ICON
;
1867 // ignore alignment if there is not enough space anyhow
1869 switch ( wLabel
< cw
? item
.GetAlign() : wxLIST_FORMAT_LEFT
)
1872 wxFAIL_MSG( _T("unknown list item format") );
1875 case wxLIST_FORMAT_LEFT
:
1879 case wxLIST_FORMAT_RIGHT
:
1880 xAligned
= x
+ cw
- wLabel
;
1883 case wxLIST_FORMAT_CENTER
:
1884 xAligned
= x
+ (cw
- wLabel
) / 2;
1888 // if we have an image, draw it on the right of the label
1895 xAligned
+ wLabel
- ix
- MARGIN_BETWEEN_TEXT_AND_ICON
,
1896 HEADER_OFFSET_Y
+ (h
- 4 - iy
)/2,
1897 wxIMAGELIST_DRAW_TRANSPARENT
1900 cw
-= ix
+ MARGIN_BETWEEN_TEXT_AND_ICON
;
1903 // draw the text clipping it so that it doesn't overwrite the column
1905 wxDCClipper
clipper(dc
, x
, HEADER_OFFSET_Y
, cw
, h
- 4 );
1907 dc
.DrawText( item
.GetText(),
1908 xAligned
+ EXTRA_WIDTH
, h
/ 2 - hLabel
/ 2 ); //HEADER_OFFSET_Y + EXTRA_HEIGHT );
1914 void wxListHeaderWindow::DrawCurrent()
1916 int x1
= m_currentX
;
1918 m_owner
->ClientToScreen( &x1
, &y1
);
1920 int x2
= m_currentX
;
1922 m_owner
->GetClientSize( NULL
, &y2
);
1923 m_owner
->ClientToScreen( &x2
, &y2
);
1926 dc
.SetLogicalFunction( wxINVERT
);
1927 dc
.SetPen( wxPen( *wxBLACK
, 2, wxSOLID
) );
1928 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
1932 dc
.DrawLine( x1
, y1
, x2
, y2
);
1934 dc
.SetLogicalFunction( wxCOPY
);
1936 dc
.SetPen( wxNullPen
);
1937 dc
.SetBrush( wxNullBrush
);
1940 void wxListHeaderWindow::OnMouse( wxMouseEvent
&event
)
1942 // we want to work with logical coords
1944 m_owner
->CalcUnscrolledPosition(event
.GetX(), 0, &x
, NULL
);
1945 int y
= event
.GetY();
1949 SendListEvent(wxEVT_COMMAND_LIST_COL_DRAGGING
, event
.GetPosition());
1951 // we don't draw the line beyond our window, but we allow dragging it
1954 GetClientSize( &w
, NULL
);
1955 m_owner
->CalcUnscrolledPosition(w
, 0, &w
, NULL
);
1958 // erase the line if it was drawn
1959 if ( m_currentX
< w
)
1962 if (event
.ButtonUp())
1965 m_isDragging
= false;
1967 m_owner
->SetColumnWidth( m_column
, m_currentX
- m_minX
);
1968 SendListEvent(wxEVT_COMMAND_LIST_COL_END_DRAG
, event
.GetPosition());
1975 m_currentX
= m_minX
+ 7;
1977 // draw in the new location
1978 if ( m_currentX
< w
)
1982 else // not dragging
1985 bool hit_border
= false;
1987 // end of the current column
1990 // find the column where this event occurred
1992 countCol
= m_owner
->GetColumnCount();
1993 for (col
= 0; col
< countCol
; col
++)
1995 xpos
+= m_owner
->GetColumnWidth( col
);
1998 if ( (abs(x
-xpos
) < 3) && (y
< 22) )
2000 // near the column border
2007 // inside the column
2014 if ( col
== countCol
)
2017 if (event
.LeftDown() || event
.RightUp())
2019 if (hit_border
&& event
.LeftDown())
2021 if ( SendListEvent(wxEVT_COMMAND_LIST_COL_BEGIN_DRAG
,
2022 event
.GetPosition()) )
2024 m_isDragging
= true;
2029 //else: column resizing was vetoed by the user code
2031 else // click on a column
2033 // record the selected state of the columns
2034 if (event
.LeftDown())
2036 for (int i
=0; i
< m_owner
->GetColumnCount(); i
++)
2039 m_owner
->GetColumn(i
, colItem
);
2040 long state
= colItem
.GetState();
2042 colItem
.SetState(state
| wxLIST_STATE_SELECTED
);
2044 colItem
.SetState(state
& ~wxLIST_STATE_SELECTED
);
2045 m_owner
->SetColumn(i
, colItem
);
2049 SendListEvent( event
.LeftDown()
2050 ? wxEVT_COMMAND_LIST_COL_CLICK
2051 : wxEVT_COMMAND_LIST_COL_RIGHT_CLICK
,
2052 event
.GetPosition());
2055 else if (event
.Moving())
2060 setCursor
= m_currentCursor
== wxSTANDARD_CURSOR
;
2061 m_currentCursor
= m_resizeCursor
;
2065 setCursor
= m_currentCursor
!= wxSTANDARD_CURSOR
;
2066 m_currentCursor
= wxSTANDARD_CURSOR
;
2070 SetCursor(*m_currentCursor
);
2075 void wxListHeaderWindow::OnSetFocus( wxFocusEvent
&WXUNUSED(event
) )
2077 m_owner
->SetFocus();
2081 bool wxListHeaderWindow::SendListEvent(wxEventType type
, const wxPoint
& pos
)
2083 wxWindow
*parent
= GetParent();
2084 wxListEvent
le( type
, parent
->GetId() );
2085 le
.SetEventObject( parent
);
2086 le
.m_pointDrag
= pos
;
2088 // the position should be relative to the parent window, not
2089 // this one for compatibility with MSW and common sense: the
2090 // user code doesn't know anything at all about this header
2091 // window, so why should it get positions relative to it?
2092 le
.m_pointDrag
.y
-= GetSize().y
;
2094 le
.m_col
= m_column
;
2095 return !parent
->GetEventHandler()->ProcessEvent( le
) || le
.IsAllowed();
2098 //-----------------------------------------------------------------------------
2099 // wxListRenameTimer (internal)
2100 //-----------------------------------------------------------------------------
2102 wxListRenameTimer::wxListRenameTimer( wxListMainWindow
*owner
)
2107 void wxListRenameTimer::Notify()
2109 m_owner
->OnRenameTimer();
2112 //-----------------------------------------------------------------------------
2113 // wxListTextCtrlWrapper (internal)
2114 //-----------------------------------------------------------------------------
2116 BEGIN_EVENT_TABLE(wxListTextCtrlWrapper
, wxEvtHandler
)
2117 EVT_CHAR (wxListTextCtrlWrapper::OnChar
)
2118 EVT_KEY_UP (wxListTextCtrlWrapper::OnKeyUp
)
2119 EVT_KILL_FOCUS (wxListTextCtrlWrapper::OnKillFocus
)
2122 wxListTextCtrlWrapper::wxListTextCtrlWrapper(wxListMainWindow
*owner
,
2125 : m_startValue(owner
->GetItemText(itemEdit
)),
2126 m_itemEdited(itemEdit
)
2131 m_aboutToFinish
= false;
2133 wxRect rectLabel
= owner
->GetLineLabelRect(itemEdit
);
2135 m_owner
->CalcScrolledPosition(rectLabel
.x
, rectLabel
.y
,
2136 &rectLabel
.x
, &rectLabel
.y
);
2138 m_text
->Create(owner
, wxID_ANY
, m_startValue
,
2139 wxPoint(rectLabel
.x
-4,rectLabel
.y
-4),
2140 wxSize(rectLabel
.width
+11,rectLabel
.height
+8));
2143 m_text
->PushEventHandler(this);
2146 void wxListTextCtrlWrapper::Finish()
2152 m_text
->RemoveEventHandler(this);
2153 m_owner
->FinishEditing(m_text
);
2155 wxPendingDelete
.Append( this );
2159 bool wxListTextCtrlWrapper::AcceptChanges()
2161 const wxString value
= m_text
->GetValue();
2163 if ( value
== m_startValue
)
2164 // nothing changed, always accept
2167 if ( !m_owner
->OnRenameAccept(m_itemEdited
, value
) )
2168 // vetoed by the user
2171 // accepted, do rename the item
2172 m_owner
->SetItemText(m_itemEdited
, value
);
2177 void wxListTextCtrlWrapper::AcceptChangesAndFinish()
2179 m_aboutToFinish
= true;
2181 // Notify the owner about the changes
2184 // Even if vetoed, close the control (consistent with MSW)
2188 void wxListTextCtrlWrapper::OnChar( wxKeyEvent
&event
)
2190 switch ( event
.m_keyCode
)
2193 AcceptChangesAndFinish();
2197 m_owner
->OnRenameCancelled( m_itemEdited
);
2206 void wxListTextCtrlWrapper::OnKeyUp( wxKeyEvent
&event
)
2214 // auto-grow the textctrl:
2215 wxSize parentSize
= m_owner
->GetSize();
2216 wxPoint myPos
= m_text
->GetPosition();
2217 wxSize mySize
= m_text
->GetSize();
2219 m_text
->GetTextExtent(m_text
->GetValue() + _T("MM"), &sx
, &sy
);
2220 if (myPos
.x
+ sx
> parentSize
.x
)
2221 sx
= parentSize
.x
- myPos
.x
;
2224 m_text
->SetSize(sx
, wxDefaultCoord
);
2229 void wxListTextCtrlWrapper::OnKillFocus( wxFocusEvent
&event
)
2231 if ( !m_finished
&& !m_aboutToFinish
)
2233 if ( !AcceptChanges() )
2234 m_owner
->OnRenameCancelled( m_itemEdited
);
2239 // We must let the native text control handle focus
2243 //-----------------------------------------------------------------------------
2245 //-----------------------------------------------------------------------------
2247 IMPLEMENT_DYNAMIC_CLASS(wxListMainWindow
,wxScrolledWindow
)
2249 BEGIN_EVENT_TABLE(wxListMainWindow
,wxScrolledWindow
)
2250 EVT_PAINT (wxListMainWindow::OnPaint
)
2251 EVT_MOUSE_EVENTS (wxListMainWindow::OnMouse
)
2252 EVT_CHAR (wxListMainWindow::OnChar
)
2253 EVT_KEY_DOWN (wxListMainWindow::OnKeyDown
)
2254 EVT_KEY_UP (wxListMainWindow::OnKeyUp
)
2255 EVT_SET_FOCUS (wxListMainWindow::OnSetFocus
)
2256 EVT_KILL_FOCUS (wxListMainWindow::OnKillFocus
)
2257 EVT_SCROLLWIN (wxListMainWindow::OnScroll
)
2260 void wxListMainWindow::Init()
2265 m_lineTo
= (size_t)-1;
2271 m_small_image_list
= (wxImageList
*) NULL
;
2272 m_normal_image_list
= (wxImageList
*) NULL
;
2274 m_small_spacing
= 30;
2275 m_normal_spacing
= 40;
2279 m_isCreated
= false;
2281 m_lastOnSame
= false;
2282 m_renameTimer
= new wxListRenameTimer( this );
2283 m_textctrlWrapper
= NULL
;
2287 m_lineSelectSingleOnUp
=
2288 m_lineBeforeLastClicked
= (size_t)-1;
2293 wxListMainWindow::wxListMainWindow()
2298 m_highlightUnfocusedBrush
= (wxBrush
*) NULL
;
2301 wxListMainWindow::wxListMainWindow( wxWindow
*parent
,
2306 const wxString
&name
)
2307 : wxScrolledWindow( parent
, id
, pos
, size
,
2308 style
| wxHSCROLL
| wxVSCROLL
, name
)
2312 m_highlightBrush
= new wxBrush
2314 wxSystemSettings::GetColour
2316 wxSYS_COLOUR_HIGHLIGHT
2321 m_highlightUnfocusedBrush
= new wxBrush
2323 wxSystemSettings::GetColour
2325 wxSYS_COLOUR_BTNSHADOW
2330 SetScrollbars( 0, 0, 0, 0, 0, 0 );
2332 wxVisualAttributes attr
= wxGenericListCtrl::GetClassDefaultAttributes();
2333 SetOwnForegroundColour( attr
.colFg
);
2334 SetOwnBackgroundColour( attr
.colBg
);
2336 SetOwnFont( attr
.font
);
2339 wxListMainWindow::~wxListMainWindow()
2342 WX_CLEAR_LIST(wxListHeaderDataList
, m_columns
);
2343 WX_CLEAR_ARRAY(m_aColWidths
);
2345 delete m_highlightBrush
;
2346 delete m_highlightUnfocusedBrush
;
2347 delete m_renameTimer
;
2350 void wxListMainWindow::CacheLineData(size_t line
)
2352 wxGenericListCtrl
*listctrl
= GetListCtrl();
2354 wxListLineData
*ld
= GetDummyLine();
2356 size_t countCol
= GetColumnCount();
2357 for ( size_t col
= 0; col
< countCol
; col
++ )
2359 ld
->SetText(col
, listctrl
->OnGetItemText(line
, col
));
2360 ld
->SetImage(col
, listctrl
->OnGetItemColumnImage(line
, col
));
2363 ld
->SetAttr(listctrl
->OnGetItemAttr(line
));
2366 wxListLineData
*wxListMainWindow::GetDummyLine() const
2368 wxASSERT_MSG( !IsEmpty(), _T("invalid line index") );
2369 wxASSERT_MSG( IsVirtual(), _T("GetDummyLine() shouldn't be called") );
2371 wxListMainWindow
*self
= wxConstCast(this, wxListMainWindow
);
2373 // we need to recreate the dummy line if the number of columns in the
2374 // control changed as it would have the incorrect number of fields
2376 if ( !m_lines
.IsEmpty() &&
2377 m_lines
[0].m_items
.GetCount() != (size_t)GetColumnCount() )
2379 self
->m_lines
.Clear();
2382 if ( m_lines
.IsEmpty() )
2384 wxListLineData
*line
= new wxListLineData(self
);
2385 self
->m_lines
.Add(line
);
2387 // don't waste extra memory -- there never going to be anything
2388 // else/more in this array
2389 self
->m_lines
.Shrink();
2395 // ----------------------------------------------------------------------------
2396 // line geometry (report mode only)
2397 // ----------------------------------------------------------------------------
2399 wxCoord
wxListMainWindow::GetLineHeight() const
2401 // we cache the line height as calling GetTextExtent() is slow
2402 if ( !m_lineHeight
)
2404 wxListMainWindow
*self
= wxConstCast(this, wxListMainWindow
);
2406 wxClientDC
dc( self
);
2407 dc
.SetFont( GetFont() );
2410 dc
.GetTextExtent(_T("H"), NULL
, &y
);
2412 if ( m_small_image_list
&& m_small_image_list
->GetImageCount() )
2415 m_small_image_list
->GetSize(0, iw
, ih
);
2420 self
->m_lineHeight
= y
+ LINE_SPACING
;
2423 return m_lineHeight
;
2426 wxCoord
wxListMainWindow::GetLineY(size_t line
) const
2428 wxASSERT_MSG( InReportView(), _T("only works in report mode") );
2430 return LINE_SPACING
+ line
* GetLineHeight();
2433 wxRect
wxListMainWindow::GetLineRect(size_t line
) const
2435 if ( !InReportView() )
2436 return GetLine(line
)->m_gi
->m_rectAll
;
2439 rect
.x
= HEADER_OFFSET_X
;
2440 rect
.y
= GetLineY(line
);
2441 rect
.width
= GetHeaderWidth();
2442 rect
.height
= GetLineHeight();
2447 wxRect
wxListMainWindow::GetLineLabelRect(size_t line
) const
2449 if ( !InReportView() )
2450 return GetLine(line
)->m_gi
->m_rectLabel
;
2453 rect
.x
= HEADER_OFFSET_X
;
2454 rect
.y
= GetLineY(line
);
2455 rect
.width
= GetColumnWidth(0);
2456 rect
.height
= GetLineHeight();
2461 wxRect
wxListMainWindow::GetLineIconRect(size_t line
) const
2463 if ( !InReportView() )
2464 return GetLine(line
)->m_gi
->m_rectIcon
;
2466 wxListLineData
*ld
= GetLine(line
);
2467 wxASSERT_MSG( ld
->HasImage(), _T("should have an image") );
2470 rect
.x
= HEADER_OFFSET_X
;
2471 rect
.y
= GetLineY(line
);
2472 GetImageSize(ld
->GetImage(), rect
.width
, rect
.height
);
2477 wxRect
wxListMainWindow::GetLineHighlightRect(size_t line
) const
2479 return InReportView() ? GetLineRect(line
)
2480 : GetLine(line
)->m_gi
->m_rectHighlight
;
2483 long wxListMainWindow::HitTestLine(size_t line
, int x
, int y
) const
2485 wxASSERT_MSG( line
< GetItemCount(), _T("invalid line in HitTestLine") );
2487 wxListLineData
*ld
= GetLine(line
);
2489 if ( ld
->HasImage() && GetLineIconRect(line
).Contains(x
, y
) )
2490 return wxLIST_HITTEST_ONITEMICON
;
2492 // VS: Testing for "ld->HasText() || InReportView()" instead of
2493 // "ld->HasText()" is needed to make empty lines in report view
2495 if ( ld
->HasText() || InReportView() )
2497 wxRect rect
= InReportView() ? GetLineRect(line
)
2498 : GetLineLabelRect(line
);
2500 if ( rect
.Contains(x
, y
) )
2501 return wxLIST_HITTEST_ONITEMLABEL
;
2507 // ----------------------------------------------------------------------------
2508 // highlight (selection) handling
2509 // ----------------------------------------------------------------------------
2511 bool wxListMainWindow::IsHighlighted(size_t line
) const
2515 return m_selStore
.IsSelected(line
);
2519 wxListLineData
*ld
= GetLine(line
);
2520 wxCHECK_MSG( ld
, false, _T("invalid index in IsHighlighted") );
2522 return ld
->IsHighlighted();
2526 void wxListMainWindow::HighlightLines( size_t lineFrom
,
2532 wxArrayInt linesChanged
;
2533 if ( !m_selStore
.SelectRange(lineFrom
, lineTo
, highlight
,
2536 // meny items changed state, refresh everything
2537 RefreshLines(lineFrom
, lineTo
);
2539 else // only a few items changed state, refresh only them
2541 size_t count
= linesChanged
.GetCount();
2542 for ( size_t n
= 0; n
< count
; n
++ )
2544 RefreshLine(linesChanged
[n
]);
2548 else // iterate over all items in non report view
2550 for ( size_t line
= lineFrom
; line
<= lineTo
; line
++ )
2552 if ( HighlightLine(line
, highlight
) )
2558 bool wxListMainWindow::HighlightLine( size_t line
, bool highlight
)
2564 changed
= m_selStore
.SelectItem(line
, highlight
);
2568 wxListLineData
*ld
= GetLine(line
);
2569 wxCHECK_MSG( ld
, false, _T("invalid index in HighlightLine") );
2571 changed
= ld
->Highlight(highlight
);
2576 SendNotify( line
, highlight
? wxEVT_COMMAND_LIST_ITEM_SELECTED
2577 : wxEVT_COMMAND_LIST_ITEM_DESELECTED
);
2583 void wxListMainWindow::RefreshLine( size_t line
)
2585 if ( InReportView() )
2587 size_t visibleFrom
, visibleTo
;
2588 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2590 if ( line
< visibleFrom
|| line
> visibleTo
)
2594 wxRect rect
= GetLineRect(line
);
2596 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2597 RefreshRect( rect
);
2600 void wxListMainWindow::RefreshLines( size_t lineFrom
, size_t lineTo
)
2602 // we suppose that they are ordered by caller
2603 wxASSERT_MSG( lineFrom
<= lineTo
, _T("indices in disorder") );
2605 wxASSERT_MSG( lineTo
< GetItemCount(), _T("invalid line range") );
2607 if ( InReportView() )
2609 size_t visibleFrom
, visibleTo
;
2610 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2612 if ( lineFrom
< visibleFrom
)
2613 lineFrom
= visibleFrom
;
2614 if ( lineTo
> visibleTo
)
2619 rect
.y
= GetLineY(lineFrom
);
2620 rect
.width
= GetClientSize().x
;
2621 rect
.height
= GetLineY(lineTo
) - rect
.y
+ GetLineHeight();
2623 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2624 RefreshRect( rect
);
2628 // TODO: this should be optimized...
2629 for ( size_t line
= lineFrom
; line
<= lineTo
; line
++ )
2636 void wxListMainWindow::RefreshAfter( size_t lineFrom
)
2638 if ( InReportView() )
2640 size_t visibleFrom
, visibleTo
;
2641 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2643 if ( lineFrom
< visibleFrom
)
2644 lineFrom
= visibleFrom
;
2645 else if ( lineFrom
> visibleTo
)
2650 rect
.y
= GetLineY(lineFrom
);
2651 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2653 wxSize size
= GetClientSize();
2654 rect
.width
= size
.x
;
2656 // refresh till the bottom of the window
2657 rect
.height
= size
.y
- rect
.y
;
2659 RefreshRect( rect
);
2663 // TODO: how to do it more efficiently?
2668 void wxListMainWindow::RefreshSelected()
2674 if ( InReportView() )
2676 GetVisibleLinesRange(&from
, &to
);
2681 to
= GetItemCount() - 1;
2684 if ( HasCurrent() && m_current
>= from
&& m_current
<= to
)
2685 RefreshLine(m_current
);
2687 for ( size_t line
= from
; line
<= to
; line
++ )
2689 // NB: the test works as expected even if m_current == -1
2690 if ( line
!= m_current
&& IsHighlighted(line
) )
2695 void wxListMainWindow::Freeze()
2700 void wxListMainWindow::Thaw()
2702 wxCHECK_RET( m_freezeCount
> 0, _T("thawing unfrozen list control?") );
2704 if ( --m_freezeCount
== 0 )
2708 void wxListMainWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
2710 // Note: a wxPaintDC must be constructed even if no drawing is
2711 // done (a Windows requirement).
2712 wxPaintDC
dc( this );
2714 if ( IsEmpty() || m_freezeCount
)
2715 // nothing to draw or not the moment to draw it
2719 // delay the repainting until we calculate all the items positions
2725 CalcScrolledPosition( 0, 0, &dev_x
, &dev_y
);
2727 dc
.SetFont( GetFont() );
2729 if ( InReportView() )
2731 int lineHeight
= GetLineHeight();
2733 size_t visibleFrom
, visibleTo
;
2734 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2737 int xOrig
= dc
.LogicalToDeviceX( 0 );
2738 int yOrig
= dc
.LogicalToDeviceY( 0 );
2740 // tell the caller cache to cache the data
2743 wxListEvent
evCache(wxEVT_COMMAND_LIST_CACHE_HINT
,
2744 GetParent()->GetId());
2745 evCache
.SetEventObject( GetParent() );
2746 evCache
.m_oldItemIndex
= visibleFrom
;
2747 evCache
.m_itemIndex
= visibleTo
;
2748 GetParent()->GetEventHandler()->ProcessEvent( evCache
);
2751 for ( size_t line
= visibleFrom
; line
<= visibleTo
; line
++ )
2753 rectLine
= GetLineRect(line
);
2756 if ( !IsExposed(rectLine
.x
+ xOrig
, rectLine
.y
+ yOrig
,
2757 rectLine
.width
, rectLine
.height
) )
2759 // don't redraw unaffected lines to avoid flicker
2763 GetLine(line
)->DrawInReportMode( &dc
,
2765 GetLineHighlightRect(line
),
2766 IsHighlighted(line
) );
2769 if ( HasFlag(wxLC_HRULES
) )
2771 wxPen
pen(GetRuleColour(), 1, wxSOLID
);
2772 wxSize clientSize
= GetClientSize();
2774 // Don't draw the first one
2775 for ( size_t i
= visibleFrom
+ 1; i
<= visibleTo
; i
++ )
2778 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
2779 dc
.DrawLine(0 - dev_x
, i
* lineHeight
,
2780 clientSize
.x
- dev_x
, i
* lineHeight
);
2783 // Draw last horizontal rule
2784 if ( visibleTo
== GetItemCount() - 1 )
2787 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
2788 dc
.DrawLine(0 - dev_x
, (m_lineTo
+ 1) * lineHeight
,
2789 clientSize
.x
- dev_x
, (m_lineTo
+ 1) * lineHeight
);
2793 // Draw vertical rules if required
2794 if ( HasFlag(wxLC_VRULES
) && !IsEmpty() )
2796 wxPen
pen(GetRuleColour(), 1, wxSOLID
);
2797 wxRect firstItemRect
, lastItemRect
;
2799 GetItemRect(visibleFrom
, firstItemRect
);
2800 GetItemRect(visibleTo
, lastItemRect
);
2801 int x
= firstItemRect
.GetX();
2803 dc
.SetBrush(* wxTRANSPARENT_BRUSH
);
2805 for (int col
= 0; col
< GetColumnCount(); col
++)
2807 int colWidth
= GetColumnWidth(col
);
2809 dc
.DrawLine(x
- dev_x
- 2, firstItemRect
.GetY() - 1 - dev_y
,
2810 x
- dev_x
- 2, lastItemRect
.GetBottom() + 1 - dev_y
);
2816 size_t count
= GetItemCount();
2817 for ( size_t i
= 0; i
< count
; i
++ )
2819 GetLine(i
)->Draw( &dc
);
2824 // Don't draw rect outline under Mac at all.
2829 wxRect
rect( GetLineHighlightRect( m_current
) );
2831 dc
.SetPen( *wxBLACK_PEN
);
2832 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
2833 dc
.DrawRectangle( rect
);
2835 wxRendererNative::Get().DrawItemSelectionRect( this, dc
, rect
, wxCONTROL_CURRENT
|wxCONTROL_FOCUSED
);
2843 void wxListMainWindow::HighlightAll( bool on
)
2845 if ( IsSingleSel() )
2847 wxASSERT_MSG( !on
, _T("can't do this in a single selection control") );
2849 // we just have one item to turn off
2850 if ( HasCurrent() && IsHighlighted(m_current
) )
2852 HighlightLine(m_current
, false);
2853 RefreshLine(m_current
);
2858 HighlightLines(0, GetItemCount() - 1, on
);
2862 void wxListMainWindow::SendNotify( size_t line
,
2863 wxEventType command
,
2864 const wxPoint
& point
)
2866 wxListEvent
le( command
, GetParent()->GetId() );
2867 le
.SetEventObject( GetParent() );
2869 le
.m_itemIndex
= line
;
2871 // set only for events which have position
2872 if ( point
!= wxDefaultPosition
)
2873 le
.m_pointDrag
= point
;
2875 // don't try to get the line info for virtual list controls: the main
2876 // program has it anyhow and if we did it would result in accessing all
2877 // the lines, even those which are not visible now and this is precisely
2878 // what we're trying to avoid
2881 if ( line
!= (size_t)-1 )
2883 GetLine(line
)->GetItem( 0, le
.m_item
);
2885 //else: this happens for wxEVT_COMMAND_LIST_ITEM_FOCUSED event
2887 //else: there may be no more such item
2889 GetParent()->GetEventHandler()->ProcessEvent( le
);
2892 void wxListMainWindow::ChangeCurrent(size_t current
)
2894 m_current
= current
;
2896 // as the current item changed, we shouldn't start editing it when the
2897 // "slow click" timer expires as the click happened on another item
2898 if ( m_renameTimer
->IsRunning() )
2899 m_renameTimer
->Stop();
2901 SendNotify(current
, wxEVT_COMMAND_LIST_ITEM_FOCUSED
);
2904 wxTextCtrl
*wxListMainWindow::EditLabel(long item
, wxClassInfo
* textControlClass
)
2906 wxCHECK_MSG( (item
>= 0) && ((size_t)item
< GetItemCount()), NULL
,
2907 wxT("wrong index in wxGenericListCtrl::EditLabel()") );
2909 wxASSERT_MSG( textControlClass
->IsKindOf(CLASSINFO(wxTextCtrl
)),
2910 wxT("EditLabel() needs a text control") );
2912 size_t itemEdit
= (size_t)item
;
2914 wxListEvent
le( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT
, GetParent()->GetId() );
2915 le
.SetEventObject( GetParent() );
2916 le
.m_itemIndex
= item
;
2917 wxListLineData
*data
= GetLine(itemEdit
);
2918 wxCHECK_MSG( data
, NULL
, _T("invalid index in EditLabel()") );
2919 data
->GetItem( 0, le
.m_item
);
2921 if ( GetParent()->GetEventHandler()->ProcessEvent( le
) && !le
.IsAllowed() )
2923 // vetoed by user code
2927 // We have to call this here because the label in question might just have
2928 // been added and no screen update taken place.
2933 // Pending events dispatched by wxSafeYield might have changed the item
2935 if ( (size_t)item
>= GetItemCount() )
2939 wxTextCtrl
* const text
= (wxTextCtrl
*)textControlClass
->CreateObject();
2940 m_textctrlWrapper
= new wxListTextCtrlWrapper(this, text
, item
);
2941 return m_textctrlWrapper
->GetText();
2944 void wxListMainWindow::OnRenameTimer()
2946 wxCHECK_RET( HasCurrent(), wxT("unexpected rename timer") );
2948 EditLabel( m_current
);
2951 bool wxListMainWindow::OnRenameAccept(size_t itemEdit
, const wxString
& value
)
2953 wxListEvent
le( wxEVT_COMMAND_LIST_END_LABEL_EDIT
, GetParent()->GetId() );
2954 le
.SetEventObject( GetParent() );
2955 le
.m_itemIndex
= itemEdit
;
2957 wxListLineData
*data
= GetLine(itemEdit
);
2959 wxCHECK_MSG( data
, false, _T("invalid index in OnRenameAccept()") );
2961 data
->GetItem( 0, le
.m_item
);
2962 le
.m_item
.m_text
= value
;
2963 return !GetParent()->GetEventHandler()->ProcessEvent( le
) ||
2967 void wxListMainWindow::OnRenameCancelled(size_t itemEdit
)
2969 // let owner know that the edit was cancelled
2970 wxListEvent
le( wxEVT_COMMAND_LIST_END_LABEL_EDIT
, GetParent()->GetId() );
2972 le
.SetEditCanceled(true);
2974 le
.SetEventObject( GetParent() );
2975 le
.m_itemIndex
= itemEdit
;
2977 wxListLineData
*data
= GetLine(itemEdit
);
2978 wxCHECK_RET( data
, _T("invalid index in OnRenameCancelled()") );
2980 data
->GetItem( 0, le
.m_item
);
2981 GetEventHandler()->ProcessEvent( le
);
2984 void wxListMainWindow::OnMouse( wxMouseEvent
&event
)
2988 // On wxMac we can't depend on the EVT_KILL_FOCUS event to properly
2989 // shutdown the edit control when the mouse is clicked elsewhere on the
2990 // listctrl because the order of events is different (or something like
2991 // that), so explicitly end the edit if it is active.
2992 if ( event
.LeftDown() && m_textctrlWrapper
)
2993 m_textctrlWrapper
->AcceptChangesAndFinish();
2996 if ( event
.LeftDown() )
2999 event
.SetEventObject( GetParent() );
3000 if ( GetParent()->GetEventHandler()->ProcessEvent( event
) )
3003 if (event
.GetEventType() == wxEVT_MOUSEWHEEL
)
3005 // let the base handle mouse wheel events.
3010 if ( !HasCurrent() || IsEmpty() )
3012 if (event
.RightDown())
3014 SendNotify( (size_t)-1, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
, event
.GetPosition() );
3015 // Allow generation of context menu event
3024 if ( !(event
.Dragging() || event
.ButtonDown() || event
.LeftUp() ||
3025 event
.ButtonDClick()) )
3028 int x
= event
.GetX();
3029 int y
= event
.GetY();
3030 CalcUnscrolledPosition( x
, y
, &x
, &y
);
3032 // where did we hit it (if we did)?
3035 size_t count
= GetItemCount(),
3038 if ( InReportView() )
3040 current
= y
/ GetLineHeight();
3041 if ( current
< count
)
3042 hitResult
= HitTestLine(current
, x
, y
);
3046 // TODO: optimize it too! this is less simple than for report view but
3047 // enumerating all items is still not a way to do it!!
3048 for ( current
= 0; current
< count
; current
++ )
3050 hitResult
= HitTestLine(current
, x
, y
);
3056 if (event
.Dragging())
3058 if (m_dragCount
== 0)
3060 // we have to report the raw, physical coords as we want to be
3061 // able to call HitTest(event.m_pointDrag) from the user code to
3062 // get the item being dragged
3063 m_dragStart
= event
.GetPosition();
3068 if (m_dragCount
!= 3)
3071 int command
= event
.RightIsDown() ? wxEVT_COMMAND_LIST_BEGIN_RDRAG
3072 : wxEVT_COMMAND_LIST_BEGIN_DRAG
;
3074 wxListEvent
le( command
, GetParent()->GetId() );
3075 le
.SetEventObject( GetParent() );
3076 le
.m_itemIndex
= m_lineLastClicked
;
3077 le
.m_pointDrag
= m_dragStart
;
3078 GetParent()->GetEventHandler()->ProcessEvent( le
);
3089 // outside of any item
3090 if (event
.RightDown())
3092 SendNotify( (size_t) -1, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
, event
.GetPosition() );
3093 // Allow generation of context menu event
3098 // reset the selection and bail out
3099 HighlightAll(false);
3105 bool forceClick
= false;
3106 if (event
.ButtonDClick())
3108 if ( m_renameTimer
->IsRunning() )
3109 m_renameTimer
->Stop();
3111 m_lastOnSame
= false;
3113 if ( current
== m_lineLastClicked
)
3115 SendNotify( current
, wxEVT_COMMAND_LIST_ITEM_ACTIVATED
);
3121 // The first click was on another item, so don't interpret this as
3122 // a double click, but as a simple click instead
3129 if (m_lineSelectSingleOnUp
!= (size_t)-1)
3131 // select single line
3132 HighlightAll( false );
3133 ReverseHighlight(m_lineSelectSingleOnUp
);
3138 if ((current
== m_current
) &&
3139 (hitResult
== wxLIST_HITTEST_ONITEMLABEL
) &&
3140 HasFlag(wxLC_EDIT_LABELS
) )
3142 m_renameTimer
->Start( 100, true );
3146 m_lastOnSame
= false;
3147 m_lineSelectSingleOnUp
= (size_t)-1;
3151 // This is necessary, because after a DnD operation in
3152 // from and to ourself, the up event is swallowed by the
3153 // DnD code. So on next non-up event (which means here and
3154 // now) m_lineSelectSingleOnUp should be reset.
3155 m_lineSelectSingleOnUp
= (size_t)-1;
3157 if (event
.RightDown())
3159 m_lineBeforeLastClicked
= m_lineLastClicked
;
3160 m_lineLastClicked
= current
;
3162 // If the item is already selected, do not update the selection.
3163 // Multi-selections should not be cleared if a selected item is clicked.
3164 if (!IsHighlighted(current
))
3166 HighlightAll(false);
3167 ChangeCurrent(current
);
3168 ReverseHighlight(m_current
);
3171 SendNotify( current
, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
, event
.GetPosition() );
3173 // Allow generation of context menu event
3176 else if (event
.MiddleDown())
3178 SendNotify( current
, wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK
);
3180 else if ( event
.LeftDown() || forceClick
)
3182 m_lineBeforeLastClicked
= m_lineLastClicked
;
3183 m_lineLastClicked
= current
;
3185 size_t oldCurrent
= m_current
;
3186 bool oldWasSelected
= IsHighlighted(m_current
);
3188 bool cmdModifierDown
= event
.CmdDown();
3189 if ( IsSingleSel() || !(cmdModifierDown
|| event
.ShiftDown()) )
3191 if ( IsSingleSel() || !IsHighlighted(current
) )
3193 HighlightAll( false );
3195 ChangeCurrent(current
);
3197 ReverseHighlight(m_current
);
3199 else // multi sel & current is highlighted & no mod keys
3201 m_lineSelectSingleOnUp
= current
;
3202 ChangeCurrent(current
); // change focus
3205 else // multi sel & either ctrl or shift is down
3207 if (cmdModifierDown
)
3209 ChangeCurrent(current
);
3211 ReverseHighlight(m_current
);
3213 else if (event
.ShiftDown())
3215 ChangeCurrent(current
);
3217 size_t lineFrom
= oldCurrent
,
3220 if ( lineTo
< lineFrom
)
3223 lineFrom
= m_current
;
3226 HighlightLines(lineFrom
, lineTo
);
3228 else // !ctrl, !shift
3230 // test in the enclosing if should make it impossible
3231 wxFAIL_MSG( _T("how did we get here?") );
3235 if (m_current
!= oldCurrent
)
3236 RefreshLine( oldCurrent
);
3238 // forceClick is only set if the previous click was on another item
3239 m_lastOnSame
= !forceClick
&& (m_current
== oldCurrent
) && oldWasSelected
;
3243 void wxListMainWindow::MoveToItem(size_t item
)
3245 if ( item
== (size_t)-1 )
3248 wxRect rect
= GetLineRect(item
);
3250 int client_w
, client_h
;
3251 GetClientSize( &client_w
, &client_h
);
3253 const int hLine
= GetLineHeight();
3255 int view_x
= SCROLL_UNIT_X
* GetScrollPos( wxHORIZONTAL
);
3256 int view_y
= hLine
* GetScrollPos( wxVERTICAL
);
3258 if ( InReportView() )
3260 // the next we need the range of lines shown it might be different,
3261 // so recalculate it
3262 ResetVisibleLinesRange();
3264 if (rect
.y
< view_y
)
3265 Scroll( -1, rect
.y
/ hLine
);
3266 if (rect
.y
+ rect
.height
+ 5 > view_y
+ client_h
)
3267 Scroll( -1, (rect
.y
+ rect
.height
- client_h
+ hLine
) / hLine
);
3271 if (rect
.x
-view_x
< 5)
3272 Scroll( (rect
.x
- 5) / SCROLL_UNIT_X
, -1 );
3273 if (rect
.x
+ rect
.width
- 5 > view_x
+ client_w
)
3274 Scroll( (rect
.x
+ rect
.width
- client_w
+ SCROLL_UNIT_X
) / SCROLL_UNIT_X
, -1 );
3278 // ----------------------------------------------------------------------------
3279 // keyboard handling
3280 // ----------------------------------------------------------------------------
3282 void wxListMainWindow::OnArrowChar(size_t newCurrent
, const wxKeyEvent
& event
)
3284 wxCHECK_RET( newCurrent
< (size_t)GetItemCount(),
3285 _T("invalid item index in OnArrowChar()") );
3287 size_t oldCurrent
= m_current
;
3289 // in single selection we just ignore Shift as we can't select several
3291 if ( event
.ShiftDown() && !IsSingleSel() )
3293 ChangeCurrent(newCurrent
);
3295 // refresh the old focus to remove it
3296 RefreshLine( oldCurrent
);
3298 // select all the items between the old and the new one
3299 if ( oldCurrent
> newCurrent
)
3301 newCurrent
= oldCurrent
;
3302 oldCurrent
= m_current
;
3305 HighlightLines(oldCurrent
, newCurrent
);
3309 // all previously selected items are unselected unless ctrl is held
3310 if ( !event
.ControlDown() )
3311 HighlightAll(false);
3313 ChangeCurrent(newCurrent
);
3315 // refresh the old focus to remove it
3316 RefreshLine( oldCurrent
);
3318 if ( !event
.ControlDown() )
3320 HighlightLine( m_current
, true );
3324 RefreshLine( m_current
);
3329 void wxListMainWindow::OnKeyDown( wxKeyEvent
&event
)
3331 wxWindow
*parent
= GetParent();
3333 // propagate the key event upwards
3334 wxKeyEvent
ke( wxEVT_KEY_DOWN
);
3335 ke
.m_shiftDown
= event
.m_shiftDown
;
3336 ke
.m_controlDown
= event
.m_controlDown
;
3337 ke
.m_altDown
= event
.m_altDown
;
3338 ke
.m_metaDown
= event
.m_metaDown
;
3339 ke
.m_keyCode
= event
.m_keyCode
;
3342 ke
.SetEventObject( parent
);
3343 if (parent
->GetEventHandler()->ProcessEvent( ke
)) return;
3348 void wxListMainWindow::OnKeyUp( wxKeyEvent
&event
)
3350 wxWindow
*parent
= GetParent();
3352 // propagate the key event upwards
3353 wxKeyEvent
ke( wxEVT_KEY_UP
);
3354 ke
.m_shiftDown
= event
.m_shiftDown
;
3355 ke
.m_controlDown
= event
.m_controlDown
;
3356 ke
.m_altDown
= event
.m_altDown
;
3357 ke
.m_metaDown
= event
.m_metaDown
;
3358 ke
.m_keyCode
= event
.m_keyCode
;
3361 ke
.SetEventObject( parent
);
3362 if (parent
->GetEventHandler()->ProcessEvent( ke
)) return;
3367 void wxListMainWindow::OnChar( wxKeyEvent
&event
)
3369 wxWindow
*parent
= GetParent();
3371 // send a list_key event up
3374 wxListEvent
le( wxEVT_COMMAND_LIST_KEY_DOWN
, GetParent()->GetId() );
3375 le
.m_itemIndex
= m_current
;
3376 GetLine(m_current
)->GetItem( 0, le
.m_item
);
3377 le
.m_code
= event
.GetKeyCode();
3378 le
.SetEventObject( parent
);
3379 parent
->GetEventHandler()->ProcessEvent( le
);
3382 // propagate the char event upwards
3383 wxKeyEvent
ke( wxEVT_CHAR
);
3384 ke
.m_shiftDown
= event
.m_shiftDown
;
3385 ke
.m_controlDown
= event
.m_controlDown
;
3386 ke
.m_altDown
= event
.m_altDown
;
3387 ke
.m_metaDown
= event
.m_metaDown
;
3388 ke
.m_keyCode
= event
.m_keyCode
;
3391 ke
.SetEventObject( parent
);
3392 if (parent
->GetEventHandler()->ProcessEvent( ke
)) return;
3394 if (event
.GetKeyCode() == WXK_TAB
)
3396 wxNavigationKeyEvent nevent
;
3397 nevent
.SetWindowChange( event
.ControlDown() );
3398 nevent
.SetDirection( !event
.ShiftDown() );
3399 nevent
.SetEventObject( GetParent()->GetParent() );
3400 nevent
.SetCurrentFocus( m_parent
);
3401 if (GetParent()->GetParent()->GetEventHandler()->ProcessEvent( nevent
))
3405 // no item -> nothing to do
3412 // don't use m_linesPerPage directly as it might not be computed yet
3413 const int pageSize
= GetCountPerPage();
3414 wxCHECK_RET( pageSize
, _T("should have non zero page size") );
3416 if (GetLayoutDirection() == wxLayout_RightToLeft
)
3418 if (event
.GetKeyCode() == WXK_RIGHT
)
3419 event
.m_keyCode
= WXK_LEFT
;
3420 else if (event
.GetKeyCode() == WXK_LEFT
)
3421 event
.m_keyCode
= WXK_RIGHT
;
3424 switch ( event
.GetKeyCode() )
3427 if ( m_current
> 0 )
3428 OnArrowChar( m_current
- 1, event
);
3432 if ( m_current
< (size_t)GetItemCount() - 1 )
3433 OnArrowChar( m_current
+ 1, event
);
3438 OnArrowChar( GetItemCount() - 1, event
);
3443 OnArrowChar( 0, event
);
3448 int steps
= InReportView() ? pageSize
- 1
3449 : m_current
% pageSize
;
3451 int index
= m_current
- steps
;
3455 OnArrowChar( index
, event
);
3461 int steps
= InReportView()
3463 : pageSize
- (m_current
% pageSize
) - 1;
3465 size_t index
= m_current
+ steps
;
3466 size_t count
= GetItemCount();
3467 if ( index
>= count
)
3470 OnArrowChar( index
, event
);
3475 if ( !InReportView() )
3477 int index
= m_current
- pageSize
;
3481 OnArrowChar( index
, event
);
3486 if ( !InReportView() )
3488 size_t index
= m_current
+ pageSize
;
3490 size_t count
= GetItemCount();
3491 if ( index
>= count
)
3494 OnArrowChar( index
, event
);
3499 if ( IsSingleSel() )
3501 SendNotify( m_current
, wxEVT_COMMAND_LIST_ITEM_ACTIVATED
);
3503 if ( IsHighlighted(m_current
) )
3505 // don't unselect the item in single selection mode
3508 //else: select it in ReverseHighlight() below if unselected
3511 ReverseHighlight(m_current
);
3516 SendNotify( m_current
, wxEVT_COMMAND_LIST_ITEM_ACTIVATED
);
3524 // ----------------------------------------------------------------------------
3526 // ----------------------------------------------------------------------------
3528 void wxListMainWindow::OnSetFocus( wxFocusEvent
&WXUNUSED(event
) )
3532 wxFocusEvent
event( wxEVT_SET_FOCUS
, GetParent()->GetId() );
3533 event
.SetEventObject( GetParent() );
3534 if ( GetParent()->GetEventHandler()->ProcessEvent( event
) )
3538 // wxGTK sends us EVT_SET_FOCUS events even if we had never got
3539 // EVT_KILL_FOCUS before which means that we finish by redrawing the items
3540 // which are already drawn correctly resulting in horrible flicker - avoid
3550 void wxListMainWindow::OnKillFocus( wxFocusEvent
&WXUNUSED(event
) )
3554 wxFocusEvent
event( wxEVT_KILL_FOCUS
, GetParent()->GetId() );
3555 event
.SetEventObject( GetParent() );
3556 if ( GetParent()->GetEventHandler()->ProcessEvent( event
) )
3564 void wxListMainWindow::DrawImage( int index
, wxDC
*dc
, int x
, int y
)
3566 if ( HasFlag(wxLC_ICON
) && (m_normal_image_list
))
3568 m_normal_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3570 else if ( HasFlag(wxLC_SMALL_ICON
) && (m_small_image_list
))
3572 m_small_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3574 else if ( HasFlag(wxLC_LIST
) && (m_small_image_list
))
3576 m_small_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3578 else if ( InReportView() && (m_small_image_list
))
3580 m_small_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3584 void wxListMainWindow::GetImageSize( int index
, int &width
, int &height
) const
3586 if ( HasFlag(wxLC_ICON
) && m_normal_image_list
)
3588 m_normal_image_list
->GetSize( index
, width
, height
);
3590 else if ( HasFlag(wxLC_SMALL_ICON
) && m_small_image_list
)
3592 m_small_image_list
->GetSize( index
, width
, height
);
3594 else if ( HasFlag(wxLC_LIST
) && m_small_image_list
)
3596 m_small_image_list
->GetSize( index
, width
, height
);
3598 else if ( InReportView() && m_small_image_list
)
3600 m_small_image_list
->GetSize( index
, width
, height
);
3609 int wxListMainWindow::GetTextLength( const wxString
&s
) const
3611 wxClientDC
dc( wxConstCast(this, wxListMainWindow
) );
3612 dc
.SetFont( GetFont() );
3615 dc
.GetTextExtent( s
, &lw
, NULL
);
3617 return lw
+ AUTOSIZE_COL_MARGIN
;
3620 void wxListMainWindow::SetImageList( wxImageList
*imageList
, int which
)
3624 // calc the spacing from the icon size
3625 int width
= 0, height
= 0;
3627 if ((imageList
) && (imageList
->GetImageCount()) )
3628 imageList
->GetSize(0, width
, height
);
3630 if (which
== wxIMAGE_LIST_NORMAL
)
3632 m_normal_image_list
= imageList
;
3633 m_normal_spacing
= width
+ 8;
3636 if (which
== wxIMAGE_LIST_SMALL
)
3638 m_small_image_list
= imageList
;
3639 m_small_spacing
= width
+ 14;
3640 m_lineHeight
= 0; // ensure that the line height will be recalc'd
3644 void wxListMainWindow::SetItemSpacing( int spacing
, bool isSmall
)
3648 m_small_spacing
= spacing
;
3650 m_normal_spacing
= spacing
;
3653 int wxListMainWindow::GetItemSpacing( bool isSmall
)
3655 return isSmall
? m_small_spacing
: m_normal_spacing
;
3658 // ----------------------------------------------------------------------------
3660 // ----------------------------------------------------------------------------
3662 void wxListMainWindow::SetColumn( int col
, wxListItem
&item
)
3664 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
3666 wxCHECK_RET( node
, _T("invalid column index in SetColumn") );
3668 if ( item
.m_width
== wxLIST_AUTOSIZE_USEHEADER
)
3669 item
.m_width
= GetTextLength( item
.m_text
);
3671 wxListHeaderData
*column
= node
->GetData();
3672 column
->SetItem( item
);
3674 wxListHeaderWindow
*headerWin
= GetListCtrl()->m_headerWin
;
3676 headerWin
->m_dirty
= true;
3680 // invalidate it as it has to be recalculated
3684 void wxListMainWindow::SetColumnWidth( int col
, int width
)
3686 wxCHECK_RET( col
>= 0 && col
< GetColumnCount(),
3687 _T("invalid column index") );
3689 wxCHECK_RET( InReportView(),
3690 _T("SetColumnWidth() can only be called in report mode.") );
3693 wxListHeaderWindow
*headerWin
= GetListCtrl()->m_headerWin
;
3695 headerWin
->m_dirty
= true;
3697 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
3698 wxCHECK_RET( node
, _T("no column?") );
3700 wxListHeaderData
*column
= node
->GetData();
3702 size_t count
= GetItemCount();
3704 if (width
== wxLIST_AUTOSIZE_USEHEADER
)
3706 width
= GetTextLength(column
->GetText());
3708 else if ( width
== wxLIST_AUTOSIZE
)
3712 // TODO: determine the max width somehow...
3713 width
= WIDTH_COL_DEFAULT
;
3717 wxClientDC
dc(this);
3718 dc
.SetFont( GetFont() );
3720 int max
= AUTOSIZE_COL_MARGIN
;
3722 // if the cached column width isn't valid then recalculate it
3723 if (m_aColWidths
.Item(col
)->bNeedsUpdate
)
3725 for (size_t i
= 0; i
< count
; i
++)
3727 wxListLineData
*line
= GetLine( i
);
3728 wxListItemDataList::compatibility_iterator n
= line
->m_items
.Item( col
);
3730 wxCHECK_RET( n
, _T("no subitem?") );
3732 wxListItemData
*itemData
= n
->GetData();
3735 itemData
->GetItem(item
);
3736 int itemWidth
= GetItemWidthWithImage(&item
);
3737 if (itemWidth
> max
)
3741 m_aColWidths
.Item(col
)->bNeedsUpdate
= false;
3742 m_aColWidths
.Item(col
)->nMaxWidth
= max
;
3745 max
= m_aColWidths
.Item(col
)->nMaxWidth
;
3746 width
= max
+ AUTOSIZE_COL_MARGIN
;
3750 column
->SetWidth( width
);
3752 // invalidate it as it has to be recalculated
3756 int wxListMainWindow::GetHeaderWidth() const
3758 if ( !m_headerWidth
)
3760 wxListMainWindow
*self
= wxConstCast(this, wxListMainWindow
);
3762 size_t count
= GetColumnCount();
3763 for ( size_t col
= 0; col
< count
; col
++ )
3765 self
->m_headerWidth
+= GetColumnWidth(col
);
3769 return m_headerWidth
;
3772 void wxListMainWindow::GetColumn( int col
, wxListItem
&item
) const
3774 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
3775 wxCHECK_RET( node
, _T("invalid column index in GetColumn") );
3777 wxListHeaderData
*column
= node
->GetData();
3778 column
->GetItem( item
);
3781 int wxListMainWindow::GetColumnWidth( int col
) const
3783 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
3784 wxCHECK_MSG( node
, 0, _T("invalid column index") );
3786 wxListHeaderData
*column
= node
->GetData();
3787 return column
->GetWidth();
3790 // ----------------------------------------------------------------------------
3792 // ----------------------------------------------------------------------------
3794 void wxListMainWindow::SetItem( wxListItem
&item
)
3796 long id
= item
.m_itemId
;
3797 wxCHECK_RET( id
>= 0 && (size_t)id
< GetItemCount(),
3798 _T("invalid item index in SetItem") );
3802 wxListLineData
*line
= GetLine((size_t)id
);
3803 line
->SetItem( item
.m_col
, item
);
3805 // Set item state if user wants
3806 if ( item
.m_mask
& wxLIST_MASK_STATE
)
3807 SetItemState( item
.m_itemId
, item
.m_state
, item
.m_state
);
3811 // update the Max Width Cache if needed
3812 int width
= GetItemWidthWithImage(&item
);
3814 if (width
> m_aColWidths
.Item(item
.m_col
)->nMaxWidth
)
3815 m_aColWidths
.Item(item
.m_col
)->nMaxWidth
= width
;
3819 // update the item on screen
3821 GetItemRect(id
, rectItem
);
3822 RefreshRect(rectItem
);
3825 void wxListMainWindow::SetItemStateAll(long state
, long stateMask
)
3830 // first deal with selection
3831 if ( stateMask
& wxLIST_STATE_SELECTED
)
3833 // set/clear select state
3836 // optimized version for virtual listctrl.
3837 m_selStore
.SelectRange(0, GetItemCount() - 1, state
== wxLIST_STATE_SELECTED
);
3840 else if ( state
& wxLIST_STATE_SELECTED
)
3842 const long count
= GetItemCount();
3843 for( long i
= 0; i
< count
; i
++ )
3845 SetItemState( i
, wxLIST_STATE_SELECTED
, wxLIST_STATE_SELECTED
);
3851 // clear for non virtual (somewhat optimized by using GetNextItem())
3853 while ( (i
= GetNextItem(i
, wxLIST_NEXT_ALL
, wxLIST_STATE_SELECTED
)) != -1 )
3855 SetItemState( i
, 0, wxLIST_STATE_SELECTED
);
3860 if ( HasCurrent() && (state
== 0) && (stateMask
& wxLIST_STATE_FOCUSED
) )
3862 // unfocus all: only one item can be focussed, so clearing focus for
3863 // all items is simply clearing focus of the focussed item.
3864 SetItemState(m_current
, state
, stateMask
);
3866 //(setting focus to all items makes no sense, so it is not handled here.)
3869 void wxListMainWindow::SetItemState( long litem
, long state
, long stateMask
)
3873 SetItemStateAll(state
, stateMask
);
3877 wxCHECK_RET( litem
>= 0 && (size_t)litem
< GetItemCount(),
3878 _T("invalid list ctrl item index in SetItem") );
3880 size_t oldCurrent
= m_current
;
3881 size_t item
= (size_t)litem
; // safe because of the check above
3883 // do we need to change the focus?
3884 if ( stateMask
& wxLIST_STATE_FOCUSED
)
3886 if ( state
& wxLIST_STATE_FOCUSED
)
3888 // don't do anything if this item is already focused
3889 if ( item
!= m_current
)
3891 ChangeCurrent(item
);
3893 if ( oldCurrent
!= (size_t)-1 )
3895 if ( IsSingleSel() )
3897 HighlightLine(oldCurrent
, false);
3900 RefreshLine(oldCurrent
);
3903 RefreshLine( m_current
);
3908 // don't do anything if this item is not focused
3909 if ( item
== m_current
)
3913 if ( IsSingleSel() )
3915 // we must unselect the old current item as well or we
3916 // might end up with more than one selected item in a
3917 // single selection control
3918 HighlightLine(oldCurrent
, false);
3921 RefreshLine( oldCurrent
);
3926 // do we need to change the selection state?
3927 if ( stateMask
& wxLIST_STATE_SELECTED
)
3929 bool on
= (state
& wxLIST_STATE_SELECTED
) != 0;
3931 if ( IsSingleSel() )
3935 // selecting the item also makes it the focused one in the
3937 if ( m_current
!= item
)
3939 ChangeCurrent(item
);
3941 if ( oldCurrent
!= (size_t)-1 )
3943 HighlightLine( oldCurrent
, false );
3944 RefreshLine( oldCurrent
);
3950 // only the current item may be selected anyhow
3951 if ( item
!= m_current
)
3956 if ( HighlightLine(item
, on
) )
3963 int wxListMainWindow::GetItemState( long item
, long stateMask
) const
3965 wxCHECK_MSG( item
>= 0 && (size_t)item
< GetItemCount(), 0,
3966 _T("invalid list ctrl item index in GetItemState()") );
3968 int ret
= wxLIST_STATE_DONTCARE
;
3970 if ( stateMask
& wxLIST_STATE_FOCUSED
)
3972 if ( (size_t)item
== m_current
)
3973 ret
|= wxLIST_STATE_FOCUSED
;
3976 if ( stateMask
& wxLIST_STATE_SELECTED
)
3978 if ( IsHighlighted(item
) )
3979 ret
|= wxLIST_STATE_SELECTED
;
3985 void wxListMainWindow::GetItem( wxListItem
&item
) const
3987 wxCHECK_RET( item
.m_itemId
>= 0 && (size_t)item
.m_itemId
< GetItemCount(),
3988 _T("invalid item index in GetItem") );
3990 wxListLineData
*line
= GetLine((size_t)item
.m_itemId
);
3991 line
->GetItem( item
.m_col
, item
);
3993 // Get item state if user wants it
3994 if ( item
.m_mask
& wxLIST_MASK_STATE
)
3995 item
.m_state
= GetItemState( item
.m_itemId
, wxLIST_STATE_SELECTED
|
3996 wxLIST_STATE_FOCUSED
);
3999 // ----------------------------------------------------------------------------
4001 // ----------------------------------------------------------------------------
4003 size_t wxListMainWindow::GetItemCount() const
4005 return IsVirtual() ? m_countVirt
: m_lines
.GetCount();
4008 void wxListMainWindow::SetItemCount(long count
)
4010 m_selStore
.SetItemCount(count
);
4011 m_countVirt
= count
;
4013 ResetVisibleLinesRange();
4015 // scrollbars must be reset
4019 int wxListMainWindow::GetSelectedItemCount() const
4021 // deal with the quick case first
4022 if ( IsSingleSel() )
4023 return HasCurrent() ? IsHighlighted(m_current
) : false;
4025 // virtual controls remmebers all its selections itself
4027 return m_selStore
.GetSelectedCount();
4029 // TODO: we probably should maintain the number of items selected even for
4030 // non virtual controls as enumerating all lines is really slow...
4031 size_t countSel
= 0;
4032 size_t count
= GetItemCount();
4033 for ( size_t line
= 0; line
< count
; line
++ )
4035 if ( GetLine(line
)->IsHighlighted() )
4042 // ----------------------------------------------------------------------------
4043 // item position/size
4044 // ----------------------------------------------------------------------------
4046 wxRect
wxListMainWindow::GetViewRect() const
4048 wxASSERT_MSG( !HasFlag(wxLC_REPORT
| wxLC_LIST
),
4049 _T("wxListCtrl::GetViewRect() only works in icon mode") );
4051 // we need to find the longest/tallest label
4052 wxCoord xMax
= 0, yMax
= 0;
4053 const int count
= GetItemCount();
4056 for ( int i
= 0; i
< count
; i
++ )
4061 wxCoord x
= r
.GetRight(),
4071 // some fudge needed to make it look prettier
4072 xMax
+= 2 * EXTRA_BORDER_X
;
4073 yMax
+= 2 * EXTRA_BORDER_Y
;
4075 // account for the scrollbars if necessary
4076 const wxSize sizeAll
= GetClientSize();
4077 if ( xMax
> sizeAll
.x
)
4078 yMax
+= wxSystemSettings::GetMetric(wxSYS_HSCROLL_Y
);
4079 if ( yMax
> sizeAll
.y
)
4080 xMax
+= wxSystemSettings::GetMetric(wxSYS_VSCROLL_X
);
4082 return wxRect(0, 0, xMax
, yMax
);
4085 void wxListMainWindow::GetItemRect( long index
, wxRect
&rect
) const
4087 wxCHECK_RET( index
>= 0 && (size_t)index
< GetItemCount(),
4088 _T("invalid index in GetItemRect") );
4090 // ensure that we're laid out, otherwise we could return nonsense
4093 wxConstCast(this, wxListMainWindow
)->
4094 RecalculatePositions(true /* no refresh */);
4097 rect
= GetLineRect((size_t)index
);
4099 CalcScrolledPosition(rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
4102 bool wxListMainWindow::GetItemPosition(long item
, wxPoint
& pos
) const
4105 GetItemRect(item
, rect
);
4113 // ----------------------------------------------------------------------------
4114 // geometry calculation
4115 // ----------------------------------------------------------------------------
4117 void wxListMainWindow::RecalculatePositions(bool noRefresh
)
4119 const int lineHeight
= GetLineHeight();
4121 wxClientDC
dc( this );
4122 dc
.SetFont( GetFont() );
4124 const size_t count
= GetItemCount();
4127 if ( HasFlag(wxLC_ICON
) )
4128 iconSpacing
= m_normal_spacing
;
4129 else if ( HasFlag(wxLC_SMALL_ICON
) )
4130 iconSpacing
= m_small_spacing
;
4134 // Note that we do not call GetClientSize() here but
4135 // GetSize() and subtract the border size for sunken
4136 // borders manually. This is technically incorrect,
4137 // but we need to know the client area's size WITHOUT
4138 // scrollbars here. Since we don't know if there are
4139 // any scrollbars, we use GetSize() instead. Another
4140 // solution would be to call SetScrollbars() here to
4141 // remove the scrollbars and call GetClientSize() then,
4142 // but this might result in flicker and - worse - will
4143 // reset the scrollbars to 0 which is not good at all
4144 // if you resize a dialog/window, but don't want to
4145 // reset the window scrolling. RR.
4146 // Furthermore, we actually do NOT subtract the border
4147 // width as 2 pixels is just the extra space which we
4148 // need around the actual content in the window. Other-
4149 // wise the text would e.g. touch the upper border. RR.
4152 GetSize( &clientWidth
, &clientHeight
);
4154 if ( InReportView() )
4156 // all lines have the same height and we scroll one line per step
4157 int entireHeight
= count
* lineHeight
+ LINE_SPACING
;
4159 m_linesPerPage
= clientHeight
/ lineHeight
;
4161 ResetVisibleLinesRange();
4163 SetScrollbars( SCROLL_UNIT_X
, lineHeight
,
4164 GetHeaderWidth() / SCROLL_UNIT_X
,
4165 (entireHeight
+ lineHeight
- 1) / lineHeight
,
4166 GetScrollPos(wxHORIZONTAL
),
4167 GetScrollPos(wxVERTICAL
),
4172 // we have 3 different layout strategies: either layout all items
4173 // horizontally/vertically (wxLC_ALIGN_XXX styles explicitly given) or
4174 // to arrange them in top to bottom, left to right (don't ask me why
4175 // not the other way round...) order
4176 if ( HasFlag(wxLC_ALIGN_LEFT
| wxLC_ALIGN_TOP
) )
4178 int x
= EXTRA_BORDER_X
;
4179 int y
= EXTRA_BORDER_Y
;
4181 wxCoord widthMax
= 0;
4184 for ( i
= 0; i
< count
; i
++ )
4186 wxListLineData
*line
= GetLine(i
);
4187 line
->CalculateSize( &dc
, iconSpacing
);
4188 line
->SetPosition( x
, y
, iconSpacing
);
4190 wxSize sizeLine
= GetLineSize(i
);
4192 if ( HasFlag(wxLC_ALIGN_TOP
) )
4194 if ( sizeLine
.x
> widthMax
)
4195 widthMax
= sizeLine
.x
;
4199 else // wxLC_ALIGN_LEFT
4201 x
+= sizeLine
.x
+ MARGIN_BETWEEN_ROWS
;
4205 if ( HasFlag(wxLC_ALIGN_TOP
) )
4207 // traverse the items again and tweak their sizes so that they are
4208 // all the same in a row
4209 for ( i
= 0; i
< count
; i
++ )
4211 wxListLineData
*line
= GetLine(i
);
4212 line
->m_gi
->ExtendWidth(widthMax
);
4220 (x
+ SCROLL_UNIT_X
) / SCROLL_UNIT_X
,
4221 (y
+ lineHeight
) / lineHeight
,
4222 GetScrollPos( wxHORIZONTAL
),
4223 GetScrollPos( wxVERTICAL
),
4227 else // "flowed" arrangement, the most complicated case
4229 // at first we try without any scrollbars, if the items don't fit into
4230 // the window, we recalculate after subtracting the space taken by the
4233 int entireWidth
= 0;
4235 for (int tries
= 0; tries
< 2; tries
++)
4237 entireWidth
= 2 * EXTRA_BORDER_X
;
4241 // Now we have decided that the items do not fit into the
4242 // client area, so we need a scrollbar
4243 entireWidth
+= SCROLL_UNIT_X
;
4246 int x
= EXTRA_BORDER_X
;
4247 int y
= EXTRA_BORDER_Y
;
4248 int maxWidthInThisRow
= 0;
4251 int currentlyVisibleLines
= 0;
4253 for (size_t i
= 0; i
< count
; i
++)
4255 currentlyVisibleLines
++;
4256 wxListLineData
*line
= GetLine( i
);
4257 line
->CalculateSize( &dc
, iconSpacing
);
4258 line
->SetPosition( x
, y
, iconSpacing
);
4260 wxSize sizeLine
= GetLineSize( i
);
4262 if ( maxWidthInThisRow
< sizeLine
.x
)
4263 maxWidthInThisRow
= sizeLine
.x
;
4266 if (currentlyVisibleLines
> m_linesPerPage
)
4267 m_linesPerPage
= currentlyVisibleLines
;
4269 if ( y
+ sizeLine
.y
>= clientHeight
)
4271 currentlyVisibleLines
= 0;
4273 maxWidthInThisRow
+= MARGIN_BETWEEN_ROWS
;
4274 x
+= maxWidthInThisRow
;
4275 entireWidth
+= maxWidthInThisRow
;
4276 maxWidthInThisRow
= 0;
4279 // We have reached the last item.
4280 if ( i
== count
- 1 )
4281 entireWidth
+= maxWidthInThisRow
;
4283 if ( (tries
== 0) &&
4284 (entireWidth
+ SCROLL_UNIT_X
> clientWidth
) )
4286 clientHeight
-= wxSystemSettings::
4287 GetMetric(wxSYS_HSCROLL_Y
);
4292 if ( i
== count
- 1 )
4293 tries
= 1; // Everything fits, no second try required.
4301 (entireWidth
+ SCROLL_UNIT_X
) / SCROLL_UNIT_X
,
4303 GetScrollPos( wxHORIZONTAL
),
4312 // FIXME: why should we call it from here?
4319 void wxListMainWindow::RefreshAll()
4324 wxListHeaderWindow
*headerWin
= GetListCtrl()->m_headerWin
;
4325 if ( headerWin
&& headerWin
->m_dirty
)
4327 headerWin
->m_dirty
= false;
4328 headerWin
->Refresh();
4332 void wxListMainWindow::UpdateCurrent()
4334 if ( !HasCurrent() && !IsEmpty() )
4338 long wxListMainWindow::GetNextItem( long item
,
4339 int WXUNUSED(geometry
),
4343 max
= GetItemCount();
4344 wxCHECK_MSG( (ret
== -1) || (ret
< max
), -1,
4345 _T("invalid listctrl index in GetNextItem()") );
4347 // notice that we start with the next item (or the first one if item == -1)
4348 // and this is intentional to allow writing a simple loop to iterate over
4349 // all selected items
4352 // this is not an error because the index was OK initially,
4353 // just no such item
4360 size_t count
= GetItemCount();
4361 for ( size_t line
= (size_t)ret
; line
< count
; line
++ )
4363 if ( (state
& wxLIST_STATE_FOCUSED
) && (line
== m_current
) )
4366 if ( (state
& wxLIST_STATE_SELECTED
) && IsHighlighted(line
) )
4373 // ----------------------------------------------------------------------------
4375 // ----------------------------------------------------------------------------
4377 void wxListMainWindow::DeleteItem( long lindex
)
4379 size_t count
= GetItemCount();
4381 wxCHECK_RET( (lindex
>= 0) && ((size_t)lindex
< count
),
4382 _T("invalid item index in DeleteItem") );
4384 size_t index
= (size_t)lindex
;
4386 // we don't need to adjust the index for the previous items
4387 if ( HasCurrent() && m_current
>= index
)
4389 // if the current item is being deleted, we want the next one to
4390 // become selected - unless there is no next one - so don't adjust
4391 // m_current in this case
4392 if ( m_current
!= index
|| m_current
== count
- 1 )
4396 if ( InReportView() )
4398 // mark the Column Max Width cache as dirty if the items in the line
4399 // we're deleting contain the Max Column Width
4400 wxListLineData
* const line
= GetLine(index
);
4401 wxListItemDataList::compatibility_iterator n
;
4402 wxListItemData
*itemData
;
4406 for (size_t i
= 0; i
< m_columns
.GetCount(); i
++)
4408 n
= line
->m_items
.Item( i
);
4409 itemData
= n
->GetData();
4410 itemData
->GetItem(item
);
4412 itemWidth
= GetItemWidthWithImage(&item
);
4414 if (itemWidth
>= m_aColWidths
.Item(i
)->nMaxWidth
)
4415 m_aColWidths
.Item(i
)->bNeedsUpdate
= true;
4418 ResetVisibleLinesRange();
4421 SendNotify( index
, wxEVT_COMMAND_LIST_DELETE_ITEM
, wxDefaultPosition
);
4426 m_selStore
.OnItemDelete(index
);
4430 m_lines
.RemoveAt( index
);
4433 // we need to refresh the (vert) scrollbar as the number of items changed
4436 RefreshAfter(index
);
4439 void wxListMainWindow::DeleteColumn( int col
)
4441 wxListHeaderDataList::compatibility_iterator node
= m_columns
.Item( col
);
4443 wxCHECK_RET( node
, wxT("invalid column index in DeleteColumn()") );
4446 delete node
->GetData();
4447 m_columns
.Erase( node
);
4451 // update all the items
4452 for ( size_t i
= 0; i
< m_lines
.GetCount(); i
++ )
4454 wxListLineData
* const line
= GetLine(i
);
4455 wxListItemDataList::compatibility_iterator n
= line
->m_items
.Item( col
);
4456 delete n
->GetData();
4457 line
->m_items
.Erase(n
);
4461 if ( InReportView() ) // we only cache max widths when in Report View
4463 delete m_aColWidths
.Item(col
);
4464 m_aColWidths
.RemoveAt(col
);
4467 // invalidate it as it has to be recalculated
4471 void wxListMainWindow::DoDeleteAllItems()
4474 // nothing to do - in particular, don't send the event
4479 // to make the deletion of all items faster, we don't send the
4480 // notifications for each item deletion in this case but only one event
4481 // for all of them: this is compatible with wxMSW and documented in
4482 // DeleteAllItems() description
4484 wxListEvent
event( wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS
, GetParent()->GetId() );
4485 event
.SetEventObject( GetParent() );
4486 GetParent()->GetEventHandler()->ProcessEvent( event
);
4494 if ( InReportView() )
4496 ResetVisibleLinesRange();
4497 for (size_t i
= 0; i
< m_aColWidths
.GetCount(); i
++)
4499 m_aColWidths
.Item(i
)->bNeedsUpdate
= true;
4506 void wxListMainWindow::DeleteAllItems()
4510 RecalculatePositions();
4513 void wxListMainWindow::DeleteEverything()
4515 WX_CLEAR_LIST(wxListHeaderDataList
, m_columns
);
4516 WX_CLEAR_ARRAY(m_aColWidths
);
4521 // ----------------------------------------------------------------------------
4522 // scanning for an item
4523 // ----------------------------------------------------------------------------
4525 void wxListMainWindow::EnsureVisible( long index
)
4527 wxCHECK_RET( index
>= 0 && (size_t)index
< GetItemCount(),
4528 _T("invalid index in EnsureVisible") );
4530 // We have to call this here because the label in question might just have
4531 // been added and its position is not known yet
4533 RecalculatePositions(true /* no refresh */);
4535 MoveToItem((size_t)index
);
4538 long wxListMainWindow::FindItem(long start
, const wxString
& str
, bool partial
)
4544 wxString str_upper
= str
.Upper();
4548 size_t count
= GetItemCount();
4549 for ( size_t i
= (size_t)pos
; i
< count
; i
++ )
4551 wxListLineData
*line
= GetLine(i
);
4552 wxString line_upper
= line
->GetText(0).Upper();
4555 if (line_upper
== str_upper
)
4560 if (line_upper
.find(str_upper
) == 0)
4568 long wxListMainWindow::FindItem(long start
, wxUIntPtr data
)
4574 size_t count
= GetItemCount();
4575 for (size_t i
= (size_t)pos
; i
< count
; i
++)
4577 wxListLineData
*line
= GetLine(i
);
4579 line
->GetItem( 0, item
);
4580 if (item
.m_data
== data
)
4587 long wxListMainWindow::FindItem( const wxPoint
& pt
)
4590 GetVisibleLinesRange( &topItem
, NULL
);
4593 GetItemPosition( GetItemCount() - 1, p
);
4597 long id
= (long)floor( pt
.y
* double(GetItemCount() - topItem
- 1) / p
.y
+ topItem
);
4598 if ( id
>= 0 && id
< (long)GetItemCount() )
4604 long wxListMainWindow::HitTest( int x
, int y
, int &flags
) const
4606 CalcUnscrolledPosition( x
, y
, &x
, &y
);
4608 size_t count
= GetItemCount();
4610 if ( InReportView() )
4612 size_t current
= y
/ GetLineHeight();
4613 if ( current
< count
)
4615 flags
= HitTestLine(current
, x
, y
);
4622 // TODO: optimize it too! this is less simple than for report view but
4623 // enumerating all items is still not a way to do it!!
4624 for ( size_t current
= 0; current
< count
; current
++ )
4626 flags
= HitTestLine(current
, x
, y
);
4635 // ----------------------------------------------------------------------------
4637 // ----------------------------------------------------------------------------
4639 void wxListMainWindow::InsertItem( wxListItem
&item
)
4641 wxASSERT_MSG( !IsVirtual(), _T("can't be used with virtual control") );
4643 int count
= GetItemCount();
4644 wxCHECK_RET( item
.m_itemId
>= 0, _T("invalid item index") );
4646 if (item
.m_itemId
> count
)
4647 item
.m_itemId
= count
;
4649 size_t id
= item
.m_itemId
;
4653 if ( InReportView() )
4655 ResetVisibleLinesRange();
4657 // calculate the width of the item and adjust the max column width
4658 wxColWidthInfo
*pWidthInfo
= m_aColWidths
.Item(item
.GetColumn());
4659 int width
= GetItemWidthWithImage(&item
);
4660 item
.SetWidth(width
);
4661 if (width
> pWidthInfo
->nMaxWidth
)
4662 pWidthInfo
->nMaxWidth
= width
;
4665 wxListLineData
*line
= new wxListLineData(this);
4667 line
->SetItem( item
.m_col
, item
);
4669 m_lines
.Insert( line
, id
);
4673 // If an item is selected at or below the point of insertion, we need to
4674 // increment the member variables because the current row's index has gone
4676 if ( HasCurrent() && m_current
>= id
)
4679 SendNotify(id
, wxEVT_COMMAND_LIST_INSERT_ITEM
);
4681 RefreshLines(id
, GetItemCount() - 1);
4684 void wxListMainWindow::InsertColumn( long col
, wxListItem
&item
)
4687 if ( InReportView() )
4689 if (item
.m_width
== wxLIST_AUTOSIZE_USEHEADER
)
4690 item
.m_width
= GetTextLength( item
.m_text
);
4692 wxListHeaderData
*column
= new wxListHeaderData( item
);
4693 wxColWidthInfo
*colWidthInfo
= new wxColWidthInfo();
4695 bool insert
= (col
>= 0) && ((size_t)col
< m_columns
.GetCount());
4698 wxListHeaderDataList::compatibility_iterator
4699 node
= m_columns
.Item( col
);
4700 m_columns
.Insert( node
, column
);
4701 m_aColWidths
.Insert( colWidthInfo
, col
);
4705 m_columns
.Append( column
);
4706 m_aColWidths
.Add( colWidthInfo
);
4711 // update all the items
4712 for ( size_t i
= 0; i
< m_lines
.GetCount(); i
++ )
4714 wxListLineData
* const line
= GetLine(i
);
4715 wxListItemData
* const data
= new wxListItemData(this);
4717 line
->m_items
.Insert(col
, data
);
4719 line
->m_items
.Append(data
);
4723 // invalidate it as it has to be recalculated
4728 int wxListMainWindow::GetItemWidthWithImage(wxListItem
* item
)
4731 wxClientDC
dc(this);
4733 dc
.SetFont( GetFont() );
4735 if (item
->GetImage() != -1)
4738 GetImageSize( item
->GetImage(), ix
, iy
);
4742 if (!item
->GetText().empty())
4745 dc
.GetTextExtent( item
->GetText(), &w
, NULL
);
4752 // ----------------------------------------------------------------------------
4754 // ----------------------------------------------------------------------------
4756 wxListCtrlCompare list_ctrl_compare_func_2
;
4757 long list_ctrl_compare_data
;
4759 int LINKAGEMODE
list_ctrl_compare_func_1( wxListLineData
**arg1
, wxListLineData
**arg2
)
4761 wxListLineData
*line1
= *arg1
;
4762 wxListLineData
*line2
= *arg2
;
4764 line1
->GetItem( 0, item
);
4765 wxUIntPtr data1
= item
.m_data
;
4766 line2
->GetItem( 0, item
);
4767 wxUIntPtr data2
= item
.m_data
;
4768 return list_ctrl_compare_func_2( data1
, data2
, list_ctrl_compare_data
);
4771 void wxListMainWindow::SortItems( wxListCtrlCompare fn
, long data
)
4773 list_ctrl_compare_func_2
= fn
;
4774 list_ctrl_compare_data
= data
;
4775 m_lines
.Sort( list_ctrl_compare_func_1
);
4779 // ----------------------------------------------------------------------------
4781 // ----------------------------------------------------------------------------
4783 void wxListMainWindow::OnScroll(wxScrollWinEvent
& event
)
4785 // update our idea of which lines are shown when we redraw the window the
4787 ResetVisibleLinesRange();
4790 #if ( defined(__WXGTK__) || defined(__WXMAC__) ) && !defined(__WXUNIVERSAL__)
4791 wxScrolledWindow::OnScroll(event
);
4793 HandleOnScroll( event
);
4796 if ( event
.GetOrientation() == wxHORIZONTAL
&& HasHeader() )
4798 wxGenericListCtrl
* lc
= GetListCtrl();
4799 wxCHECK_RET( lc
, _T("no listctrl window?") );
4801 lc
->m_headerWin
->Refresh();
4802 lc
->m_headerWin
->Update();
4806 int wxListMainWindow::GetCountPerPage() const
4808 if ( !m_linesPerPage
)
4810 wxConstCast(this, wxListMainWindow
)->
4811 m_linesPerPage
= GetClientSize().y
/ GetLineHeight();
4814 return m_linesPerPage
;
4817 void wxListMainWindow::GetVisibleLinesRange(size_t *from
, size_t *to
)
4819 wxASSERT_MSG( InReportView(), _T("this is for report mode only") );
4821 if ( m_lineFrom
== (size_t)-1 )
4823 size_t count
= GetItemCount();
4826 m_lineFrom
= GetScrollPos(wxVERTICAL
);
4828 // this may happen if SetScrollbars() hadn't been called yet
4829 if ( m_lineFrom
>= count
)
4830 m_lineFrom
= count
- 1;
4832 // we redraw one extra line but this is needed to make the redrawing
4833 // logic work when there is a fractional number of lines on screen
4834 m_lineTo
= m_lineFrom
+ m_linesPerPage
;
4835 if ( m_lineTo
>= count
)
4836 m_lineTo
= count
- 1;
4838 else // empty control
4841 m_lineTo
= (size_t)-1;
4845 wxASSERT_MSG( IsEmpty() ||
4846 (m_lineFrom
<= m_lineTo
&& m_lineTo
< GetItemCount()),
4847 _T("GetVisibleLinesRange() returns incorrect result") );
4855 // -------------------------------------------------------------------------------------
4856 // wxGenericListCtrl
4857 // -------------------------------------------------------------------------------------
4859 IMPLEMENT_DYNAMIC_CLASS(wxGenericListCtrl
, wxControl
)
4861 BEGIN_EVENT_TABLE(wxGenericListCtrl
,wxControl
)
4862 EVT_SIZE(wxGenericListCtrl::OnSize
)
4865 wxGenericListCtrl::wxGenericListCtrl()
4867 m_imageListNormal
= (wxImageList
*) NULL
;
4868 m_imageListSmall
= (wxImageList
*) NULL
;
4869 m_imageListState
= (wxImageList
*) NULL
;
4871 m_ownsImageListNormal
=
4872 m_ownsImageListSmall
=
4873 m_ownsImageListState
= false;
4875 m_mainWin
= (wxListMainWindow
*) NULL
;
4876 m_headerWin
= (wxListHeaderWindow
*) NULL
;
4880 wxGenericListCtrl::~wxGenericListCtrl()
4882 if (m_ownsImageListNormal
)
4883 delete m_imageListNormal
;
4884 if (m_ownsImageListSmall
)
4885 delete m_imageListSmall
;
4886 if (m_ownsImageListState
)
4887 delete m_imageListState
;
4890 void wxGenericListCtrl::CalculateAndSetHeaderHeight()
4896 GetThemeMetric( kThemeMetricListHeaderHeight
, &h
);
4898 // we use 'g' to get the descent, too
4900 m_headerWin
->GetTextExtent(wxT("Hg"), &w
, &h
, &d
);
4901 h
+= d
+ 2 * HEADER_OFFSET_Y
+ EXTRA_HEIGHT
;
4904 // only update if changed
4905 if ( h
!= m_headerHeight
)
4910 ResizeReportView(true);
4911 else //why is this needed if it doesn't have a header?
4912 m_headerWin
->SetSize(m_headerWin
->GetSize().x
, m_headerHeight
);
4917 void wxGenericListCtrl::CreateHeaderWindow()
4919 m_headerWin
= new wxListHeaderWindow
4921 this, wxID_ANY
, m_mainWin
,
4923 wxSize(GetClientSize().x
, m_headerHeight
),
4926 CalculateAndSetHeaderHeight();
4929 bool wxGenericListCtrl::Create(wxWindow
*parent
,
4934 const wxValidator
&validator
,
4935 const wxString
&name
)
4939 m_imageListState
= (wxImageList
*) NULL
;
4940 m_ownsImageListNormal
=
4941 m_ownsImageListSmall
=
4942 m_ownsImageListState
= false;
4944 m_mainWin
= (wxListMainWindow
*) NULL
;
4945 m_headerWin
= (wxListHeaderWindow
*) NULL
;
4949 if ( !(style
& wxLC_MASK_TYPE
) )
4951 style
= style
| wxLC_LIST
;
4954 if ( !wxControl::Create( parent
, id
, pos
, size
, style
, validator
, name
) )
4957 // don't create the inner window with the border
4958 style
&= ~wxBORDER_MASK
;
4960 m_mainWin
= new wxListMainWindow( this, wxID_ANY
, wxPoint(0, 0), size
, style
);
4962 #ifdef __WXMAC_CARBON__
4963 // Human Interface Guidelines ask us for a special font in this case
4964 if ( GetWindowVariant() == wxWINDOW_VARIANT_NORMAL
)
4967 font
.MacCreateThemeFont( kThemeViewsFont
);
4972 if ( InReportView() )
4974 CreateHeaderWindow();
4976 #ifdef __WXMAC_CARBON__
4980 font
.MacCreateThemeFont( kThemeSmallSystemFont
);
4981 m_headerWin
->SetFont( font
);
4982 CalculateAndSetHeaderHeight();
4986 if ( HasFlag(wxLC_NO_HEADER
) )
4987 // VZ: why do we create it at all then?
4988 m_headerWin
->Show( false );
4991 SetInitialSize(size
);
4996 void wxGenericListCtrl::SetSingleStyle( long style
, bool add
)
4998 wxASSERT_MSG( !(style
& wxLC_VIRTUAL
),
4999 _T("wxLC_VIRTUAL can't be [un]set") );
5001 long flag
= GetWindowStyle();
5005 if (style
& wxLC_MASK_TYPE
)
5006 flag
&= ~(wxLC_MASK_TYPE
| wxLC_VIRTUAL
);
5007 if (style
& wxLC_MASK_ALIGN
)
5008 flag
&= ~wxLC_MASK_ALIGN
;
5009 if (style
& wxLC_MASK_SORT
)
5010 flag
&= ~wxLC_MASK_SORT
;
5018 SetWindowStyleFlag( flag
);
5021 void wxGenericListCtrl::SetWindowStyleFlag( long flag
)
5025 m_mainWin
->DeleteEverything();
5027 // has the header visibility changed?
5028 bool hasHeader
= HasHeader();
5029 bool willHaveHeader
= (flag
& wxLC_REPORT
) && !(flag
& wxLC_NO_HEADER
);
5031 if ( hasHeader
!= willHaveHeader
)
5038 // don't delete, just hide, as we can reuse it later
5039 m_headerWin
->Show(false);
5041 //else: nothing to do
5043 else // must show header
5047 CreateHeaderWindow();
5049 else // already have it, just show
5051 m_headerWin
->Show( true );
5055 ResizeReportView(willHaveHeader
);
5059 wxWindow::SetWindowStyleFlag( flag
);
5062 bool wxGenericListCtrl::GetColumn(int col
, wxListItem
&item
) const
5064 m_mainWin
->GetColumn( col
, item
);
5068 bool wxGenericListCtrl::SetColumn( int col
, wxListItem
& item
)
5070 m_mainWin
->SetColumn( col
, item
);
5074 int wxGenericListCtrl::GetColumnWidth( int col
) const
5076 return m_mainWin
->GetColumnWidth( col
);
5079 bool wxGenericListCtrl::SetColumnWidth( int col
, int width
)
5081 m_mainWin
->SetColumnWidth( col
, width
);
5085 int wxGenericListCtrl::GetCountPerPage() const
5087 return m_mainWin
->GetCountPerPage(); // different from Windows ?
5090 bool wxGenericListCtrl::GetItem( wxListItem
&info
) const
5092 m_mainWin
->GetItem( info
);
5096 bool wxGenericListCtrl::SetItem( wxListItem
&info
)
5098 m_mainWin
->SetItem( info
);
5102 long wxGenericListCtrl::SetItem( long index
, int col
, const wxString
& label
, int imageId
)
5105 info
.m_text
= label
;
5106 info
.m_mask
= wxLIST_MASK_TEXT
;
5107 info
.m_itemId
= index
;
5111 info
.m_image
= imageId
;
5112 info
.m_mask
|= wxLIST_MASK_IMAGE
;
5115 m_mainWin
->SetItem(info
);
5119 int wxGenericListCtrl::GetItemState( long item
, long stateMask
) const
5121 return m_mainWin
->GetItemState( item
, stateMask
);
5124 bool wxGenericListCtrl::SetItemState( long item
, long state
, long stateMask
)
5126 m_mainWin
->SetItemState( item
, state
, stateMask
);
5131 wxGenericListCtrl::SetItemImage( long item
, int image
, int WXUNUSED(selImage
) )
5133 return SetItemColumnImage(item
, 0, image
);
5137 wxGenericListCtrl::SetItemColumnImage( long item
, long column
, int image
)
5140 info
.m_image
= image
;
5141 info
.m_mask
= wxLIST_MASK_IMAGE
;
5142 info
.m_itemId
= item
;
5143 info
.m_col
= column
;
5144 m_mainWin
->SetItem( info
);
5148 wxString
wxGenericListCtrl::GetItemText( long item
) const
5150 return m_mainWin
->GetItemText(item
);
5153 void wxGenericListCtrl::SetItemText( long item
, const wxString
& str
)
5155 m_mainWin
->SetItemText(item
, str
);
5158 wxUIntPtr
wxGenericListCtrl::GetItemData( long item
) const
5161 info
.m_mask
= wxLIST_MASK_DATA
;
5162 info
.m_itemId
= item
;
5163 m_mainWin
->GetItem( info
);
5167 bool wxGenericListCtrl::SetItemData( long item
, long data
)
5170 info
.m_mask
= wxLIST_MASK_DATA
;
5171 info
.m_itemId
= item
;
5173 m_mainWin
->SetItem( info
);
5177 wxRect
wxGenericListCtrl::GetViewRect() const
5179 return m_mainWin
->GetViewRect();
5182 bool wxGenericListCtrl::GetItemRect( long item
, wxRect
&rect
, int WXUNUSED(code
) ) const
5184 m_mainWin
->GetItemRect( item
, rect
);
5185 if ( m_mainWin
->HasHeader() )
5186 rect
.y
+= m_headerHeight
+ 1;
5190 bool wxGenericListCtrl::GetItemPosition( long item
, wxPoint
& pos
) const
5192 m_mainWin
->GetItemPosition( item
, pos
);
5196 bool wxGenericListCtrl::SetItemPosition( long WXUNUSED(item
), const wxPoint
& WXUNUSED(pos
) )
5201 int wxGenericListCtrl::GetItemCount() const
5203 return m_mainWin
->GetItemCount();
5206 int wxGenericListCtrl::GetColumnCount() const
5208 return m_mainWin
->GetColumnCount();
5211 void wxGenericListCtrl::SetItemSpacing( int spacing
, bool isSmall
)
5213 m_mainWin
->SetItemSpacing( spacing
, isSmall
);
5216 wxSize
wxGenericListCtrl::GetItemSpacing() const
5218 const int spacing
= m_mainWin
->GetItemSpacing(HasFlag(wxLC_SMALL_ICON
));
5220 return wxSize(spacing
, spacing
);
5223 #if WXWIN_COMPATIBILITY_2_6
5224 int wxGenericListCtrl::GetItemSpacing( bool isSmall
) const
5226 return m_mainWin
->GetItemSpacing( isSmall
);
5228 #endif // WXWIN_COMPATIBILITY_2_6
5230 void wxGenericListCtrl::SetItemTextColour( long item
, const wxColour
&col
)
5233 info
.m_itemId
= item
;
5234 info
.SetTextColour( col
);
5235 m_mainWin
->SetItem( info
);
5238 wxColour
wxGenericListCtrl::GetItemTextColour( long item
) const
5241 info
.m_itemId
= item
;
5242 m_mainWin
->GetItem( info
);
5243 return info
.GetTextColour();
5246 void wxGenericListCtrl::SetItemBackgroundColour( long item
, const wxColour
&col
)
5249 info
.m_itemId
= item
;
5250 info
.SetBackgroundColour( col
);
5251 m_mainWin
->SetItem( info
);
5254 wxColour
wxGenericListCtrl::GetItemBackgroundColour( long item
) const
5257 info
.m_itemId
= item
;
5258 m_mainWin
->GetItem( info
);
5259 return info
.GetBackgroundColour();
5262 int wxGenericListCtrl::GetScrollPos( int orient
) const
5264 return m_mainWin
->GetScrollPos( orient
);
5267 void wxGenericListCtrl::SetScrollPos( int orient
, int pos
, bool refresh
)
5269 m_mainWin
->SetScrollPos( orient
, pos
, refresh
);
5272 void wxGenericListCtrl::SetItemFont( long item
, const wxFont
&f
)
5275 info
.m_itemId
= item
;
5277 m_mainWin
->SetItem( info
);
5280 wxFont
wxGenericListCtrl::GetItemFont( long item
) const
5283 info
.m_itemId
= item
;
5284 m_mainWin
->GetItem( info
);
5285 return info
.GetFont();
5288 int wxGenericListCtrl::GetSelectedItemCount() const
5290 return m_mainWin
->GetSelectedItemCount();
5293 wxColour
wxGenericListCtrl::GetTextColour() const
5295 return GetForegroundColour();
5298 void wxGenericListCtrl::SetTextColour(const wxColour
& col
)
5300 SetForegroundColour(col
);
5303 long wxGenericListCtrl::GetTopItem() const
5306 m_mainWin
->GetVisibleLinesRange(&top
, NULL
);
5310 long wxGenericListCtrl::GetNextItem( long item
, int geom
, int state
) const
5312 return m_mainWin
->GetNextItem( item
, geom
, state
);
5315 wxImageList
*wxGenericListCtrl::GetImageList(int which
) const
5317 if (which
== wxIMAGE_LIST_NORMAL
)
5318 return m_imageListNormal
;
5319 else if (which
== wxIMAGE_LIST_SMALL
)
5320 return m_imageListSmall
;
5321 else if (which
== wxIMAGE_LIST_STATE
)
5322 return m_imageListState
;
5324 return (wxImageList
*) NULL
;
5327 void wxGenericListCtrl::SetImageList( wxImageList
*imageList
, int which
)
5329 if ( which
== wxIMAGE_LIST_NORMAL
)
5331 if (m_ownsImageListNormal
)
5332 delete m_imageListNormal
;
5333 m_imageListNormal
= imageList
;
5334 m_ownsImageListNormal
= false;
5336 else if ( which
== wxIMAGE_LIST_SMALL
)
5338 if (m_ownsImageListSmall
)
5339 delete m_imageListSmall
;
5340 m_imageListSmall
= imageList
;
5341 m_ownsImageListSmall
= false;
5343 else if ( which
== wxIMAGE_LIST_STATE
)
5345 if (m_ownsImageListState
)
5346 delete m_imageListState
;
5347 m_imageListState
= imageList
;
5348 m_ownsImageListState
= false;
5351 m_mainWin
->SetImageList( imageList
, which
);
5354 void wxGenericListCtrl::AssignImageList(wxImageList
*imageList
, int which
)
5356 SetImageList(imageList
, which
);
5357 if ( which
== wxIMAGE_LIST_NORMAL
)
5358 m_ownsImageListNormal
= true;
5359 else if ( which
== wxIMAGE_LIST_SMALL
)
5360 m_ownsImageListSmall
= true;
5361 else if ( which
== wxIMAGE_LIST_STATE
)
5362 m_ownsImageListState
= true;
5365 bool wxGenericListCtrl::Arrange( int WXUNUSED(flag
) )
5370 bool wxGenericListCtrl::DeleteItem( long item
)
5372 m_mainWin
->DeleteItem( item
);
5376 bool wxGenericListCtrl::DeleteAllItems()
5378 m_mainWin
->DeleteAllItems();
5382 bool wxGenericListCtrl::DeleteAllColumns()
5384 size_t count
= m_mainWin
->m_columns
.GetCount();
5385 for ( size_t n
= 0; n
< count
; n
++ )
5390 void wxGenericListCtrl::ClearAll()
5392 m_mainWin
->DeleteEverything();
5395 bool wxGenericListCtrl::DeleteColumn( int col
)
5397 m_mainWin
->DeleteColumn( col
);
5399 // if we don't have the header any longer, we need to relayout the window
5400 if ( !GetColumnCount() )
5401 ResizeReportView(false /* no header */);
5405 wxTextCtrl
*wxGenericListCtrl::EditLabel(long item
,
5406 wxClassInfo
* textControlClass
)
5408 return m_mainWin
->EditLabel( item
, textControlClass
);
5411 wxTextCtrl
*wxGenericListCtrl::GetEditControl() const
5413 return m_mainWin
->GetEditControl();
5416 bool wxGenericListCtrl::EnsureVisible( long item
)
5418 m_mainWin
->EnsureVisible( item
);
5422 long wxGenericListCtrl::FindItem( long start
, const wxString
& str
, bool partial
)
5424 return m_mainWin
->FindItem( start
, str
, partial
);
5427 long wxGenericListCtrl::FindItem( long start
, wxUIntPtr data
)
5429 return m_mainWin
->FindItem( start
, data
);
5432 long wxGenericListCtrl::FindItem( long WXUNUSED(start
), const wxPoint
& pt
,
5433 int WXUNUSED(direction
))
5435 return m_mainWin
->FindItem( pt
);
5438 // TODO: sub item hit testing
5439 long wxGenericListCtrl::HitTest(const wxPoint
& point
, int& flags
, long *) const
5441 return m_mainWin
->HitTest( (int)point
.x
, (int)point
.y
, flags
);
5444 long wxGenericListCtrl::InsertItem( wxListItem
& info
)
5446 m_mainWin
->InsertItem( info
);
5447 return info
.m_itemId
;
5450 long wxGenericListCtrl::InsertItem( long index
, const wxString
&label
)
5453 info
.m_text
= label
;
5454 info
.m_mask
= wxLIST_MASK_TEXT
;
5455 info
.m_itemId
= index
;
5456 return InsertItem( info
);
5459 long wxGenericListCtrl::InsertItem( long index
, int imageIndex
)
5462 info
.m_mask
= wxLIST_MASK_IMAGE
;
5463 info
.m_image
= imageIndex
;
5464 info
.m_itemId
= index
;
5465 return InsertItem( info
);
5468 long wxGenericListCtrl::InsertItem( long index
, const wxString
&label
, int imageIndex
)
5471 info
.m_text
= label
;
5472 info
.m_image
= imageIndex
;
5473 info
.m_mask
= wxLIST_MASK_TEXT
| wxLIST_MASK_IMAGE
;
5474 info
.m_itemId
= index
;
5475 return InsertItem( info
);
5478 long wxGenericListCtrl::InsertColumn( long col
, wxListItem
&item
)
5480 wxCHECK_MSG( m_headerWin
, -1, _T("can't add column in non report mode") );
5482 m_mainWin
->InsertColumn( col
, item
);
5484 // if we hadn't had a header before but have one now
5485 // then we need to relayout the window
5486 if ( GetColumnCount() == 1 && m_mainWin
->HasHeader() )
5487 ResizeReportView(true /* have header */);
5489 m_headerWin
->Refresh();
5494 long wxGenericListCtrl::InsertColumn( long col
, const wxString
&heading
,
5495 int format
, int width
)
5498 item
.m_mask
= wxLIST_MASK_TEXT
| wxLIST_MASK_FORMAT
;
5499 item
.m_text
= heading
;
5502 item
.m_mask
|= wxLIST_MASK_WIDTH
;
5503 item
.m_width
= width
;
5506 item
.m_format
= format
;
5508 return InsertColumn( col
, item
);
5511 bool wxGenericListCtrl::ScrollList( int WXUNUSED(dx
), int WXUNUSED(dy
) )
5517 // fn is a function which takes 3 long arguments: item1, item2, data.
5518 // item1 is the long data associated with a first item (NOT the index).
5519 // item2 is the long data associated with a second item (NOT the index).
5520 // data is the same value as passed to SortItems.
5521 // The return value is a negative number if the first item should precede the second
5522 // item, a positive number of the second item should precede the first,
5523 // or zero if the two items are equivalent.
5524 // data is arbitrary data to be passed to the sort function.
5526 bool wxGenericListCtrl::SortItems( wxListCtrlCompare fn
, long data
)
5528 m_mainWin
->SortItems( fn
, data
);
5532 // ----------------------------------------------------------------------------
5534 // ----------------------------------------------------------------------------
5536 void wxGenericListCtrl::OnSize(wxSizeEvent
& WXUNUSED(event
))
5541 ResizeReportView(m_mainWin
->HasHeader());
5542 m_mainWin
->RecalculatePositions();
5545 void wxGenericListCtrl::ResizeReportView(bool showHeader
)
5548 GetClientSize( &cw
, &ch
);
5552 m_headerWin
->SetSize( 0, 0, cw
, m_headerHeight
);
5553 if(ch
> m_headerHeight
)
5554 m_mainWin
->SetSize( 0, m_headerHeight
+ 1,
5555 cw
, ch
- m_headerHeight
- 1 );
5557 m_mainWin
->SetSize( 0, m_headerHeight
+ 1,
5560 else // no header window
5562 m_mainWin
->SetSize( 0, 0, cw
, ch
);
5566 void wxGenericListCtrl::OnInternalIdle()
5568 wxWindow::OnInternalIdle();
5570 // do it only if needed
5571 if ( !m_mainWin
->m_dirty
)
5574 m_mainWin
->RecalculatePositions();
5577 // ----------------------------------------------------------------------------
5579 // ----------------------------------------------------------------------------
5581 bool wxGenericListCtrl::SetBackgroundColour( const wxColour
&colour
)
5585 m_mainWin
->SetBackgroundColour( colour
);
5586 m_mainWin
->m_dirty
= true;
5592 bool wxGenericListCtrl::SetForegroundColour( const wxColour
&colour
)
5594 if ( !wxWindow::SetForegroundColour( colour
) )
5599 m_mainWin
->SetForegroundColour( colour
);
5600 m_mainWin
->m_dirty
= true;
5604 m_headerWin
->SetForegroundColour( colour
);
5609 bool wxGenericListCtrl::SetFont( const wxFont
&font
)
5611 if ( !wxWindow::SetFont( font
) )
5616 m_mainWin
->SetFont( font
);
5617 m_mainWin
->m_dirty
= true;
5622 m_headerWin
->SetFont( font
);
5623 CalculateAndSetHeaderHeight();
5633 wxGenericListCtrl::GetClassDefaultAttributes(wxWindowVariant variant
)
5636 // Use the same color scheme as wxListBox
5637 return wxListBox::GetClassDefaultAttributes(variant
);
5639 wxUnusedVar(variant
);
5640 wxVisualAttributes attr
;
5641 attr
.colFg
= wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT
);
5642 attr
.colBg
= wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX
);
5643 attr
.font
= wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT
);
5648 // ----------------------------------------------------------------------------
5649 // methods forwarded to m_mainWin
5650 // ----------------------------------------------------------------------------
5652 #if wxUSE_DRAG_AND_DROP
5654 void wxGenericListCtrl::SetDropTarget( wxDropTarget
*dropTarget
)
5656 m_mainWin
->SetDropTarget( dropTarget
);
5659 wxDropTarget
*wxGenericListCtrl::GetDropTarget() const
5661 return m_mainWin
->GetDropTarget();
5666 bool wxGenericListCtrl::SetCursor( const wxCursor
&cursor
)
5668 return m_mainWin
? m_mainWin
->wxWindow::SetCursor(cursor
) : false;
5671 wxColour
wxGenericListCtrl::GetBackgroundColour() const
5673 return m_mainWin
? m_mainWin
->GetBackgroundColour() : wxColour();
5676 wxColour
wxGenericListCtrl::GetForegroundColour() const
5678 return m_mainWin
? m_mainWin
->GetForegroundColour() : wxColour();
5681 bool wxGenericListCtrl::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
5684 return m_mainWin
->PopupMenu( menu
, x
, y
);
5690 void wxGenericListCtrl::DoClientToScreen( int *x
, int *y
) const
5692 m_mainWin
->DoClientToScreen(x
, y
);
5695 void wxGenericListCtrl::DoScreenToClient( int *x
, int *y
) const
5697 m_mainWin
->DoScreenToClient(x
, y
);
5700 void wxGenericListCtrl::SetFocus()
5702 // The test in window.cpp fails as we are a composite
5703 // window, so it checks against "this", but not m_mainWin.
5704 if ( DoFindFocus() != this )
5705 m_mainWin
->SetFocus();
5708 wxSize
wxGenericListCtrl::DoGetBestSize() const
5710 // Something is better than nothing...
5711 // 100x80 is what the MSW version will get from the default
5712 // wxControl::DoGetBestSize
5713 return wxSize(100, 80);
5716 // ----------------------------------------------------------------------------
5717 // virtual list control support
5718 // ----------------------------------------------------------------------------
5720 wxString
wxGenericListCtrl::OnGetItemText(long WXUNUSED(item
), long WXUNUSED(col
)) const
5722 // this is a pure virtual function, in fact - which is not really pure
5723 // because the controls which are not virtual don't need to implement it
5724 wxFAIL_MSG( _T("wxGenericListCtrl::OnGetItemText not supposed to be called") );
5726 return wxEmptyString
;
5729 int wxGenericListCtrl::OnGetItemImage(long WXUNUSED(item
)) const
5731 wxCHECK_MSG(!GetImageList(wxIMAGE_LIST_SMALL
),
5733 wxT("List control has an image list, OnGetItemImage or OnGetItemColumnImage should be overridden."));
5737 int wxGenericListCtrl::OnGetItemColumnImage(long item
, long column
) const
5740 return OnGetItemImage(item
);
5746 wxGenericListCtrl::OnGetItemAttr(long WXUNUSED_UNLESS_DEBUG(item
)) const
5748 wxASSERT_MSG( item
>= 0 && item
< GetItemCount(),
5749 _T("invalid item index in OnGetItemAttr()") );
5751 // no attributes by default
5755 void wxGenericListCtrl::SetItemCount(long count
)
5757 wxASSERT_MSG( IsVirtual(), _T("this is for virtual controls only") );
5759 m_mainWin
->SetItemCount(count
);
5762 void wxGenericListCtrl::RefreshItem(long item
)
5764 m_mainWin
->RefreshLine(item
);
5767 void wxGenericListCtrl::RefreshItems(long itemFrom
, long itemTo
)
5769 m_mainWin
->RefreshLines(itemFrom
, itemTo
);
5772 // Generic wxListCtrl is more or less a container for two other
5773 // windows which drawings are done upon. These are namely
5774 // 'm_headerWin' and 'm_mainWin'.
5775 // Here we override 'virtual wxWindow::Refresh()' to mimic the
5776 // behaviour wxListCtrl has under wxMSW.
5778 void wxGenericListCtrl::Refresh(bool eraseBackground
, const wxRect
*rect
)
5782 // The easy case, no rectangle specified.
5784 m_headerWin
->Refresh(eraseBackground
);
5787 m_mainWin
->Refresh(eraseBackground
);
5791 // Refresh the header window
5794 wxRect rectHeader
= m_headerWin
->GetRect();
5795 rectHeader
.Intersect(*rect
);
5796 if (rectHeader
.GetWidth() && rectHeader
.GetHeight())
5799 m_headerWin
->GetPosition(&x
, &y
);
5800 rectHeader
.Offset(-x
, -y
);
5801 m_headerWin
->Refresh(eraseBackground
, &rectHeader
);
5805 // Refresh the main window
5808 wxRect rectMain
= m_mainWin
->GetRect();
5809 rectMain
.Intersect(*rect
);
5810 if (rectMain
.GetWidth() && rectMain
.GetHeight())
5813 m_mainWin
->GetPosition(&x
, &y
);
5814 rectMain
.Offset(-x
, -y
);
5815 m_mainWin
->Refresh(eraseBackground
, &rectMain
);
5821 void wxGenericListCtrl::Freeze()
5823 m_mainWin
->Freeze();
5826 void wxGenericListCtrl::Thaw()
5831 #endif // wxUSE_LISTCTRL