1 /////////////////////////////////////////////////////////////////////////////
2 // Name: generic/listctrl.cpp
3 // Purpose: generic implementation of wxListCtrl
4 // Author: Robert Roebling
5 // Vadim Zeitlin (virtual list control support)
7 // Copyright: (c) 1998 Robert Roebling
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
14 1. we need to implement searching/sorting for virtual controls somehow
15 ?2. when changing selection the lines are refreshed twice
18 // ============================================================================
20 // ============================================================================
22 // ----------------------------------------------------------------------------
24 // ----------------------------------------------------------------------------
27 #pragma implementation "listctrl.h"
28 #pragma implementation "listctrlbase.h"
31 // For compilers that support precompilation, includes "wx.h".
32 #include "wx/wxprec.h"
40 #include "wx/dcscreen.h"
42 #include "wx/listctrl.h"
43 #include "wx/imaglist.h"
44 #include "wx/dynarray.h"
48 #include "wx/gtk/win_gtk.h"
51 // ----------------------------------------------------------------------------
53 // ----------------------------------------------------------------------------
55 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_DRAG
)
56 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_RDRAG
)
57 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT
)
58 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_END_LABEL_EDIT
)
59 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_DELETE_ITEM
)
60 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS
)
61 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_GET_INFO
)
62 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_SET_INFO
)
63 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_SELECTED
)
64 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_DESELECTED
)
65 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_KEY_DOWN
)
66 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_INSERT_ITEM
)
67 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_CLICK
)
68 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_RIGHT_CLICK
)
69 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_BEGIN_DRAG
)
70 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_DRAGGING
)
71 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_COL_END_DRAG
)
72 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
)
73 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK
)
74 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_ITEM_ACTIVATED
)
75 DEFINE_EVENT_TYPE(wxEVT_COMMAND_LIST_CACHE_HINT
)
77 // ----------------------------------------------------------------------------
79 // ----------------------------------------------------------------------------
81 // the height of the header window (FIXME: should depend on its font!)
82 static const int HEADER_HEIGHT
= 23;
84 // the scrollbar units
85 static const int SCROLL_UNIT_X
= 15;
86 static const int SCROLL_UNIT_Y
= 15;
88 // the spacing between the lines (in report mode)
89 static const int LINE_SPACING
= 0;
91 // extra margins around the text label
92 static const int EXTRA_WIDTH
= 3;
93 static const int EXTRA_HEIGHT
= 4;
95 // offset for the header window
96 static const int HEADER_OFFSET_X
= 1;
97 static const int HEADER_OFFSET_Y
= 1;
99 // when autosizing the columns, add some slack
100 static const int AUTOSIZE_COL_MARGIN
= 10;
102 // default and minimal widths for the header columns
103 static const int WIDTH_COL_DEFAULT
= 80;
104 static const int WIDTH_COL_MIN
= 10;
106 // the space between the image and the text in the report mode
107 static const int IMAGE_MARGIN_IN_REPORT_MODE
= 5;
109 // ============================================================================
111 // ============================================================================
113 // ----------------------------------------------------------------------------
115 // ----------------------------------------------------------------------------
117 int CMPFUNC_CONV
wxSizeTCmpFn(size_t n1
, size_t n2
) { return n1
- n2
; }
119 WX_DEFINE_SORTED_EXPORTED_ARRAY(size_t, wxIndexArray
);
121 // this class is used to store the selected items in the virtual list control
122 // (but it is not tied to list control and so can be used with other controls
123 // such as wxListBox in wxUniv)
125 // the idea is to make it really smart later (i.e. store the selections as an
126 // array of ranes + individual items) but, as I don't have time to do it now
127 // (this would require writing code to merge/break ranges and much more) keep
128 // it simple but define a clean interface to it which allows it to be made
130 class WXDLLEXPORT wxSelectionStore
133 wxSelectionStore() : m_itemsSel(wxSizeTCmpFn
) { Init(); }
135 // set the total number of items we handle
136 void SetItemCount(size_t count
) { m_count
= count
; }
138 // special case of SetItemCount(0)
139 void Clear() { m_itemsSel
.Clear(); m_count
= 0; }
141 // must be called when a new item is inserted/added
142 void OnItemAdd(size_t item
) { wxFAIL_MSG( _T("TODO") ); }
144 // must be called when an item is deleted
145 void OnItemDelete(size_t item
);
147 // select one item, use SelectRange() insted if possible!
149 // returns true if the items selection really changed
150 bool SelectItem(size_t item
, bool select
= TRUE
);
152 // select the range of items
154 // return true and fill the itemsChanged array with the indices of items
155 // which have changed state if "few" of them did, otherwise return false
156 // (meaning that too many items changed state to bother counting them
158 bool SelectRange(size_t itemFrom
, size_t itemTo
,
160 wxArrayInt
*itemsChanged
= NULL
);
162 // return true if the given item is selected
163 bool IsSelected(size_t item
) const;
165 // return the total number of selected items
166 size_t GetSelectedCount() const
168 return m_defaultState
? m_count
- m_itemsSel
.GetCount()
169 : m_itemsSel
.GetCount();
174 void Init() { m_defaultState
= FALSE
; }
176 // the total number of items we handle
179 // the default state: normally, FALSE (i.e. off) but maybe set to TRUE if
180 // there are more selected items than non selected ones - this allows to
181 // handle selection of all items efficiently
184 // the array of items whose selection state is different from default
185 wxIndexArray m_itemsSel
;
187 DECLARE_NO_COPY_CLASS(wxSelectionStore
)
190 //-----------------------------------------------------------------------------
191 // wxListItemData (internal)
192 //-----------------------------------------------------------------------------
194 class WXDLLEXPORT wxListItemData
197 wxListItemData(wxListMainWindow
*owner
);
200 void SetItem( const wxListItem
&info
);
201 void SetImage( int image
) { m_image
= image
; }
202 void SetData( long data
) { m_data
= data
; }
203 void SetPosition( int x
, int y
);
204 void SetSize( int width
, int height
);
206 bool HasText() const { return !m_text
.empty(); }
207 const wxString
& GetText() const { return m_text
; }
208 void SetText(const wxString
& text
) { m_text
= text
; }
210 // we can't use empty string for measuring the string width/height, so
211 // always return something
212 wxString
GetTextForMeasuring() const
214 wxString s
= GetText();
221 bool IsHit( int x
, int y
) const;
225 int GetWidth() const;
226 int GetHeight() const;
228 int GetImage() const { return m_image
; }
229 bool HasImage() const { return GetImage() != -1; }
231 void GetItem( wxListItem
&info
) const;
233 void SetAttr(wxListItemAttr
*attr
) { m_attr
= attr
; }
234 wxListItemAttr
*GetAttr() const { return m_attr
; }
237 // the item image or -1
240 // user data associated with the item
243 // the item coordinates are not used in report mode, instead this pointer
244 // is NULL and the owner window is used to retrieve the item position and
248 // the list ctrl we are in
249 wxListMainWindow
*m_owner
;
251 // custom attributes or NULL
252 wxListItemAttr
*m_attr
;
255 // common part of all ctors
261 //-----------------------------------------------------------------------------
262 // wxListHeaderData (internal)
263 //-----------------------------------------------------------------------------
265 class WXDLLEXPORT wxListHeaderData
: public wxObject
269 wxListHeaderData( const wxListItem
&info
);
270 void SetItem( const wxListItem
&item
);
271 void SetPosition( int x
, int y
);
272 void SetWidth( int w
);
273 void SetFormat( int format
);
274 void SetHeight( int h
);
275 bool HasImage() const;
277 bool HasText() const { return !m_text
.empty(); }
278 const wxString
& GetText() const { return m_text
; }
279 void SetText(const wxString
& text
) { m_text
= text
; }
281 void GetItem( wxListItem
&item
);
283 bool IsHit( int x
, int y
) const;
284 int GetImage() const;
285 int GetWidth() const;
286 int GetFormat() const;
302 //-----------------------------------------------------------------------------
303 // wxListLineData (internal)
304 //-----------------------------------------------------------------------------
306 WX_DECLARE_LIST(wxListItemData
, wxListItemDataList
);
307 #include "wx/listimpl.cpp"
308 WX_DEFINE_LIST(wxListItemDataList
);
310 class WXDLLEXPORT wxListLineData
313 // the list of subitems: only may have more than one item in report mode
314 wxListItemDataList m_items
;
316 // this is not used in report view
328 // the part to be highlighted
329 wxRect m_rectHighlight
;
332 // is this item selected? [NB: not used in virtual mode]
335 // back pointer to the list ctrl
336 wxListMainWindow
*m_owner
;
339 wxListLineData(wxListMainWindow
*owner
);
341 ~wxListLineData() { delete m_gi
; }
343 // are we in report mode?
344 inline bool InReportView() const;
346 // are we in virtual report mode?
347 inline bool IsVirtual() const;
349 // these 2 methods shouldn't be called for report view controls, in that
350 // case we determine our position/size ourselves
352 // calculate the size of the line
353 void CalculateSize( wxDC
*dc
, int spacing
);
355 // remember the position this line appears at
356 void SetPosition( int x
, int y
, int window_width
, int spacing
);
360 void SetImage( int image
) { SetImage(0, image
); }
361 int GetImage() const { return GetImage(0); }
362 bool HasImage() const { return GetImage() != -1; }
363 bool HasText() const { return !GetText(0).empty(); }
365 void SetItem( int index
, const wxListItem
&info
);
366 void GetItem( int index
, wxListItem
&info
);
368 wxString
GetText(int index
) const;
369 void SetText( int index
, const wxString s
);
371 wxListItemAttr
*GetAttr() const;
372 void SetAttr(wxListItemAttr
*attr
);
374 // return true if the highlighting really changed
375 bool Highlight( bool on
);
377 void ReverseHighlight();
379 bool IsHighlighted() const
381 wxASSERT_MSG( !IsVirtual(), _T("unexpected call to IsHighlighted") );
383 return m_highlighted
;
386 // draw the line on the given DC in icon/list mode
387 void Draw( wxDC
*dc
);
389 // the same in report mode
390 void DrawInReportMode( wxDC
*dc
,
392 const wxRect
& rectHL
,
396 // set the line to contain num items (only can be > 1 in report mode)
397 void InitItems( int num
);
399 // get the mode (i.e. style) of the list control
400 inline int GetMode() const;
402 // prepare the DC for drawing with these item's attributes, return true if
403 // we need to draw the items background to highlight it, false otherwise
404 bool SetAttributes(wxDC
*dc
,
405 const wxListItemAttr
*attr
,
408 // these are only used by GetImage/SetImage above, we don't support images
409 // with subitems at the public API level yet
410 void SetImage( int index
, int image
);
411 int GetImage( int index
) const;
414 WX_DECLARE_EXPORTED_OBJARRAY(wxListLineData
, wxListLineDataArray
);
415 #include "wx/arrimpl.cpp"
416 WX_DEFINE_OBJARRAY(wxListLineDataArray
);
418 //-----------------------------------------------------------------------------
419 // wxListHeaderWindow (internal)
420 //-----------------------------------------------------------------------------
422 class WXDLLEXPORT wxListHeaderWindow
: public wxWindow
425 wxListMainWindow
*m_owner
;
426 wxCursor
*m_currentCursor
;
427 wxCursor
*m_resizeCursor
;
430 // column being resized
433 // divider line position in logical (unscrolled) coords
436 // minimal position beyond which the divider line can't be dragged in
441 wxListHeaderWindow();
443 wxListHeaderWindow( wxWindow
*win
,
445 wxListMainWindow
*owner
,
446 const wxPoint
&pos
= wxDefaultPosition
,
447 const wxSize
&size
= wxDefaultSize
,
449 const wxString
&name
= "wxlistctrlcolumntitles" );
451 virtual ~wxListHeaderWindow();
453 void DoDrawRect( wxDC
*dc
, int x
, int y
, int w
, int h
);
455 void AdjustDC(wxDC
& dc
);
457 void OnPaint( wxPaintEvent
&event
);
458 void OnMouse( wxMouseEvent
&event
);
459 void OnSetFocus( wxFocusEvent
&event
);
465 // common part of all ctors
468 DECLARE_DYNAMIC_CLASS(wxListHeaderWindow
)
469 DECLARE_EVENT_TABLE()
472 //-----------------------------------------------------------------------------
473 // wxListRenameTimer (internal)
474 //-----------------------------------------------------------------------------
476 class WXDLLEXPORT wxListRenameTimer
: public wxTimer
479 wxListMainWindow
*m_owner
;
482 wxListRenameTimer( wxListMainWindow
*owner
);
486 //-----------------------------------------------------------------------------
487 // wxListTextCtrl (internal)
488 //-----------------------------------------------------------------------------
490 class WXDLLEXPORT wxListTextCtrl
: public wxTextCtrl
495 wxListMainWindow
*m_owner
;
496 wxString m_startValue
;
500 wxListTextCtrl( wxWindow
*parent
, const wxWindowID id
,
501 bool *accept
, wxString
*res
, wxListMainWindow
*owner
,
502 const wxString
&value
= "",
503 const wxPoint
&pos
= wxDefaultPosition
, const wxSize
&size
= wxDefaultSize
,
505 const wxValidator
& validator
= wxDefaultValidator
,
506 const wxString
&name
= "listctrltextctrl" );
507 void OnChar( wxKeyEvent
&event
);
508 void OnKeyUp( wxKeyEvent
&event
);
509 void OnKillFocus( wxFocusEvent
&event
);
512 DECLARE_DYNAMIC_CLASS(wxListTextCtrl
);
513 DECLARE_EVENT_TABLE()
516 //-----------------------------------------------------------------------------
517 // wxListMainWindow (internal)
518 //-----------------------------------------------------------------------------
520 WX_DECLARE_LIST(wxListHeaderData
, wxListHeaderDataList
);
521 #include "wx/listimpl.cpp"
522 WX_DEFINE_LIST(wxListHeaderDataList
);
524 class WXDLLEXPORT wxListMainWindow
: public wxScrolledWindow
528 wxListMainWindow( wxWindow
*parent
,
530 const wxPoint
& pos
= wxDefaultPosition
,
531 const wxSize
& size
= wxDefaultSize
,
533 const wxString
&name
= _T("listctrlmainwindow") );
535 virtual ~wxListMainWindow();
537 bool HasFlag(int flag
) const { return m_parent
->HasFlag(flag
); }
539 // return true if this is a virtual list control
540 bool IsVirtual() const { return HasFlag(wxLC_VIRTUAL
); }
542 // return true if the control is in report mode
543 bool InReportView() const { return HasFlag(wxLC_REPORT
); }
545 // return true if we are in single selection mode, false if multi sel
546 bool IsSingleSel() const { return HasFlag(wxLC_SINGLE_SEL
); }
548 // do we have a header window?
549 bool HasHeader() const
550 { return HasFlag(wxLC_REPORT
) && !HasFlag(wxLC_NO_HEADER
); }
552 void HighlightAll( bool on
);
554 // all these functions only do something if the line is currently visible
556 // change the line "selected" state, return TRUE if it really changed
557 bool HighlightLine( size_t line
, bool highlight
= TRUE
);
559 // as HighlightLine() but do it for the range of lines: this is incredibly
560 // more efficient for virtual list controls!
562 // NB: unlike HighlightLine() this one does refresh the lines on screen
563 void HighlightLines( size_t lineFrom
, size_t lineTo
, bool on
= TRUE
);
565 // toggle the line state and refresh it
566 void ReverseHighlight( size_t line
)
567 { HighlightLine(line
, !IsHighlighted(line
)); RefreshLine(line
); }
569 // return true if the line is highlighted
570 bool IsHighlighted(size_t line
) const;
572 // refresh one or several lines at once
573 void RefreshLine( size_t line
);
574 void RefreshLines( size_t lineFrom
, size_t lineTo
);
576 // refresh all selected items
577 void RefreshSelected();
579 // refresh all lines below the given one: the difference with
580 // RefreshLines() is that the index here might not be a valid one (happens
581 // when the last line is deleted)
582 void RefreshAfter( size_t lineFrom
);
584 // the methods which are forwarded to wxListLineData itself in list/icon
585 // modes but are here because the lines don't store their positions in the
588 // get the bound rect for the entire line
589 wxRect
GetLineRect(size_t line
) const;
591 // get the bound rect of the label
592 wxRect
GetLineLabelRect(size_t line
) const;
594 // get the bound rect of the items icon (only may be called if we do have
596 wxRect
GetLineIconRect(size_t line
) const;
598 // get the rect to be highlighted when the item has focus
599 wxRect
GetLineHighlightRect(size_t line
) const;
601 // get the size of the total line rect
602 wxSize
GetLineSize(size_t line
) const
603 { return GetLineRect(line
).GetSize(); }
605 // return the hit code for the corresponding position (in this line)
606 long HitTestLine(size_t line
, int x
, int y
) const;
608 // bring the selected item into view, scrolling to it if necessary
609 void MoveToItem(size_t item
);
611 // bring the current item into view
612 void MoveToFocus() { MoveToItem(m_current
); }
614 void EditLabel( long item
);
615 void OnRenameTimer();
616 void OnRenameAccept();
618 void OnMouse( wxMouseEvent
&event
);
620 // called to switch the selection from the current item to newCurrent,
621 void OnArrowChar( size_t newCurrent
, const wxKeyEvent
& event
);
623 void OnChar( wxKeyEvent
&event
);
624 void OnKeyDown( wxKeyEvent
&event
);
625 void OnSetFocus( wxFocusEvent
&event
);
626 void OnKillFocus( wxFocusEvent
&event
);
627 void OnScroll(wxScrollWinEvent
& event
) ;
629 void OnPaint( wxPaintEvent
&event
);
631 void DrawImage( int index
, wxDC
*dc
, int x
, int y
);
632 void GetImageSize( int index
, int &width
, int &height
) const;
633 int GetTextLength( const wxString
&s
) const;
635 void SetImageList( wxImageList
*imageList
, int which
);
636 void SetItemSpacing( int spacing
, bool isSmall
= FALSE
);
637 int GetItemSpacing( bool isSmall
= FALSE
);
639 void SetColumn( int col
, wxListItem
&item
);
640 void SetColumnWidth( int col
, int width
);
641 void GetColumn( int col
, wxListItem
&item
) const;
642 int GetColumnWidth( int col
) const;
643 int GetColumnCount() const { return m_columns
.GetCount(); }
645 // returns the sum of the heights of all columns
646 int GetHeaderWidth() const;
648 int GetCountPerPage() const;
650 void SetItem( wxListItem
&item
);
651 void GetItem( wxListItem
&item
);
652 void SetItemState( long item
, long state
, long stateMask
);
653 int GetItemState( long item
, long stateMask
);
654 void GetItemRect( long index
, wxRect
&rect
);
655 bool GetItemPosition( long item
, wxPoint
& pos
);
656 int GetSelectedItemCount();
658 // set the scrollbars and update the positions of the items
659 void RecalculatePositions(bool noRefresh
= FALSE
);
661 // refresh the window and the header
664 long GetNextItem( long item
, int geometry
, int state
);
665 void DeleteItem( long index
);
666 void DeleteAllItems();
667 void DeleteColumn( int col
);
668 void DeleteEverything();
669 void EnsureVisible( long index
);
670 long FindItem( long start
, const wxString
& str
, bool partial
= FALSE
);
671 long FindItem( long start
, long data
);
672 long HitTest( int x
, int y
, int &flags
);
673 void InsertItem( wxListItem
&item
);
674 void InsertColumn( long col
, wxListItem
&item
);
675 void SortItems( wxListCtrlCompare fn
, long data
);
677 size_t GetItemCount() const;
678 bool IsEmpty() const { return GetItemCount() == 0; }
679 void SetItemCount(long count
);
681 void ResetCurrent() { m_current
= (size_t)-1; }
682 bool HasCurrent() const { return m_current
!= (size_t)-1; }
684 // send out a wxListEvent
685 void SendNotify( size_t line
,
687 wxPoint point
= wxDefaultPosition
);
689 // override base class virtual to reset m_lineHeight when the font changes
690 virtual bool SetFont(const wxFont
& font
)
692 if ( !wxScrolledWindow::SetFont(font
) )
700 // these are for wxListLineData usage only
702 // get the backpointer to the list ctrl
703 wxListCtrl
*GetListCtrl() const
705 return wxStaticCast(GetParent(), wxListCtrl
);
708 // get the height of all lines (assuming they all do have the same height)
709 wxCoord
GetLineHeight() const;
711 // get the y position of the given line (only for report view)
712 wxCoord
GetLineY(size_t line
) const;
714 // get the brush to use for the item highlighting
715 wxBrush
*GetHighlightBrush() const
717 return m_hasFocus
? m_highlightBrush
: m_highlightUnfocusedBrush
;
721 // the array of all line objects for a non virtual list control
722 wxListLineDataArray m_lines
;
724 // the list of column objects
725 wxListHeaderDataList m_columns
;
727 // currently focused item or -1
730 // the item currently being edited or -1
731 size_t m_currentEdit
;
733 // the number of lines per page
736 // this flag is set when something which should result in the window
737 // redrawing happens (i.e. an item was added or deleted, or its appearance
738 // changed) and OnPaint() doesn't redraw the window while it is set which
739 // allows to minimize the number of repaintings when a lot of items are
740 // being added. The real repainting occurs only after the next OnIdle()
744 wxColour
*m_highlightColour
;
747 wxImageList
*m_small_image_list
;
748 wxImageList
*m_normal_image_list
;
750 int m_normal_spacing
;
754 wxTimer
*m_renameTimer
;
756 wxString m_renameRes
;
761 // for double click logic
762 size_t m_lineLastClicked
,
763 m_lineBeforeLastClicked
;
766 // the total count of items in a virtual list control
769 // the object maintaining the items selection state, only used in virtual
771 wxSelectionStore m_selStore
;
773 // common part of all ctors
776 // intiialize m_[xy]Scroll
777 void InitScrolling();
779 // get the line data for the given index
780 wxListLineData
*GetLine(size_t n
) const
782 wxASSERT_MSG( n
!= (size_t)-1, _T("invalid line index") );
786 wxConstCast(this, wxListMainWindow
)->CacheLineData(n
);
794 // get a dummy line which can be used for geometry calculations and such:
795 // you must use GetLine() if you want to really draw the line
796 wxListLineData
*GetDummyLine() const;
798 // cache the line data of the n-th line in m_lines[0]
799 void CacheLineData(size_t line
);
801 // get the range of visible lines
802 void GetVisibleLinesRange(size_t *from
, size_t *to
);
804 // force us to recalculate the range of visible lines
805 void ResetVisibleLinesRange() { m_lineFrom
= (size_t)-1; }
807 // get the colour to be used for drawing the rules
808 wxColour
GetRuleColour() const
813 return wxSystemSettings::GetSystemColour(wxSYS_COLOUR_3DLIGHT
);
818 // initialize the current item if needed
819 void UpdateCurrent();
821 // delete all items but don't refresh: called from dtor
822 void DoDeleteAllItems();
824 // called when an item is [un]focuded, i.e. becomes [not] current
827 void OnFocusLine( size_t line
);
828 void OnUnfocusLine( size_t line
);
830 // the height of one line using the current font
831 wxCoord m_lineHeight
;
833 // the total header width or 0 if not calculated yet
834 wxCoord m_headerWidth
;
836 // the first and last lines being shown on screen right now (inclusive),
837 // both may be -1 if they must be calculated so never access them directly:
838 // use GetVisibleLinesRange() above instead
842 // the brushes to use for item highlighting when we do/don't have focus
843 wxBrush
*m_highlightBrush
,
844 *m_highlightUnfocusedBrush
;
846 DECLARE_DYNAMIC_CLASS(wxListMainWindow
);
847 DECLARE_EVENT_TABLE()
850 // ============================================================================
852 // ============================================================================
854 // ----------------------------------------------------------------------------
856 // ----------------------------------------------------------------------------
858 bool wxSelectionStore::IsSelected(size_t item
) const
860 bool isSel
= m_itemsSel
.Index(item
) != wxNOT_FOUND
;
862 // if the default state is to be selected, being in m_itemsSel means that
863 // the item is not selected, so we have to inverse the logic
864 return m_defaultState
? !isSel
: isSel
;
867 bool wxSelectionStore::SelectItem(size_t item
, bool select
)
869 // search for the item ourselves as like this we get the index where to
870 // insert it later if needed, so we do only one search in the array instead
871 // of two (adding item to a sorted array requires a search)
872 size_t index
= m_itemsSel
.IndexForInsert(item
);
873 bool isSel
= index
< m_itemsSel
.GetCount() && m_itemsSel
[index
] == item
;
875 if ( select
!= m_defaultState
)
879 m_itemsSel
.AddAt(item
, index
);
884 else // reset to default state
888 m_itemsSel
.RemoveAt(index
);
896 bool wxSelectionStore::SelectRange(size_t itemFrom
, size_t itemTo
,
898 wxArrayInt
*itemsChanged
)
900 // 100 is hardcoded but it shouldn't matter much: the important thing is
901 // that we don't refresh everything when really few (e.g. 1 or 2) items
903 static const size_t MANY_ITEMS
= 100;
905 wxASSERT_MSG( itemFrom
<= itemTo
, _T("should be in order") );
907 // are we going to have more [un]selected items than the other ones?
908 if ( itemTo
- itemFrom
> m_count
/2 )
910 if ( select
!= m_defaultState
)
912 // the default state now becomes the same as 'select'
913 m_defaultState
= select
;
915 // so all the old selections (which had state select) shouldn't be
916 // selected any more, but all the other ones should
917 wxIndexArray selOld
= m_itemsSel
;
920 // TODO: it should be possible to optimize the searches a bit
921 // knowing the possible range
924 for ( item
= 0; item
< itemFrom
; item
++ )
926 if ( selOld
.Index(item
) == wxNOT_FOUND
)
927 m_itemsSel
.Add(item
);
930 for ( item
= itemTo
+ 1; item
< m_count
; item
++ )
932 if ( selOld
.Index(item
) == wxNOT_FOUND
)
933 m_itemsSel
.Add(item
);
936 // many items (> half) changed state
939 else // select == m_defaultState
941 // get the inclusive range of items between itemFrom and itemTo
942 size_t count
= m_itemsSel
.GetCount(),
943 start
= m_itemsSel
.IndexForInsert(itemFrom
),
944 end
= m_itemsSel
.IndexForInsert(itemTo
);
946 if ( start
== count
|| m_itemsSel
[start
] < itemFrom
)
951 if ( end
== count
|| m_itemsSel
[end
] > itemTo
)
958 // delete all of them (from end to avoid changing indices)
959 for ( int i
= end
; i
>= (int)start
; i
-- )
963 if ( itemsChanged
->GetCount() > MANY_ITEMS
)
965 // stop counting (see comment below)
969 itemsChanged
->Add(m_itemsSel
[i
]);
972 m_itemsSel
.RemoveAt(i
);
977 else // "few" items change state
981 itemsChanged
->Empty();
984 // just add the items to the selection
985 for ( size_t item
= itemFrom
; item
<= itemTo
; item
++ )
987 if ( SelectItem(item
, select
) && itemsChanged
)
989 itemsChanged
->Add(item
);
991 if ( itemsChanged
->GetCount() > MANY_ITEMS
)
993 // stop counting them, we'll just eat gobs of memory
994 // for nothing at all - faster to refresh everything in
1002 // we set it to NULL if there are many items changing state
1003 return itemsChanged
!= NULL
;
1006 void wxSelectionStore::OnItemDelete(size_t item
)
1008 size_t count
= m_itemsSel
.GetCount(),
1009 i
= m_itemsSel
.IndexForInsert(item
);
1011 if ( i
< count
&& m_itemsSel
[i
] == item
)
1013 // this item itself was in m_itemsSel, remove it from there
1014 m_itemsSel
.RemoveAt(i
);
1019 // and adjust the index of all which follow it
1022 // all following elements must be greater than the one we deleted
1023 wxASSERT_MSG( m_itemsSel
[i
] > item
, _T("logic error") );
1029 //-----------------------------------------------------------------------------
1031 //-----------------------------------------------------------------------------
1033 wxListItemData::~wxListItemData()
1035 // in the virtual list control the attributes are managed by the main
1036 // program, so don't delete them
1037 if ( !m_owner
->IsVirtual() )
1045 void wxListItemData::Init()
1053 wxListItemData::wxListItemData(wxListMainWindow
*owner
)
1059 if ( owner
->InReportView() )
1065 m_rect
= new wxRect
;
1069 void wxListItemData::SetItem( const wxListItem
&info
)
1071 if ( info
.m_mask
& wxLIST_MASK_TEXT
)
1072 SetText(info
.m_text
);
1073 if ( info
.m_mask
& wxLIST_MASK_IMAGE
)
1074 m_image
= info
.m_image
;
1075 if ( info
.m_mask
& wxLIST_MASK_DATA
)
1076 m_data
= info
.m_data
;
1078 if ( info
.HasAttributes() )
1081 *m_attr
= *info
.GetAttributes();
1083 m_attr
= new wxListItemAttr(*info
.GetAttributes());
1091 m_rect
->width
= info
.m_width
;
1095 void wxListItemData::SetPosition( int x
, int y
)
1097 wxCHECK_RET( m_rect
, _T("unexpected SetPosition() call") );
1103 void wxListItemData::SetSize( int width
, int height
)
1105 wxCHECK_RET( m_rect
, _T("unexpected SetSize() call") );
1108 m_rect
->width
= width
;
1110 m_rect
->height
= height
;
1113 bool wxListItemData::IsHit( int x
, int y
) const
1115 wxCHECK_MSG( m_rect
, FALSE
, _T("can't be called in this mode") );
1117 return wxRect(GetX(), GetY(), GetWidth(), GetHeight()).Inside(x
, y
);
1120 int wxListItemData::GetX() const
1122 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
1127 int wxListItemData::GetY() const
1129 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
1134 int wxListItemData::GetWidth() const
1136 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
1138 return m_rect
->width
;
1141 int wxListItemData::GetHeight() const
1143 wxCHECK_MSG( m_rect
, 0, _T("can't be called in this mode") );
1145 return m_rect
->height
;
1148 void wxListItemData::GetItem( wxListItem
&info
) const
1150 info
.m_text
= m_text
;
1151 info
.m_image
= m_image
;
1152 info
.m_data
= m_data
;
1156 if ( m_attr
->HasTextColour() )
1157 info
.SetTextColour(m_attr
->GetTextColour());
1158 if ( m_attr
->HasBackgroundColour() )
1159 info
.SetBackgroundColour(m_attr
->GetBackgroundColour());
1160 if ( m_attr
->HasFont() )
1161 info
.SetFont(m_attr
->GetFont());
1165 //-----------------------------------------------------------------------------
1167 //-----------------------------------------------------------------------------
1169 void wxListHeaderData::Init()
1180 wxListHeaderData::wxListHeaderData()
1185 wxListHeaderData::wxListHeaderData( const wxListItem
&item
)
1192 void wxListHeaderData::SetItem( const wxListItem
&item
)
1194 m_mask
= item
.m_mask
;
1196 if ( m_mask
& wxLIST_MASK_TEXT
)
1197 m_text
= item
.m_text
;
1199 if ( m_mask
& wxLIST_MASK_IMAGE
)
1200 m_image
= item
.m_image
;
1202 if ( m_mask
& wxLIST_MASK_FORMAT
)
1203 m_format
= item
.m_format
;
1205 if ( m_mask
& wxLIST_MASK_WIDTH
)
1206 SetWidth(item
.m_width
);
1209 void wxListHeaderData::SetPosition( int x
, int y
)
1215 void wxListHeaderData::SetHeight( int h
)
1220 void wxListHeaderData::SetWidth( int w
)
1224 m_width
= WIDTH_COL_DEFAULT
;
1225 else if (m_width
< WIDTH_COL_MIN
)
1226 m_width
= WIDTH_COL_MIN
;
1229 void wxListHeaderData::SetFormat( int format
)
1234 bool wxListHeaderData::HasImage() const
1236 return m_image
!= -1;
1239 bool wxListHeaderData::IsHit( int x
, int y
) const
1241 return ((x
>= m_xpos
) && (x
<= m_xpos
+m_width
) && (y
>= m_ypos
) && (y
<= m_ypos
+m_height
));
1244 void wxListHeaderData::GetItem( wxListItem
& item
)
1246 item
.m_mask
= m_mask
;
1247 item
.m_text
= m_text
;
1248 item
.m_image
= m_image
;
1249 item
.m_format
= m_format
;
1250 item
.m_width
= m_width
;
1253 int wxListHeaderData::GetImage() const
1258 int wxListHeaderData::GetWidth() const
1263 int wxListHeaderData::GetFormat() const
1268 //-----------------------------------------------------------------------------
1270 //-----------------------------------------------------------------------------
1272 inline int wxListLineData::GetMode() const
1274 return m_owner
->GetListCtrl()->GetWindowStyleFlag() & wxLC_MASK_TYPE
;
1277 inline bool wxListLineData::InReportView() const
1279 return m_owner
->HasFlag(wxLC_REPORT
);
1282 inline bool wxListLineData::IsVirtual() const
1284 return m_owner
->IsVirtual();
1287 wxListLineData::wxListLineData( wxListMainWindow
*owner
)
1290 m_items
.DeleteContents( TRUE
);
1292 if ( InReportView() )
1298 m_gi
= new GeometryInfo
;
1301 m_highlighted
= FALSE
;
1303 InitItems( GetMode() == wxLC_REPORT
? m_owner
->GetColumnCount() : 1 );
1306 void wxListLineData::CalculateSize( wxDC
*dc
, int spacing
)
1308 wxListItemDataList::Node
*node
= m_items
.GetFirst();
1309 wxCHECK_RET( node
, _T("no subitems at all??") );
1311 wxListItemData
*item
= node
->GetData();
1313 switch ( GetMode() )
1316 case wxLC_SMALL_ICON
:
1318 m_gi
->m_rectAll
.width
= spacing
;
1320 wxString s
= item
->GetText();
1326 m_gi
->m_rectLabel
.width
=
1327 m_gi
->m_rectLabel
.height
= 0;
1331 dc
->GetTextExtent( s
, &lw
, &lh
);
1332 if (lh
< SCROLL_UNIT_Y
)
1337 m_gi
->m_rectAll
.height
= spacing
+ lh
;
1339 m_gi
->m_rectAll
.width
= lw
;
1341 m_gi
->m_rectLabel
.width
= lw
;
1342 m_gi
->m_rectLabel
.height
= lh
;
1345 if (item
->HasImage())
1348 m_owner
->GetImageSize( item
->GetImage(), w
, h
);
1349 m_gi
->m_rectIcon
.width
= w
+ 8;
1350 m_gi
->m_rectIcon
.height
= h
+ 8;
1352 if ( m_gi
->m_rectIcon
.width
> m_gi
->m_rectAll
.width
)
1353 m_gi
->m_rectAll
.width
= m_gi
->m_rectIcon
.width
;
1354 if ( m_gi
->m_rectIcon
.height
+ lh
> m_gi
->m_rectAll
.height
- 4 )
1355 m_gi
->m_rectAll
.height
= m_gi
->m_rectIcon
.height
+ lh
+ 4;
1358 if ( item
->HasText() )
1360 m_gi
->m_rectHighlight
.width
= m_gi
->m_rectLabel
.width
;
1361 m_gi
->m_rectHighlight
.height
= m_gi
->m_rectLabel
.height
;
1363 else // no text, highlight the icon
1365 m_gi
->m_rectHighlight
.width
= m_gi
->m_rectIcon
.width
;
1366 m_gi
->m_rectHighlight
.height
= m_gi
->m_rectIcon
.height
;
1373 wxString s
= item
->GetTextForMeasuring();
1376 dc
->GetTextExtent( s
, &lw
, &lh
);
1377 if (lh
< SCROLL_UNIT_Y
)
1382 m_gi
->m_rectLabel
.width
= lw
;
1383 m_gi
->m_rectLabel
.height
= lh
;
1385 m_gi
->m_rectAll
.width
= lw
;
1386 m_gi
->m_rectAll
.height
= lh
;
1388 if (item
->HasImage())
1391 m_owner
->GetImageSize( item
->GetImage(), w
, h
);
1392 m_gi
->m_rectIcon
.width
= w
;
1393 m_gi
->m_rectIcon
.height
= h
;
1395 m_gi
->m_rectAll
.width
+= 4 + w
;
1396 if (h
> m_gi
->m_rectAll
.height
)
1397 m_gi
->m_rectAll
.height
= h
;
1400 m_gi
->m_rectHighlight
.width
= m_gi
->m_rectAll
.width
;
1401 m_gi
->m_rectHighlight
.height
= m_gi
->m_rectAll
.height
;
1406 wxFAIL_MSG( _T("unexpected call to SetSize") );
1410 wxFAIL_MSG( _T("unknown mode") );
1414 void wxListLineData::SetPosition( int x
, int y
,
1418 wxListItemDataList::Node
*node
= m_items
.GetFirst();
1419 wxCHECK_RET( node
, _T("no subitems at all??") );
1421 wxListItemData
*item
= node
->GetData();
1423 switch ( GetMode() )
1426 case wxLC_SMALL_ICON
:
1427 m_gi
->m_rectAll
.x
= x
;
1428 m_gi
->m_rectAll
.y
= y
;
1430 if ( item
->HasImage() )
1432 m_gi
->m_rectIcon
.x
= m_gi
->m_rectAll
.x
+ 4
1433 + (spacing
- m_gi
->m_rectIcon
.width
)/2;
1434 m_gi
->m_rectIcon
.y
= m_gi
->m_rectAll
.y
+ 4;
1437 if ( item
->HasText() )
1439 if (m_gi
->m_rectAll
.width
> spacing
)
1440 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ 2;
1442 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ 2 + (spacing
/2) - (m_gi
->m_rectLabel
.width
/2);
1443 m_gi
->m_rectLabel
.y
= m_gi
->m_rectAll
.y
+ m_gi
->m_rectAll
.height
+ 2 - m_gi
->m_rectLabel
.height
;
1444 m_gi
->m_rectHighlight
.x
= m_gi
->m_rectLabel
.x
- 2;
1445 m_gi
->m_rectHighlight
.y
= m_gi
->m_rectLabel
.y
- 2;
1447 else // no text, highlight the icon
1449 m_gi
->m_rectHighlight
.x
= m_gi
->m_rectIcon
.x
- 4;
1450 m_gi
->m_rectHighlight
.y
= m_gi
->m_rectIcon
.y
- 4;
1455 m_gi
->m_rectAll
.x
= x
;
1456 m_gi
->m_rectAll
.y
= y
;
1458 m_gi
->m_rectHighlight
.x
= m_gi
->m_rectAll
.x
;
1459 m_gi
->m_rectHighlight
.y
= m_gi
->m_rectAll
.y
;
1460 m_gi
->m_rectLabel
.y
= m_gi
->m_rectAll
.y
+ 2;
1462 if (item
->HasImage())
1464 m_gi
->m_rectIcon
.x
= m_gi
->m_rectAll
.x
+ 2;
1465 m_gi
->m_rectIcon
.y
= m_gi
->m_rectAll
.y
+ 2;
1466 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ 6 + m_gi
->m_rectIcon
.width
;
1470 m_gi
->m_rectLabel
.x
= m_gi
->m_rectAll
.x
+ 2;
1475 wxFAIL_MSG( _T("unexpected call to SetPosition") );
1479 wxFAIL_MSG( _T("unknown mode") );
1483 void wxListLineData::InitItems( int num
)
1485 for (int i
= 0; i
< num
; i
++)
1486 m_items
.Append( new wxListItemData(m_owner
) );
1489 void wxListLineData::SetItem( int index
, const wxListItem
&info
)
1491 wxListItemDataList::Node
*node
= m_items
.Item( index
);
1492 wxCHECK_RET( node
, _T("invalid column index in SetItem") );
1494 wxListItemData
*item
= node
->GetData();
1495 item
->SetItem( info
);
1498 void wxListLineData::GetItem( int index
, wxListItem
&info
)
1500 wxListItemDataList::Node
*node
= m_items
.Item( index
);
1503 wxListItemData
*item
= node
->GetData();
1504 item
->GetItem( info
);
1508 wxString
wxListLineData::GetText(int index
) const
1512 wxListItemDataList::Node
*node
= m_items
.Item( index
);
1515 wxListItemData
*item
= node
->GetData();
1516 s
= item
->GetText();
1522 void wxListLineData::SetText( int index
, const wxString s
)
1524 wxListItemDataList::Node
*node
= m_items
.Item( index
);
1527 wxListItemData
*item
= node
->GetData();
1532 void wxListLineData::SetImage( int index
, int image
)
1534 wxListItemDataList::Node
*node
= m_items
.Item( index
);
1535 wxCHECK_RET( node
, _T("invalid column index in SetImage()") );
1537 wxListItemData
*item
= node
->GetData();
1538 item
->SetImage(image
);
1541 int wxListLineData::GetImage( int index
) const
1543 wxListItemDataList::Node
*node
= m_items
.Item( index
);
1544 wxCHECK_MSG( node
, -1, _T("invalid column index in GetImage()") );
1546 wxListItemData
*item
= node
->GetData();
1547 return item
->GetImage();
1550 wxListItemAttr
*wxListLineData::GetAttr() const
1552 wxListItemDataList::Node
*node
= m_items
.GetFirst();
1553 wxCHECK_MSG( node
, NULL
, _T("invalid column index in GetAttr()") );
1555 wxListItemData
*item
= node
->GetData();
1556 return item
->GetAttr();
1559 void wxListLineData::SetAttr(wxListItemAttr
*attr
)
1561 wxListItemDataList::Node
*node
= m_items
.GetFirst();
1562 wxCHECK_RET( node
, _T("invalid column index in SetAttr()") );
1564 wxListItemData
*item
= node
->GetData();
1565 item
->SetAttr(attr
);
1568 bool wxListLineData::SetAttributes(wxDC
*dc
,
1569 const wxListItemAttr
*attr
,
1572 wxWindow
*listctrl
= m_owner
->GetParent();
1576 // don't use foreground colour for drawing highlighted items - this might
1577 // make them completely invisible (and there is no way to do bit
1578 // arithmetics on wxColour, unfortunately)
1582 colText
= wxSystemSettings::GetSystemColour(wxSYS_COLOUR_HIGHLIGHTTEXT
);
1586 if ( attr
&& attr
->HasTextColour() )
1588 colText
= attr
->GetTextColour();
1592 colText
= listctrl
->GetForegroundColour();
1596 dc
->SetTextForeground(colText
);
1600 if ( attr
&& attr
->HasFont() )
1602 font
= attr
->GetFont();
1606 font
= listctrl
->GetFont();
1612 bool hasBgCol
= attr
&& attr
->HasBackgroundColour();
1613 if ( highlighted
|| hasBgCol
)
1617 dc
->SetBrush( *m_owner
->GetHighlightBrush() );
1621 dc
->SetBrush(wxBrush(attr
->GetBackgroundColour(), wxSOLID
));
1624 dc
->SetPen( *wxTRANSPARENT_PEN
);
1632 void wxListLineData::Draw( wxDC
*dc
)
1634 wxListItemDataList::Node
*node
= m_items
.GetFirst();
1635 wxCHECK_RET( node
, _T("no subitems at all??") );
1637 bool highlighted
= IsHighlighted();
1639 wxListItemAttr
*attr
= GetAttr();
1641 if ( SetAttributes(dc
, attr
, highlighted
) )
1643 dc
->DrawRectangle( m_gi
->m_rectHighlight
);
1646 wxListItemData
*item
= node
->GetData();
1647 if (item
->HasImage())
1649 wxRect rectIcon
= m_gi
->m_rectIcon
;
1650 m_owner
->DrawImage( item
->GetImage(), dc
,
1651 rectIcon
.x
, rectIcon
.y
);
1654 if (item
->HasText())
1656 wxRect rectLabel
= m_gi
->m_rectLabel
;
1658 wxDCClipper
clipper(*dc
, rectLabel
);
1659 dc
->DrawText( item
->GetText(), rectLabel
.x
, rectLabel
.y
);
1663 void wxListLineData::DrawInReportMode( wxDC
*dc
,
1665 const wxRect
& rectHL
,
1668 // TODO: later we should support setting different attributes for
1669 // different columns - to do it, just add "col" argument to
1670 // GetAttr() and move these lines into the loop below
1671 wxListItemAttr
*attr
= GetAttr();
1672 if ( SetAttributes(dc
, attr
, highlighted
) )
1674 dc
->DrawRectangle( rectHL
);
1677 wxListItemDataList::Node
*node
= m_items
.GetFirst();
1678 wxCHECK_RET( node
, _T("no subitems at all??") );
1681 wxCoord x
= rect
.x
+ HEADER_OFFSET_X
,
1682 y
= rect
.y
+ (LINE_SPACING
+ EXTRA_HEIGHT
) / 2;
1686 wxListItemData
*item
= node
->GetData();
1688 int width
= m_owner
->GetColumnWidth(col
++);
1692 if ( item
->HasImage() )
1695 m_owner
->DrawImage( item
->GetImage(), dc
, xOld
, y
);
1696 m_owner
->GetImageSize( item
->GetImage(), ix
, iy
);
1698 ix
+= IMAGE_MARGIN_IN_REPORT_MODE
;
1704 wxDCClipper
clipper(*dc
, xOld
, y
, width
, rect
.height
);
1706 if ( item
->HasText() )
1708 dc
->DrawText( item
->GetText(), xOld
, y
);
1711 node
= node
->GetNext();
1715 bool wxListLineData::Highlight( bool on
)
1717 wxCHECK_MSG( !m_owner
->IsVirtual(), FALSE
, _T("unexpected call to Highlight") );
1719 if ( on
== m_highlighted
)
1727 void wxListLineData::ReverseHighlight( void )
1729 Highlight(!IsHighlighted());
1732 //-----------------------------------------------------------------------------
1733 // wxListHeaderWindow
1734 //-----------------------------------------------------------------------------
1736 IMPLEMENT_DYNAMIC_CLASS(wxListHeaderWindow
,wxWindow
);
1738 BEGIN_EVENT_TABLE(wxListHeaderWindow
,wxWindow
)
1739 EVT_PAINT (wxListHeaderWindow::OnPaint
)
1740 EVT_MOUSE_EVENTS (wxListHeaderWindow::OnMouse
)
1741 EVT_SET_FOCUS (wxListHeaderWindow::OnSetFocus
)
1744 void wxListHeaderWindow::Init()
1746 m_currentCursor
= (wxCursor
*) NULL
;
1747 m_isDragging
= FALSE
;
1751 wxListHeaderWindow::wxListHeaderWindow()
1755 m_owner
= (wxListMainWindow
*) NULL
;
1756 m_resizeCursor
= (wxCursor
*) NULL
;
1759 wxListHeaderWindow::wxListHeaderWindow( wxWindow
*win
,
1761 wxListMainWindow
*owner
,
1765 const wxString
&name
)
1766 : wxWindow( win
, id
, pos
, size
, style
, name
)
1771 m_resizeCursor
= new wxCursor( wxCURSOR_SIZEWE
);
1773 SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNFACE
) );
1776 wxListHeaderWindow::~wxListHeaderWindow()
1778 delete m_resizeCursor
;
1781 void wxListHeaderWindow::DoDrawRect( wxDC
*dc
, int x
, int y
, int w
, int h
)
1784 GtkStateType state
= m_parent
->IsEnabled() ? GTK_STATE_NORMAL
1785 : GTK_STATE_INSENSITIVE
;
1787 x
= dc
->XLOG2DEV( x
);
1789 gtk_paint_box (m_wxwindow
->style
, GTK_PIZZA(m_wxwindow
)->bin_window
,
1790 state
, GTK_SHADOW_OUT
,
1791 (GdkRectangle
*) NULL
, m_wxwindow
, "button",
1792 x
-1, y
-1, w
+2, h
+2);
1793 #elif defined( __WXMAC__ )
1794 const int m_corner
= 1;
1796 dc
->SetBrush( *wxTRANSPARENT_BRUSH
);
1798 dc
->SetPen( wxPen( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNSHADOW
) , 1 , wxSOLID
) );
1799 dc
->DrawLine( x
+w
-m_corner
+1, y
, x
+w
, y
+h
); // right (outer)
1800 dc
->DrawRectangle( x
, y
+h
, w
+1, 1 ); // bottom (outer)
1802 wxPen
pen( wxColour( 0x88 , 0x88 , 0x88 ), 1, wxSOLID
);
1805 dc
->DrawLine( x
+w
-m_corner
, y
, x
+w
-1, y
+h
); // right (inner)
1806 dc
->DrawRectangle( x
+1, y
+h
-1, w
-2, 1 ); // bottom (inner)
1808 dc
->SetPen( *wxWHITE_PEN
);
1809 dc
->DrawRectangle( x
, y
, w
-m_corner
+1, 1 ); // top (outer)
1810 dc
->DrawRectangle( x
, y
, 1, h
); // left (outer)
1811 dc
->DrawLine( x
, y
+h
-1, x
+1, y
+h
-1 );
1812 dc
->DrawLine( x
+w
-1, y
, x
+w
-1, y
+1 );
1814 const int m_corner
= 1;
1816 dc
->SetBrush( *wxTRANSPARENT_BRUSH
);
1818 dc
->SetPen( *wxBLACK_PEN
);
1819 dc
->DrawLine( x
+w
-m_corner
+1, y
, x
+w
, y
+h
); // right (outer)
1820 dc
->DrawRectangle( x
, y
+h
, w
+1, 1 ); // bottom (outer)
1822 wxPen
pen( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_BTNSHADOW
), 1, wxSOLID
);
1825 dc
->DrawLine( x
+w
-m_corner
, y
, x
+w
-1, y
+h
); // right (inner)
1826 dc
->DrawRectangle( x
+1, y
+h
-1, w
-2, 1 ); // bottom (inner)
1828 dc
->SetPen( *wxWHITE_PEN
);
1829 dc
->DrawRectangle( x
, y
, w
-m_corner
+1, 1 ); // top (outer)
1830 dc
->DrawRectangle( x
, y
, 1, h
); // left (outer)
1831 dc
->DrawLine( x
, y
+h
-1, x
+1, y
+h
-1 );
1832 dc
->DrawLine( x
+w
-1, y
, x
+w
-1, y
+1 );
1836 // shift the DC origin to match the position of the main window horz
1837 // scrollbar: this allows us to always use logical coords
1838 void wxListHeaderWindow::AdjustDC(wxDC
& dc
)
1841 m_owner
->GetScrollPixelsPerUnit( &xpix
, NULL
);
1844 m_owner
->GetViewStart( &x
, NULL
);
1846 // account for the horz scrollbar offset
1847 dc
.SetDeviceOrigin( -x
* xpix
, 0 );
1850 void wxListHeaderWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
1853 wxClientDC
dc( this );
1855 wxPaintDC
dc( this );
1863 dc
.SetFont( GetFont() );
1865 // width and height of the entire header window
1867 GetClientSize( &w
, &h
);
1868 m_owner
->CalcUnscrolledPosition(w
, 0, &w
, NULL
);
1870 dc
.SetBackgroundMode(wxTRANSPARENT
);
1872 // do *not* use the listctrl colour for headers - one day we will have a
1873 // function to set it separately
1874 //dc.SetTextForeground( *wxBLACK );
1875 dc
.SetTextForeground(wxSystemSettings::
1876 GetSystemColour( wxSYS_COLOUR_WINDOWTEXT
));
1878 int x
= HEADER_OFFSET_X
;
1880 int numColumns
= m_owner
->GetColumnCount();
1882 for (int i
= 0; i
< numColumns
; i
++)
1884 m_owner
->GetColumn( i
, item
);
1885 int wCol
= item
.m_width
;
1887 // the width of the rect to draw: make it smaller to fit entirely
1888 // inside the column rect
1891 dc
.SetPen( *wxWHITE_PEN
);
1893 DoDrawRect( &dc
, x
, HEADER_OFFSET_Y
, cw
, h
-2 );
1895 // if we have an image, draw it on the right of the label
1896 int image
= item
.m_image
;
1899 wxImageList
*imageList
= m_owner
->m_small_image_list
;
1903 imageList
->GetSize(image
, ix
, iy
);
1910 HEADER_OFFSET_Y
+ (h
- 4 - iy
)/2,
1911 wxIMAGELIST_DRAW_TRANSPARENT
1916 //else: ignore the column image
1919 // draw the text clipping it so that it doesn't overwrite the column
1921 wxDCClipper
clipper(dc
, x
, HEADER_OFFSET_Y
, cw
, h
- 4 );
1923 dc
.DrawText( item
.GetText(),
1924 x
+ EXTRA_WIDTH
, HEADER_OFFSET_Y
+ EXTRA_HEIGHT
);
1926 if ( x
> w
- wCol
+ 5 )
1934 void wxListHeaderWindow::DrawCurrent()
1936 int x1
= m_currentX
;
1938 ClientToScreen( &x1
, &y1
);
1940 int x2
= m_currentX
-1;
1942 m_owner
->GetClientSize( NULL
, &y2
);
1943 m_owner
->ClientToScreen( &x2
, &y2
);
1946 dc
.SetLogicalFunction( wxINVERT
);
1947 dc
.SetPen( wxPen( *wxBLACK
, 2, wxSOLID
) );
1948 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
1952 dc
.DrawLine( x1
, y1
, x2
, y2
);
1954 dc
.SetLogicalFunction( wxCOPY
);
1956 dc
.SetPen( wxNullPen
);
1957 dc
.SetBrush( wxNullBrush
);
1960 void wxListHeaderWindow::OnMouse( wxMouseEvent
&event
)
1962 // we want to work with logical coords
1964 m_owner
->CalcUnscrolledPosition(event
.GetX(), 0, &x
, NULL
);
1965 int y
= event
.GetY();
1969 // we don't draw the line beyond our window, but we allow dragging it
1972 GetClientSize( &w
, NULL
);
1973 m_owner
->CalcUnscrolledPosition(w
, 0, &w
, NULL
);
1976 // erase the line if it was drawn
1977 if ( m_currentX
< w
)
1980 if (event
.ButtonUp())
1983 m_isDragging
= FALSE
;
1985 m_owner
->SetColumnWidth( m_column
, m_currentX
- m_minX
);
1992 m_currentX
= m_minX
+ 7;
1994 // draw in the new location
1995 if ( m_currentX
< w
)
1999 else // not dragging
2002 bool hit_border
= FALSE
;
2004 // end of the current column
2007 // find the column where this event occured
2008 int countCol
= m_owner
->GetColumnCount();
2009 for (int col
= 0; col
< countCol
; col
++)
2011 xpos
+= m_owner
->GetColumnWidth( col
);
2014 if ( (abs(x
-xpos
) < 3) && (y
< 22) )
2016 // near the column border
2023 // inside the column
2030 if (event
.LeftDown() || event
.RightUp())
2032 if (hit_border
&& event
.LeftDown())
2034 m_isDragging
= TRUE
;
2039 else // click on a column
2041 wxWindow
*parent
= GetParent();
2042 wxListEvent
le( event
.LeftDown()
2043 ? wxEVT_COMMAND_LIST_COL_CLICK
2044 : wxEVT_COMMAND_LIST_COL_RIGHT_CLICK
,
2046 le
.SetEventObject( parent
);
2047 le
.m_pointDrag
= event
.GetPosition();
2049 // the position should be relative to the parent window, not
2050 // this one for compatibility with MSW and common sense: the
2051 // user code doesn't know anything at all about this header
2052 // window, so why should it get positions relative to it?
2053 le
.m_pointDrag
.y
-= GetSize().y
;
2055 le
.m_col
= m_column
;
2056 parent
->GetEventHandler()->ProcessEvent( le
);
2059 else if (event
.Moving())
2064 setCursor
= m_currentCursor
== wxSTANDARD_CURSOR
;
2065 m_currentCursor
= m_resizeCursor
;
2069 setCursor
= m_currentCursor
!= wxSTANDARD_CURSOR
;
2070 m_currentCursor
= wxSTANDARD_CURSOR
;
2074 SetCursor(*m_currentCursor
);
2079 void wxListHeaderWindow::OnSetFocus( wxFocusEvent
&WXUNUSED(event
) )
2081 m_owner
->SetFocus();
2084 //-----------------------------------------------------------------------------
2085 // wxListRenameTimer (internal)
2086 //-----------------------------------------------------------------------------
2088 wxListRenameTimer::wxListRenameTimer( wxListMainWindow
*owner
)
2093 void wxListRenameTimer::Notify()
2095 m_owner
->OnRenameTimer();
2098 //-----------------------------------------------------------------------------
2099 // wxListTextCtrl (internal)
2100 //-----------------------------------------------------------------------------
2102 IMPLEMENT_DYNAMIC_CLASS(wxListTextCtrl
,wxTextCtrl
);
2104 BEGIN_EVENT_TABLE(wxListTextCtrl
,wxTextCtrl
)
2105 EVT_CHAR (wxListTextCtrl::OnChar
)
2106 EVT_KEY_UP (wxListTextCtrl::OnKeyUp
)
2107 EVT_KILL_FOCUS (wxListTextCtrl::OnKillFocus
)
2110 wxListTextCtrl::wxListTextCtrl( wxWindow
*parent
,
2111 const wxWindowID id
,
2114 wxListMainWindow
*owner
,
2115 const wxString
&value
,
2119 const wxValidator
& validator
,
2120 const wxString
&name
)
2121 : wxTextCtrl( parent
, id
, value
, pos
, size
, style
, validator
, name
)
2126 (*m_accept
) = FALSE
;
2128 m_startValue
= value
;
2131 void wxListTextCtrl::OnChar( wxKeyEvent
&event
)
2133 if (event
.m_keyCode
== WXK_RETURN
)
2136 (*m_res
) = GetValue();
2138 if (!wxPendingDelete
.Member(this))
2139 wxPendingDelete
.Append(this);
2141 if ((*m_accept
) && ((*m_res
) != m_startValue
))
2142 m_owner
->OnRenameAccept();
2146 if (event
.m_keyCode
== WXK_ESCAPE
)
2148 (*m_accept
) = FALSE
;
2151 if (!wxPendingDelete
.Member(this))
2152 wxPendingDelete
.Append(this);
2160 void wxListTextCtrl::OnKeyUp( wxKeyEvent
&event
)
2162 // auto-grow the textctrl:
2163 wxSize parentSize
= m_owner
->GetSize();
2164 wxPoint myPos
= GetPosition();
2165 wxSize mySize
= GetSize();
2167 GetTextExtent(GetValue() + _T("MM"), &sx
, &sy
); // FIXME: MM??
2168 if (myPos
.x
+ sx
> parentSize
.x
)
2169 sx
= parentSize
.x
- myPos
.x
;
2177 void wxListTextCtrl::OnKillFocus( wxFocusEvent
&WXUNUSED(event
) )
2179 if (!wxPendingDelete
.Member(this))
2180 wxPendingDelete
.Append(this);
2182 if ((*m_accept
) && ((*m_res
) != m_startValue
))
2183 m_owner
->OnRenameAccept();
2186 //-----------------------------------------------------------------------------
2188 //-----------------------------------------------------------------------------
2190 IMPLEMENT_DYNAMIC_CLASS(wxListMainWindow
,wxScrolledWindow
);
2192 BEGIN_EVENT_TABLE(wxListMainWindow
,wxScrolledWindow
)
2193 EVT_PAINT (wxListMainWindow::OnPaint
)
2194 EVT_MOUSE_EVENTS (wxListMainWindow::OnMouse
)
2195 EVT_CHAR (wxListMainWindow::OnChar
)
2196 EVT_KEY_DOWN (wxListMainWindow::OnKeyDown
)
2197 EVT_SET_FOCUS (wxListMainWindow::OnSetFocus
)
2198 EVT_KILL_FOCUS (wxListMainWindow::OnKillFocus
)
2199 EVT_SCROLLWIN (wxListMainWindow::OnScroll
)
2202 void wxListMainWindow::Init()
2204 m_columns
.DeleteContents( TRUE
);
2208 m_lineTo
= (size_t)-1;
2214 m_small_image_list
= (wxImageList
*) NULL
;
2215 m_normal_image_list
= (wxImageList
*) NULL
;
2217 m_small_spacing
= 30;
2218 m_normal_spacing
= 40;
2222 m_isCreated
= FALSE
;
2224 m_lastOnSame
= FALSE
;
2225 m_renameTimer
= new wxListRenameTimer( this );
2226 m_renameAccept
= FALSE
;
2231 m_lineBeforeLastClicked
= (size_t)-1;
2234 void wxListMainWindow::InitScrolling()
2236 if ( HasFlag(wxLC_REPORT
) )
2238 m_xScroll
= SCROLL_UNIT_X
;
2239 m_yScroll
= SCROLL_UNIT_Y
;
2243 m_xScroll
= SCROLL_UNIT_Y
;
2248 wxListMainWindow::wxListMainWindow()
2253 m_highlightUnfocusedBrush
= (wxBrush
*) NULL
;
2259 wxListMainWindow::wxListMainWindow( wxWindow
*parent
,
2264 const wxString
&name
)
2265 : wxScrolledWindow( parent
, id
, pos
, size
,
2266 style
| wxHSCROLL
| wxVSCROLL
, name
)
2270 m_highlightBrush
= new wxBrush
2272 wxSystemSettings::GetSystemColour
2274 wxSYS_COLOUR_HIGHLIGHT
2279 m_highlightUnfocusedBrush
= new wxBrush
2281 wxSystemSettings::GetSystemColour
2283 wxSYS_COLOUR_BTNSHADOW
2292 SetScrollbars( m_xScroll
, m_yScroll
, 0, 0, 0, 0 );
2294 SetBackgroundColour( wxSystemSettings::GetSystemColour( wxSYS_COLOUR_LISTBOX
) );
2297 wxListMainWindow::~wxListMainWindow()
2301 delete m_highlightBrush
;
2302 delete m_highlightUnfocusedBrush
;
2304 delete m_renameTimer
;
2307 void wxListMainWindow::CacheLineData(size_t line
)
2309 wxListCtrl
*listctrl
= GetListCtrl();
2311 wxListLineData
*ld
= GetDummyLine();
2313 size_t countCol
= GetColumnCount();
2314 for ( size_t col
= 0; col
< countCol
; col
++ )
2316 ld
->SetText(col
, listctrl
->OnGetItemText(line
, col
));
2319 ld
->SetImage(listctrl
->OnGetItemImage(line
));
2320 ld
->SetAttr(listctrl
->OnGetItemAttr(line
));
2323 wxListLineData
*wxListMainWindow::GetDummyLine() const
2325 wxASSERT_MSG( !IsEmpty(), _T("invalid line index") );
2327 if ( m_lines
.IsEmpty() )
2329 // normal controls are supposed to have something in m_lines
2330 // already if it's not empty
2331 wxASSERT_MSG( IsVirtual(), _T("logic error") );
2333 wxListMainWindow
*self
= wxConstCast(this, wxListMainWindow
);
2334 wxListLineData
*line
= new wxListLineData(self
);
2335 self
->m_lines
.Add(line
);
2341 // ----------------------------------------------------------------------------
2342 // line geometry (report mode only)
2343 // ----------------------------------------------------------------------------
2345 wxCoord
wxListMainWindow::GetLineHeight() const
2347 wxASSERT_MSG( HasFlag(wxLC_REPORT
), _T("only works in report mode") );
2349 // we cache the line height as calling GetTextExtent() is slow
2350 if ( !m_lineHeight
)
2352 wxListMainWindow
*self
= wxConstCast(this, wxListMainWindow
);
2354 wxClientDC
dc( self
);
2355 dc
.SetFont( GetFont() );
2358 dc
.GetTextExtent(_T("H"), NULL
, &y
);
2360 if ( y
< SCROLL_UNIT_Y
)
2364 self
->m_lineHeight
= y
+ LINE_SPACING
;
2367 return m_lineHeight
;
2370 wxCoord
wxListMainWindow::GetLineY(size_t line
) const
2372 wxASSERT_MSG( HasFlag(wxLC_REPORT
), _T("only works in report mode") );
2374 return LINE_SPACING
+ line
*GetLineHeight();
2377 wxRect
wxListMainWindow::GetLineRect(size_t line
) const
2379 if ( !InReportView() )
2380 return GetLine(line
)->m_gi
->m_rectAll
;
2383 rect
.x
= HEADER_OFFSET_X
;
2384 rect
.y
= GetLineY(line
);
2385 rect
.width
= GetHeaderWidth();
2386 rect
.height
= GetLineHeight();
2391 wxRect
wxListMainWindow::GetLineLabelRect(size_t line
) const
2393 if ( !InReportView() )
2394 return GetLine(line
)->m_gi
->m_rectLabel
;
2397 rect
.x
= HEADER_OFFSET_X
;
2398 rect
.y
= GetLineY(line
);
2399 rect
.width
= GetColumnWidth(0);
2400 rect
.height
= GetLineHeight();
2405 wxRect
wxListMainWindow::GetLineIconRect(size_t line
) const
2407 if ( !InReportView() )
2408 return GetLine(line
)->m_gi
->m_rectIcon
;
2410 wxListLineData
*ld
= GetLine(line
);
2411 wxASSERT_MSG( ld
->HasImage(), _T("should have an image") );
2414 rect
.x
= HEADER_OFFSET_X
;
2415 rect
.y
= GetLineY(line
);
2416 GetImageSize(ld
->GetImage(), rect
.width
, rect
.height
);
2421 wxRect
wxListMainWindow::GetLineHighlightRect(size_t line
) const
2423 return InReportView() ? GetLineRect(line
)
2424 : GetLine(line
)->m_gi
->m_rectHighlight
;
2427 long wxListMainWindow::HitTestLine(size_t line
, int x
, int y
) const
2429 wxASSERT_MSG( line
< GetItemCount(), _T("invalid line in HitTestLine") );
2431 wxListLineData
*ld
= GetLine(line
);
2433 if ( ld
->HasImage() && GetLineIconRect(line
).Inside(x
, y
) )
2434 return wxLIST_HITTEST_ONITEMICON
;
2436 if ( ld
->HasText() )
2438 wxRect rect
= InReportView() ? GetLineRect(line
)
2439 : GetLineLabelRect(line
);
2441 if ( rect
.Inside(x
, y
) )
2442 return wxLIST_HITTEST_ONITEMLABEL
;
2448 // ----------------------------------------------------------------------------
2449 // highlight (selection) handling
2450 // ----------------------------------------------------------------------------
2452 bool wxListMainWindow::IsHighlighted(size_t line
) const
2456 return m_selStore
.IsSelected(line
);
2460 wxListLineData
*ld
= GetLine(line
);
2461 wxCHECK_MSG( ld
, FALSE
, _T("invalid index in IsHighlighted") );
2463 return ld
->IsHighlighted();
2467 void wxListMainWindow::HighlightLines( size_t lineFrom
,
2473 wxArrayInt linesChanged
;
2474 if ( !m_selStore
.SelectRange(lineFrom
, lineTo
, highlight
,
2477 // meny items changed state, refresh everything
2478 RefreshLines(lineFrom
, lineTo
);
2480 else // only a few items changed state, refresh only them
2482 size_t count
= linesChanged
.GetCount();
2483 for ( size_t n
= 0; n
< count
; n
++ )
2485 RefreshLine(linesChanged
[n
]);
2489 else // iterate over all items in non report view
2491 for ( size_t line
= lineFrom
; line
<= lineTo
; line
++ )
2493 if ( HighlightLine(line
, highlight
) )
2501 bool wxListMainWindow::HighlightLine( size_t line
, bool highlight
)
2507 changed
= m_selStore
.SelectItem(line
, highlight
);
2511 wxListLineData
*ld
= GetLine(line
);
2512 wxCHECK_MSG( ld
, FALSE
, _T("invalid index in HighlightLine") );
2514 changed
= ld
->Highlight(highlight
);
2519 SendNotify( line
, highlight
? wxEVT_COMMAND_LIST_ITEM_SELECTED
2520 : wxEVT_COMMAND_LIST_ITEM_DESELECTED
);
2526 void wxListMainWindow::RefreshLine( size_t line
)
2528 if ( HasFlag(wxLC_REPORT
) )
2530 size_t visibleFrom
, visibleTo
;
2531 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2533 if ( line
< visibleFrom
|| line
> visibleTo
)
2537 wxRect rect
= GetLineRect(line
);
2539 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2540 RefreshRect( rect
);
2543 void wxListMainWindow::RefreshLines( size_t lineFrom
, size_t lineTo
)
2545 // we suppose that they are ordered by caller
2546 wxASSERT_MSG( lineFrom
<= lineTo
, _T("indices in disorder") );
2548 wxASSERT_MSG( lineTo
< GetItemCount(), _T("invalid line range") );
2550 if ( HasFlag(wxLC_REPORT
) )
2552 size_t visibleFrom
, visibleTo
;
2553 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2555 if ( lineFrom
< visibleFrom
)
2556 lineFrom
= visibleFrom
;
2557 if ( lineTo
> visibleTo
)
2562 rect
.y
= GetLineY(lineFrom
);
2563 rect
.width
= GetClientSize().x
;
2564 rect
.height
= GetLineY(lineTo
) - rect
.y
+ GetLineHeight();
2566 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2567 RefreshRect( rect
);
2571 // TODO: this should be optimized...
2572 for ( size_t line
= lineFrom
; line
<= lineTo
; line
++ )
2579 void wxListMainWindow::RefreshAfter( size_t lineFrom
)
2581 if ( HasFlag(wxLC_REPORT
) )
2584 GetVisibleLinesRange(&visibleFrom
, NULL
);
2586 if ( lineFrom
< visibleFrom
)
2587 lineFrom
= visibleFrom
;
2591 rect
.y
= GetLineY(lineFrom
);
2593 wxSize size
= GetClientSize();
2594 rect
.width
= size
.x
;
2595 // refresh till the bottom of the window
2596 rect
.height
= size
.y
- rect
.y
;
2598 CalcScrolledPosition( rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
2599 RefreshRect( rect
);
2603 // TODO: how to do it more efficiently?
2608 void wxListMainWindow::RefreshSelected()
2614 if ( InReportView() )
2616 GetVisibleLinesRange(&from
, &to
);
2621 to
= GetItemCount() - 1;
2624 // VZ: this code would work fine if wxGTK wxWindow::Refresh() were
2625 // reasonable, i.e. if it only generated one expose event for
2626 // several calls to it - as it is, each Refresh() results in a
2627 // repaint which provokes flicker too horrible to be seen
2629 // when/if wxGTK is fixed, this code should be restored as normally it
2630 // should generate _less_ flicker than the version below
2632 if ( HasCurrent() && m_current
>= from
&& m_current
<= to
)
2634 RefreshLine(m_current
);
2637 for ( size_t line
= from
; line
<= to
; line
++ )
2639 // NB: the test works as expected even if m_current == -1
2640 if ( line
!= m_current
&& IsHighlighted(line
) )
2646 size_t selMin
= (size_t)-1,
2649 for ( size_t line
= from
; line
<= to
; line
++ )
2651 if ( IsHighlighted(line
) )
2653 if ( line
< selMin
)
2655 if ( line
> selMax
)
2660 if ( selMin
!= (size_t)-1 )
2662 RefreshLines(selMin
, selMax
);
2664 #endif // !__WXGTK__/__WXGTK__
2667 void wxListMainWindow::OnPaint( wxPaintEvent
&WXUNUSED(event
) )
2669 // Note: a wxPaintDC must be constructed even if no drawing is
2670 // done (a Windows requirement).
2671 wxPaintDC
dc( this );
2675 // empty control. nothing to draw
2681 // delay the repainting until we calculate all the items positions
2688 CalcScrolledPosition( 0, 0, &dev_x
, &dev_y
);
2692 dc
.SetFont( GetFont() );
2694 if ( HasFlag(wxLC_REPORT
) )
2696 int lineHeight
= GetLineHeight();
2698 size_t visibleFrom
, visibleTo
;
2699 GetVisibleLinesRange(&visibleFrom
, &visibleTo
);
2702 wxCoord xOrig
, yOrig
;
2703 CalcUnscrolledPosition(0, 0, &xOrig
, &yOrig
);
2705 // tell the caller cache to cache the data
2708 wxListEvent
evCache(wxEVT_COMMAND_LIST_CACHE_HINT
,
2709 GetParent()->GetId());
2710 evCache
.SetEventObject( GetParent() );
2711 evCache
.m_oldItemIndex
= visibleFrom
;
2712 evCache
.m_itemIndex
= visibleTo
;
2713 GetParent()->GetEventHandler()->ProcessEvent( evCache
);
2716 for ( size_t line
= visibleFrom
; line
<= visibleTo
; line
++ )
2718 rectLine
= GetLineRect(line
);
2720 if ( !IsExposed(rectLine
.x
- xOrig
, rectLine
.y
- yOrig
,
2721 rectLine
.width
, rectLine
.height
) )
2723 // don't redraw unaffected lines to avoid flicker
2727 GetLine(line
)->DrawInReportMode( &dc
,
2729 GetLineHighlightRect(line
),
2730 IsHighlighted(line
) );
2733 if ( HasFlag(wxLC_HRULES
) )
2735 wxPen
pen(GetRuleColour(), 1, wxSOLID
);
2736 wxSize clientSize
= GetClientSize();
2738 for ( size_t i
= visibleFrom
; i
<= visibleTo
; i
++ )
2741 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
2742 dc
.DrawLine(0 - dev_x
, i
*lineHeight
,
2743 clientSize
.x
- dev_x
, i
*lineHeight
);
2746 // Draw last horizontal rule
2747 if ( visibleTo
> visibleFrom
)
2750 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
2751 dc
.DrawLine(0 - dev_x
, m_lineTo
*lineHeight
,
2752 clientSize
.x
- dev_x
, m_lineTo
*lineHeight
);
2756 // Draw vertical rules if required
2757 if ( HasFlag(wxLC_VRULES
) && !IsEmpty() )
2759 wxPen
pen(GetRuleColour(), 1, wxSOLID
);
2762 wxRect firstItemRect
;
2763 wxRect lastItemRect
;
2764 GetItemRect(0, firstItemRect
);
2765 GetItemRect(GetItemCount() - 1, lastItemRect
);
2766 int x
= firstItemRect
.GetX();
2768 dc
.SetBrush(* wxTRANSPARENT_BRUSH
);
2769 for (col
= 0; col
< GetColumnCount(); col
++)
2771 int colWidth
= GetColumnWidth(col
);
2773 dc
.DrawLine(x
- dev_x
, firstItemRect
.GetY() - 1 - dev_y
,
2774 x
- dev_x
, lastItemRect
.GetBottom() + 1 - dev_y
);
2780 size_t count
= GetItemCount();
2781 for ( size_t i
= 0; i
< count
; i
++ )
2783 GetLine(i
)->Draw( &dc
);
2789 // don't draw rect outline under Max if we already have the background
2790 // color but under other platforms only draw it if we do: it is a bit
2791 // silly to draw "focus rect" if we don't have focus!
2796 #endif // __WXMAC__/!__WXMAC__
2798 dc
.SetPen( *wxBLACK_PEN
);
2799 dc
.SetBrush( *wxTRANSPARENT_BRUSH
);
2800 dc
.DrawRectangle( GetLineHighlightRect(m_current
) );
2807 void wxListMainWindow::HighlightAll( bool on
)
2809 if ( IsSingleSel() )
2811 wxASSERT_MSG( !on
, _T("can't do this in a single sel control") );
2813 // we just have one item to turn off
2814 if ( HasCurrent() && IsHighlighted(m_current
) )
2816 HighlightLine(m_current
, FALSE
);
2817 RefreshLine(m_current
);
2822 HighlightLines(0, GetItemCount() - 1, on
);
2826 void wxListMainWindow::SendNotify( size_t line
,
2827 wxEventType command
,
2830 wxListEvent
le( command
, GetParent()->GetId() );
2831 le
.SetEventObject( GetParent() );
2832 le
.m_itemIndex
= line
;
2834 // set only for events which have position
2835 if ( point
!= wxDefaultPosition
)
2836 le
.m_pointDrag
= point
;
2838 // don't try to get the line info for virtual list controls: the main
2839 // program has it anyhow and if we did it would result in accessing all
2840 // the lines, even those which are not visible now and this is precisely
2841 // what we're trying to avoid
2842 if ( !IsVirtual() && (command
!= wxEVT_COMMAND_LIST_DELETE_ITEM
) )
2844 GetLine(line
)->GetItem( 0, le
.m_item
);
2846 //else: there may be no more such item
2848 GetParent()->GetEventHandler()->ProcessEvent( le
);
2851 void wxListMainWindow::OnFocusLine( size_t WXUNUSED(line
) )
2853 // SendNotify( line, wxEVT_COMMAND_LIST_ITEM_FOCUSSED );
2856 void wxListMainWindow::OnUnfocusLine( size_t WXUNUSED(line
) )
2858 // SendNotify( line, wxEVT_COMMAND_LIST_ITEM_UNFOCUSSED );
2861 void wxListMainWindow::EditLabel( long item
)
2863 wxCHECK_RET( (item
>= 0) && ((size_t)item
< GetItemCount()),
2864 wxT("wrong index in wxListCtrl::EditLabel()") );
2866 m_currentEdit
= (size_t)item
;
2868 wxListEvent
le( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT
, GetParent()->GetId() );
2869 le
.SetEventObject( GetParent() );
2870 le
.m_itemIndex
= item
;
2871 wxListLineData
*data
= GetLine(m_currentEdit
);
2872 wxCHECK_RET( data
, _T("invalid index in EditLabel()") );
2873 data
->GetItem( 0, le
.m_item
);
2874 GetParent()->GetEventHandler()->ProcessEvent( le
);
2876 if (!le
.IsAllowed())
2879 // We have to call this here because the label in question might just have
2880 // been added and no screen update taken place.
2884 wxClientDC
dc(this);
2887 wxString s
= data
->GetText(0);
2888 wxRect rectLabel
= GetLineLabelRect(m_currentEdit
);
2890 rectLabel
.x
= dc
.LogicalToDeviceX( rectLabel
.x
);
2891 rectLabel
.y
= dc
.LogicalToDeviceY( rectLabel
.y
);
2893 wxListTextCtrl
*text
= new wxListTextCtrl
2900 wxPoint(rectLabel
.x
-4,rectLabel
.y
-4),
2901 wxSize(rectLabel
.width
+11,rectLabel
.height
+8)
2906 void wxListMainWindow::OnRenameTimer()
2908 wxCHECK_RET( HasCurrent(), wxT("unexpected rename timer") );
2910 EditLabel( m_current
);
2913 void wxListMainWindow::OnRenameAccept()
2915 wxListEvent
le( wxEVT_COMMAND_LIST_END_LABEL_EDIT
, GetParent()->GetId() );
2916 le
.SetEventObject( GetParent() );
2917 le
.m_itemIndex
= m_currentEdit
;
2919 wxListLineData
*data
= GetLine(m_currentEdit
);
2920 wxCHECK_RET( data
, _T("invalid index in OnRenameAccept()") );
2922 data
->GetItem( 0, le
.m_item
);
2923 le
.m_item
.m_text
= m_renameRes
;
2924 GetParent()->GetEventHandler()->ProcessEvent( le
);
2926 if (!le
.IsAllowed()) return;
2929 info
.m_mask
= wxLIST_MASK_TEXT
;
2930 info
.m_itemId
= le
.m_itemIndex
;
2931 info
.m_text
= m_renameRes
;
2932 info
.SetTextColour(le
.m_item
.GetTextColour());
2936 void wxListMainWindow::OnMouse( wxMouseEvent
&event
)
2938 event
.SetEventObject( GetParent() );
2939 if ( GetParent()->GetEventHandler()->ProcessEvent( event
) )
2942 if ( !HasCurrent() || IsEmpty() )
2948 if ( !(event
.Dragging() || event
.ButtonDown() || event
.LeftUp() ||
2949 event
.ButtonDClick()) )
2952 int x
= event
.GetX();
2953 int y
= event
.GetY();
2954 CalcUnscrolledPosition( x
, y
, &x
, &y
);
2956 // where did we hit it (if we did)?
2959 size_t count
= GetItemCount(),
2962 if ( HasFlag(wxLC_REPORT
) )
2964 current
= y
/ GetLineHeight();
2965 if ( current
< count
)
2966 hitResult
= HitTestLine(current
, x
, y
);
2970 // TODO: optimize it too! this is less simple than for report view but
2971 // enumerating all items is still not a way to do it!!
2972 for ( current
= 0; current
< count
; current
++ )
2974 hitResult
= HitTestLine(current
, x
, y
);
2980 if (event
.Dragging())
2982 if (m_dragCount
== 0)
2984 // we have to report the raw, physical coords as we want to be
2985 // able to call HitTest(event.m_pointDrag) from the user code to
2986 // get the item being dragged
2987 m_dragStart
= event
.GetPosition();
2992 if (m_dragCount
!= 3)
2995 int command
= event
.RightIsDown() ? wxEVT_COMMAND_LIST_BEGIN_RDRAG
2996 : wxEVT_COMMAND_LIST_BEGIN_DRAG
;
2998 wxListEvent
le( command
, GetParent()->GetId() );
2999 le
.SetEventObject( GetParent() );
3000 le
.m_pointDrag
= m_dragStart
;
3001 GetParent()->GetEventHandler()->ProcessEvent( le
);
3012 // outside of any item
3016 bool forceClick
= FALSE
;
3017 if (event
.ButtonDClick())
3019 m_renameTimer
->Stop();
3020 m_lastOnSame
= FALSE
;
3022 if ( current
== m_lineBeforeLastClicked
)
3024 SendNotify( current
, wxEVT_COMMAND_LIST_ITEM_ACTIVATED
);
3030 // the first click was on another item, so don't interpret this as
3031 // a double click, but as a simple click instead
3036 if (event
.LeftUp() && m_lastOnSame
)
3038 if ((current
== m_current
) &&
3039 (hitResult
== wxLIST_HITTEST_ONITEMLABEL
) &&
3040 HasFlag(wxLC_EDIT_LABELS
) )
3042 m_renameTimer
->Start( 100, TRUE
);
3044 m_lastOnSame
= FALSE
;
3046 else if (event
.RightDown())
3048 SendNotify( current
, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK
,
3049 event
.GetPosition() );
3051 else if (event
.MiddleDown())
3053 SendNotify( current
, wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK
);
3055 else if ( event
.LeftDown() || forceClick
)
3057 m_lineBeforeLastClicked
= m_lineLastClicked
;
3058 m_lineLastClicked
= current
;
3060 size_t oldCurrent
= m_current
;
3062 if ( IsSingleSel() || !(event
.ControlDown() || event
.ShiftDown()) )
3064 HighlightAll( FALSE
);
3065 m_current
= current
;
3067 ReverseHighlight(m_current
);
3069 else // multi sel & either ctrl or shift is down
3071 if (event
.ControlDown())
3073 m_current
= current
;
3075 ReverseHighlight(m_current
);
3077 else if (event
.ShiftDown())
3079 m_current
= current
;
3081 size_t lineFrom
= oldCurrent
,
3084 if ( lineTo
< lineFrom
)
3087 lineFrom
= m_current
;
3090 HighlightLines(lineFrom
, lineTo
);
3092 else // !ctrl, !shift
3094 // test in the enclosing if should make it impossible
3095 wxFAIL_MSG( _T("how did we get here?") );
3099 if (m_current
!= oldCurrent
)
3101 RefreshLine( oldCurrent
);
3102 OnUnfocusLine( oldCurrent
);
3103 OnFocusLine( m_current
);
3106 // forceClick is only set if the previous click was on another item
3107 m_lastOnSame
= !forceClick
&& (m_current
== oldCurrent
);
3111 void wxListMainWindow::MoveToItem(size_t item
)
3113 if ( item
== (size_t)-1 )
3116 wxRect rect
= GetLineRect(item
);
3118 int client_w
, client_h
;
3119 GetClientSize( &client_w
, &client_h
);
3121 int view_x
= m_xScroll
*GetScrollPos( wxHORIZONTAL
);
3122 int view_y
= m_yScroll
*GetScrollPos( wxVERTICAL
);
3124 if ( HasFlag(wxLC_REPORT
) )
3126 // the next we need the range of lines shown it might be different, so
3128 ResetVisibleLinesRange();
3130 if (rect
.y
< view_y
)
3131 Scroll( -1, rect
.y
/m_yScroll
);
3132 if (rect
.y
+rect
.height
+5 > view_y
+client_h
)
3133 Scroll( -1, (rect
.y
+rect
.height
-client_h
+SCROLL_UNIT_Y
)/m_yScroll
);
3137 if (rect
.x
-view_x
< 5)
3138 Scroll( (rect
.x
-5)/m_xScroll
, -1 );
3139 if (rect
.x
+rect
.width
-5 > view_x
+client_w
)
3140 Scroll( (rect
.x
+rect
.width
-client_w
+SCROLL_UNIT_X
)/m_xScroll
, -1 );
3144 // ----------------------------------------------------------------------------
3145 // keyboard handling
3146 // ----------------------------------------------------------------------------
3148 void wxListMainWindow::OnArrowChar(size_t newCurrent
, const wxKeyEvent
& event
)
3150 wxCHECK_RET( newCurrent
< (size_t)GetItemCount(),
3151 _T("invalid item index in OnArrowChar()") );
3153 size_t oldCurrent
= m_current
;
3155 // in single selection we just ignore Shift as we can't select several
3157 if ( event
.ShiftDown() && !IsSingleSel() )
3159 m_current
= newCurrent
;
3161 // select all the items between the old and the new one
3162 if ( oldCurrent
> newCurrent
)
3164 newCurrent
= oldCurrent
;
3165 oldCurrent
= m_current
;
3168 HighlightLines(oldCurrent
, newCurrent
);
3172 // all previously selected items are unselected unless ctrl is held
3173 if ( !event
.ControlDown() )
3174 HighlightAll(FALSE
);
3176 m_current
= newCurrent
;
3178 HighlightLine( oldCurrent
, FALSE
);
3179 RefreshLine( oldCurrent
);
3181 if ( !event
.ControlDown() )
3183 HighlightLine( m_current
, TRUE
);
3187 OnUnfocusLine( oldCurrent
);
3188 OnFocusLine( m_current
);
3189 RefreshLine( m_current
);
3194 void wxListMainWindow::OnKeyDown( wxKeyEvent
&event
)
3196 wxWindow
*parent
= GetParent();
3198 /* we propagate the key event up */
3199 wxKeyEvent
ke( wxEVT_KEY_DOWN
);
3200 ke
.m_shiftDown
= event
.m_shiftDown
;
3201 ke
.m_controlDown
= event
.m_controlDown
;
3202 ke
.m_altDown
= event
.m_altDown
;
3203 ke
.m_metaDown
= event
.m_metaDown
;
3204 ke
.m_keyCode
= event
.m_keyCode
;
3207 ke
.SetEventObject( parent
);
3208 if (parent
->GetEventHandler()->ProcessEvent( ke
)) return;
3213 void wxListMainWindow::OnChar( wxKeyEvent
&event
)
3215 wxWindow
*parent
= GetParent();
3217 /* we send a list_key event up */
3220 wxListEvent
le( wxEVT_COMMAND_LIST_KEY_DOWN
, GetParent()->GetId() );
3221 le
.m_itemIndex
= m_current
;
3222 GetLine(m_current
)->GetItem( 0, le
.m_item
);
3223 le
.m_code
= (int)event
.KeyCode();
3224 le
.SetEventObject( parent
);
3225 parent
->GetEventHandler()->ProcessEvent( le
);
3228 /* we propagate the char event up */
3229 wxKeyEvent
ke( wxEVT_CHAR
);
3230 ke
.m_shiftDown
= event
.m_shiftDown
;
3231 ke
.m_controlDown
= event
.m_controlDown
;
3232 ke
.m_altDown
= event
.m_altDown
;
3233 ke
.m_metaDown
= event
.m_metaDown
;
3234 ke
.m_keyCode
= event
.m_keyCode
;
3237 ke
.SetEventObject( parent
);
3238 if (parent
->GetEventHandler()->ProcessEvent( ke
)) return;
3240 if (event
.KeyCode() == WXK_TAB
)
3242 wxNavigationKeyEvent nevent
;
3243 nevent
.SetWindowChange( event
.ControlDown() );
3244 nevent
.SetDirection( !event
.ShiftDown() );
3245 nevent
.SetEventObject( GetParent()->GetParent() );
3246 nevent
.SetCurrentFocus( m_parent
);
3247 if (GetParent()->GetParent()->GetEventHandler()->ProcessEvent( nevent
)) return;
3250 /* no item -> nothing to do */
3257 switch (event
.KeyCode())
3260 if ( m_current
> 0 )
3261 OnArrowChar( m_current
- 1, event
);
3265 if ( m_current
< (size_t)GetItemCount() - 1 )
3266 OnArrowChar( m_current
+ 1, event
);
3271 OnArrowChar( GetItemCount() - 1, event
);
3276 OnArrowChar( 0, event
);
3282 if ( HasFlag(wxLC_REPORT
) )
3284 steps
= m_linesPerPage
- 1;
3288 steps
= m_current
% m_linesPerPage
;
3291 int index
= m_current
- steps
;
3295 OnArrowChar( index
, event
);
3302 if ( HasFlag(wxLC_REPORT
) )
3304 steps
= m_linesPerPage
- 1;
3308 steps
= m_linesPerPage
- (m_current
% m_linesPerPage
) - 1;
3311 size_t index
= m_current
+ steps
;
3312 size_t count
= GetItemCount();
3313 if ( index
>= count
)
3316 OnArrowChar( index
, event
);
3321 if ( !HasFlag(wxLC_REPORT
) )
3323 int index
= m_current
- m_linesPerPage
;
3327 OnArrowChar( index
, event
);
3332 if ( !HasFlag(wxLC_REPORT
) )
3334 size_t index
= m_current
+ m_linesPerPage
;
3336 size_t count
= GetItemCount();
3337 if ( index
>= count
)
3340 OnArrowChar( index
, event
);
3345 if ( IsSingleSel() )
3347 wxListEvent
le( wxEVT_COMMAND_LIST_ITEM_ACTIVATED
,
3348 GetParent()->GetId() );
3349 le
.SetEventObject( GetParent() );
3350 le
.m_itemIndex
= m_current
;
3351 GetLine(m_current
)->GetItem( 0, le
.m_item
);
3352 GetParent()->GetEventHandler()->ProcessEvent( le
);
3354 if ( IsHighlighted(m_current
) )
3356 // don't unselect the item in single selection mode
3359 //else: select it in ReverseHighlight() below if unselected
3362 ReverseHighlight(m_current
);
3368 wxListEvent
le( wxEVT_COMMAND_LIST_ITEM_ACTIVATED
,
3369 GetParent()->GetId() );
3370 le
.SetEventObject( GetParent() );
3371 le
.m_itemIndex
= m_current
;
3372 GetLine(m_current
)->GetItem( 0, le
.m_item
);
3373 GetParent()->GetEventHandler()->ProcessEvent( le
);
3382 // ----------------------------------------------------------------------------
3384 // ----------------------------------------------------------------------------
3387 extern wxWindow
*g_focusWindow
;
3390 void wxListMainWindow::OnSetFocus( wxFocusEvent
&WXUNUSED(event
) )
3392 // wxGTK sends us EVT_SET_FOCUS events even if we had never got
3393 // EVT_KILL_FOCUS before which means that we finish by redrawing the items
3394 // which are already drawn correctly resulting in horrible flicker - avoid
3407 g_focusWindow
= GetParent();
3410 wxFocusEvent
event( wxEVT_SET_FOCUS
, GetParent()->GetId() );
3411 event
.SetEventObject( GetParent() );
3412 GetParent()->GetEventHandler()->ProcessEvent( event
);
3415 void wxListMainWindow::OnKillFocus( wxFocusEvent
&WXUNUSED(event
) )
3422 void wxListMainWindow::DrawImage( int index
, wxDC
*dc
, int x
, int y
)
3424 if ( HasFlag(wxLC_ICON
) && (m_normal_image_list
))
3426 m_normal_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3428 else if ( HasFlag(wxLC_SMALL_ICON
) && (m_small_image_list
))
3430 m_small_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3432 else if ( HasFlag(wxLC_LIST
) && (m_small_image_list
))
3434 m_small_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3436 else if ( HasFlag(wxLC_REPORT
) && (m_small_image_list
))
3438 m_small_image_list
->Draw( index
, *dc
, x
, y
, wxIMAGELIST_DRAW_TRANSPARENT
);
3442 void wxListMainWindow::GetImageSize( int index
, int &width
, int &height
) const
3444 if ( HasFlag(wxLC_ICON
) && m_normal_image_list
)
3446 m_normal_image_list
->GetSize( index
, width
, height
);
3448 else if ( HasFlag(wxLC_SMALL_ICON
) && m_small_image_list
)
3450 m_small_image_list
->GetSize( index
, width
, height
);
3452 else if ( HasFlag(wxLC_LIST
) && m_small_image_list
)
3454 m_small_image_list
->GetSize( index
, width
, height
);
3456 else if ( HasFlag(wxLC_REPORT
) && m_small_image_list
)
3458 m_small_image_list
->GetSize( index
, width
, height
);
3467 int wxListMainWindow::GetTextLength( const wxString
&s
) const
3469 wxClientDC
dc( wxConstCast(this, wxListMainWindow
) );
3470 dc
.SetFont( GetFont() );
3473 dc
.GetTextExtent( s
, &lw
, NULL
);
3475 return lw
+ AUTOSIZE_COL_MARGIN
;
3478 void wxListMainWindow::SetImageList( wxImageList
*imageList
, int which
)
3482 // calc the spacing from the icon size
3485 if ((imageList
) && (imageList
->GetImageCount()) )
3487 imageList
->GetSize(0, width
, height
);
3490 if (which
== wxIMAGE_LIST_NORMAL
)
3492 m_normal_image_list
= imageList
;
3493 m_normal_spacing
= width
+ 8;
3496 if (which
== wxIMAGE_LIST_SMALL
)
3498 m_small_image_list
= imageList
;
3499 m_small_spacing
= width
+ 14;
3503 void wxListMainWindow::SetItemSpacing( int spacing
, bool isSmall
)
3508 m_small_spacing
= spacing
;
3512 m_normal_spacing
= spacing
;
3516 int wxListMainWindow::GetItemSpacing( bool isSmall
)
3518 return isSmall
? m_small_spacing
: m_normal_spacing
;
3521 // ----------------------------------------------------------------------------
3523 // ----------------------------------------------------------------------------
3525 void wxListMainWindow::SetColumn( int col
, wxListItem
&item
)
3527 wxListHeaderDataList::Node
*node
= m_columns
.Item( col
);
3529 wxCHECK_RET( node
, _T("invalid column index in SetColumn") );
3531 if ( item
.m_width
== wxLIST_AUTOSIZE_USEHEADER
)
3532 item
.m_width
= GetTextLength( item
.m_text
);
3534 wxListHeaderData
*column
= node
->GetData();
3535 column
->SetItem( item
);
3537 wxListHeaderWindow
*headerWin
= GetListCtrl()->m_headerWin
;
3539 headerWin
->m_dirty
= TRUE
;
3543 // invalidate it as it has to be recalculated
3547 void wxListMainWindow::SetColumnWidth( int col
, int width
)
3549 wxCHECK_RET( col
>= 0 && col
< GetColumnCount(),
3550 _T("invalid column index") );
3552 wxCHECK_RET( HasFlag(wxLC_REPORT
),
3553 _T("SetColumnWidth() can only be called in report mode.") );
3556 wxListHeaderWindow
*headerWin
= GetListCtrl()->m_headerWin
;
3558 headerWin
->m_dirty
= TRUE
;
3560 wxListHeaderDataList::Node
*node
= m_columns
.Item( col
);
3561 wxCHECK_RET( node
, _T("no column?") );
3563 wxListHeaderData
*column
= node
->GetData();
3565 size_t count
= GetItemCount();
3567 if (width
== wxLIST_AUTOSIZE_USEHEADER
)
3569 width
= GetTextLength(column
->GetText());
3571 else if ( width
== wxLIST_AUTOSIZE
)
3575 // TODO: determine the max width somehow...
3576 width
= WIDTH_COL_DEFAULT
;
3580 wxClientDC
dc(this);
3581 dc
.SetFont( GetFont() );
3583 int max
= AUTOSIZE_COL_MARGIN
;
3585 for ( size_t i
= 0; i
< count
; i
++ )
3587 wxListLineData
*line
= GetLine(i
);
3588 wxListItemDataList::Node
*n
= line
->m_items
.Item( col
);
3590 wxCHECK_RET( n
, _T("no subitem?") );
3592 wxListItemData
*item
= n
->GetData();
3595 if (item
->HasImage())
3598 GetImageSize( item
->GetImage(), ix
, iy
);
3602 if (item
->HasText())
3605 dc
.GetTextExtent( item
->GetText(), &w
, NULL
);
3613 width
= max
+ AUTOSIZE_COL_MARGIN
;
3617 column
->SetWidth( width
);
3619 // invalidate it as it has to be recalculated
3623 int wxListMainWindow::GetHeaderWidth() const
3625 if ( !m_headerWidth
)
3627 wxListMainWindow
*self
= wxConstCast(this, wxListMainWindow
);
3629 size_t count
= GetColumnCount();
3630 for ( size_t col
= 0; col
< count
; col
++ )
3632 self
->m_headerWidth
+= GetColumnWidth(col
);
3636 return m_headerWidth
;
3639 void wxListMainWindow::GetColumn( int col
, wxListItem
&item
) const
3641 wxListHeaderDataList::Node
*node
= m_columns
.Item( col
);
3642 wxCHECK_RET( node
, _T("invalid column index in GetColumn") );
3644 wxListHeaderData
*column
= node
->GetData();
3645 column
->GetItem( item
);
3648 int wxListMainWindow::GetColumnWidth( int col
) const
3650 wxListHeaderDataList::Node
*node
= m_columns
.Item( col
);
3651 wxCHECK_MSG( node
, 0, _T("invalid column index") );
3653 wxListHeaderData
*column
= node
->GetData();
3654 return column
->GetWidth();
3657 // ----------------------------------------------------------------------------
3659 // ----------------------------------------------------------------------------
3661 void wxListMainWindow::SetItem( wxListItem
&item
)
3663 long id
= item
.m_itemId
;
3664 wxCHECK_RET( id
>= 0 && (size_t)id
< GetItemCount(),
3665 _T("invalid item index in SetItem") );
3669 wxListLineData
*line
= GetLine((size_t)id
);
3670 line
->SetItem( item
.m_col
, item
);
3673 if ( InReportView() )
3675 // just refresh the line to show the new value of the text/image
3676 RefreshLine((size_t)id
);
3680 // refresh everything (resulting in horrible flicker - FIXME!)
3685 void wxListMainWindow::SetItemState( long litem
, long state
, long stateMask
)
3687 wxCHECK_RET( litem
>= 0 && (size_t)litem
< GetItemCount(),
3688 _T("invalid list ctrl item index in SetItem") );
3690 size_t oldCurrent
= m_current
;
3691 size_t item
= (size_t)litem
; // safe because of the check above
3693 // do we need to change the focus?
3694 if ( stateMask
& wxLIST_STATE_FOCUSED
)
3696 if ( state
& wxLIST_STATE_FOCUSED
)
3698 // don't do anything if this item is already focused
3699 if ( item
!= m_current
)
3701 OnUnfocusLine( m_current
);
3703 OnFocusLine( m_current
);
3705 if ( oldCurrent
!= (size_t)-1 )
3707 if ( IsSingleSel() )
3709 HighlightLine(oldCurrent
, FALSE
);
3712 RefreshLine(oldCurrent
);
3715 RefreshLine( m_current
);
3720 // don't do anything if this item is not focused
3721 if ( item
== m_current
)
3723 OnUnfocusLine( m_current
);
3724 m_current
= (size_t)-1;
3726 RefreshLine( oldCurrent
);
3731 // do we need to change the selection state?
3732 if ( stateMask
& wxLIST_STATE_SELECTED
)
3734 bool on
= (state
& wxLIST_STATE_SELECTED
) != 0;
3736 if ( IsSingleSel() )
3740 // selecting the item also makes it the focused one in the
3742 if ( m_current
!= item
)
3744 OnUnfocusLine( m_current
);
3746 OnFocusLine( m_current
);
3748 if ( oldCurrent
!= (size_t)-1 )
3750 HighlightLine( oldCurrent
, FALSE
);
3751 RefreshLine( oldCurrent
);
3757 // only the current item may be selected anyhow
3758 if ( item
!= m_current
)
3763 if ( HighlightLine(item
, on
) )
3770 int wxListMainWindow::GetItemState( long item
, long stateMask
)
3772 wxCHECK_MSG( item
>= 0 && (size_t)item
< GetItemCount(), 0,
3773 _T("invalid list ctrl item index in GetItemState()") );
3775 int ret
= wxLIST_STATE_DONTCARE
;
3777 if ( stateMask
& wxLIST_STATE_FOCUSED
)
3779 if ( (size_t)item
== m_current
)
3780 ret
|= wxLIST_STATE_FOCUSED
;
3783 if ( stateMask
& wxLIST_STATE_SELECTED
)
3785 if ( IsHighlighted(item
) )
3786 ret
|= wxLIST_STATE_SELECTED
;
3792 void wxListMainWindow::GetItem( wxListItem
&item
)
3794 wxCHECK_RET( item
.m_itemId
>= 0 && (size_t)item
.m_itemId
< GetItemCount(),
3795 _T("invalid item index in GetItem") );
3797 wxListLineData
*line
= GetLine((size_t)item
.m_itemId
);
3798 line
->GetItem( item
.m_col
, item
);
3801 // ----------------------------------------------------------------------------
3803 // ----------------------------------------------------------------------------
3805 size_t wxListMainWindow::GetItemCount() const
3807 return IsVirtual() ? m_countVirt
: m_lines
.GetCount();
3810 void wxListMainWindow::SetItemCount(long count
)
3812 m_selStore
.SetItemCount(count
);
3813 m_countVirt
= count
;
3815 ResetVisibleLinesRange();
3817 // scrollbars must be reset
3821 int wxListMainWindow::GetSelectedItemCount()
3823 // deal with the quick case first
3824 if ( IsSingleSel() )
3826 return HasCurrent() ? IsHighlighted(m_current
) : FALSE
;
3829 // virtual controls remmebers all its selections itself
3831 return m_selStore
.GetSelectedCount();
3833 // TODO: we probably should maintain the number of items selected even for
3834 // non virtual controls as enumerating all lines is really slow...
3835 size_t countSel
= 0;
3836 size_t count
= GetItemCount();
3837 for ( size_t line
= 0; line
< count
; line
++ )
3839 if ( GetLine(line
)->IsHighlighted() )
3846 // ----------------------------------------------------------------------------
3847 // item position/size
3848 // ----------------------------------------------------------------------------
3850 void wxListMainWindow::GetItemRect( long index
, wxRect
&rect
)
3852 wxCHECK_RET( index
>= 0 && (size_t)index
< GetItemCount(),
3853 _T("invalid index in GetItemRect") );
3855 rect
= GetLineRect((size_t)index
);
3857 CalcScrolledPosition(rect
.x
, rect
.y
, &rect
.x
, &rect
.y
);
3860 bool wxListMainWindow::GetItemPosition(long item
, wxPoint
& pos
)
3863 GetItemRect(item
, rect
);
3871 // ----------------------------------------------------------------------------
3872 // geometry calculation
3873 // ----------------------------------------------------------------------------
3875 void wxListMainWindow::RecalculatePositions(bool noRefresh
)
3877 wxClientDC
dc( this );
3878 dc
.SetFont( GetFont() );
3881 if ( HasFlag(wxLC_ICON
) )
3882 iconSpacing
= m_normal_spacing
;
3883 else if ( HasFlag(wxLC_SMALL_ICON
) )
3884 iconSpacing
= m_small_spacing
;
3890 GetClientSize( &clientWidth
, &clientHeight
);
3892 if ( HasFlag(wxLC_REPORT
) )
3894 // all lines have the same height
3895 int lineHeight
= GetLineHeight();
3897 // scroll one line per step
3898 m_yScroll
= lineHeight
;
3900 size_t lineCount
= GetItemCount();
3901 int entireHeight
= lineCount
*lineHeight
+ LINE_SPACING
;
3903 m_linesPerPage
= clientHeight
/ lineHeight
;
3905 ResetVisibleLinesRange();
3907 SetScrollbars( m_xScroll
, m_yScroll
,
3908 (GetHeaderWidth() + m_xScroll
- 1)/m_xScroll
,
3909 (entireHeight
+ m_yScroll
- 1)/m_yScroll
,
3910 GetScrollPos(wxHORIZONTAL
),
3911 GetScrollPos(wxVERTICAL
),
3916 // at first we try without any scrollbar. if the items don't
3917 // fit into the window, we recalculate after subtracting an
3918 // approximated 15 pt for the horizontal scrollbar
3920 clientHeight
-= 4; // sunken frame
3922 int entireWidth
= 0;
3924 for (int tries
= 0; tries
< 2; tries
++)
3931 int currentlyVisibleLines
= 0;
3933 size_t count
= GetItemCount();
3934 for (size_t i
= 0; i
< count
; i
++)
3936 currentlyVisibleLines
++;
3937 wxListLineData
*line
= GetLine(i
);
3938 line
->CalculateSize( &dc
, iconSpacing
);
3939 line
->SetPosition( x
, y
, clientWidth
, iconSpacing
);
3941 wxSize sizeLine
= GetLineSize(i
);
3943 if ( maxWidth
< sizeLine
.x
)
3944 maxWidth
= sizeLine
.x
;
3947 if (currentlyVisibleLines
> m_linesPerPage
)
3948 m_linesPerPage
= currentlyVisibleLines
;
3950 // assume that the size of the next one is the same... (FIXME)
3951 if ( y
+ sizeLine
.y
- 6 >= clientHeight
)
3953 currentlyVisibleLines
= 0;
3956 entireWidth
+= maxWidth
+6;
3959 if ( i
== count
- 1 )
3960 entireWidth
+= maxWidth
;
3961 if ((tries
== 0) && (entireWidth
> clientWidth
))
3963 clientHeight
-= 15; // scrollbar height
3965 currentlyVisibleLines
= 0;
3968 if ( i
== count
- 1 )
3969 tries
= 1; // everything fits, no second try required
3973 int scroll_pos
= GetScrollPos( wxHORIZONTAL
);
3974 SetScrollbars( m_xScroll
, m_yScroll
, (entireWidth
+SCROLL_UNIT_X
) / m_xScroll
, 0, scroll_pos
, 0, TRUE
);
3979 // FIXME: why should we call it from here?
3986 void wxListMainWindow::RefreshAll()
3991 wxListHeaderWindow
*headerWin
= GetListCtrl()->m_headerWin
;
3992 if ( headerWin
&& headerWin
->m_dirty
)
3994 headerWin
->m_dirty
= FALSE
;
3995 headerWin
->Refresh();
3999 void wxListMainWindow::UpdateCurrent()
4001 if ( !HasCurrent() && !IsEmpty() )
4006 if ( m_current
!= (size_t)-1 )
4008 OnFocusLine( m_current
);
4012 long wxListMainWindow::GetNextItem( long item
,
4013 int WXUNUSED(geometry
),
4017 max
= GetItemCount();
4018 wxCHECK_MSG( (ret
== -1) || (ret
< max
), -1,
4019 _T("invalid listctrl index in GetNextItem()") );
4021 // notice that we start with the next item (or the first one if item == -1)
4022 // and this is intentional to allow writing a simple loop to iterate over
4023 // all selected items
4027 // this is not an error because the index was ok initially, just no
4038 size_t count
= GetItemCount();
4039 for ( size_t line
= (size_t)ret
; line
< count
; line
++ )
4041 if ( (state
& wxLIST_STATE_FOCUSED
) && (line
== m_current
) )
4044 if ( (state
& wxLIST_STATE_SELECTED
) && IsHighlighted(line
) )
4051 // ----------------------------------------------------------------------------
4053 // ----------------------------------------------------------------------------
4055 void wxListMainWindow::DeleteItem( long lindex
)
4057 size_t count
= GetItemCount();
4059 wxCHECK_RET( (lindex
>= 0) && ((size_t)lindex
< count
),
4060 _T("invalid item index in DeleteItem") );
4062 size_t index
= (size_t)lindex
;
4064 // we don't need to adjust the index for the previous items
4065 if ( HasCurrent() && m_current
>= index
)
4067 // if the current item is being deleted, we want the next one to
4068 // become selected - unless there is no next one - so don't adjust
4069 // m_current in this case
4070 if ( m_current
!= index
|| m_current
== count
- 1 )
4076 if ( InReportView() )
4078 ResetVisibleLinesRange();
4085 m_selStore
.OnItemDelete(index
);
4089 m_lines
.RemoveAt( index
);
4092 // we need to refresh the (vert) scrollbar as the number of items changed
4095 SendNotify( index
, wxEVT_COMMAND_LIST_DELETE_ITEM
);
4097 RefreshAfter(index
);
4100 void wxListMainWindow::DeleteColumn( int col
)
4102 wxListHeaderDataList::Node
*node
= m_columns
.Item( col
);
4104 wxCHECK_RET( node
, wxT("invalid column index in DeleteColumn()") );
4107 m_columns
.DeleteNode( node
);
4110 void wxListMainWindow::DoDeleteAllItems()
4114 // nothing to do - in particular, don't send the event
4120 // to make the deletion of all items faster, we don't send the
4121 // notifications for each item deletion in this case but only one event
4122 // for all of them: this is compatible with wxMSW and documented in
4123 // DeleteAllItems() description
4125 wxListEvent
event( wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS
, GetParent()->GetId() );
4126 event
.SetEventObject( GetParent() );
4127 GetParent()->GetEventHandler()->ProcessEvent( event
);
4136 if ( InReportView() )
4138 ResetVisibleLinesRange();
4144 void wxListMainWindow::DeleteAllItems()
4148 RecalculatePositions();
4151 void wxListMainWindow::DeleteEverything()
4158 // ----------------------------------------------------------------------------
4159 // scanning for an item
4160 // ----------------------------------------------------------------------------
4162 void wxListMainWindow::EnsureVisible( long index
)
4164 wxCHECK_RET( index
>= 0 && (size_t)index
< GetItemCount(),
4165 _T("invalid index in EnsureVisible") );
4167 // We have to call this here because the label in question might just have
4168 // been added and its position is not known yet
4171 RecalculatePositions(TRUE
/* no refresh */);
4174 MoveToItem((size_t)index
);
4177 long wxListMainWindow::FindItem(long start
, const wxString
& str
, bool WXUNUSED(partial
) )
4184 size_t count
= GetItemCount();
4185 for ( size_t i
= (size_t)pos
; i
< count
; i
++ )
4187 wxListLineData
*line
= GetLine(i
);
4188 if ( line
->GetText(0) == tmp
)
4195 long wxListMainWindow::FindItem(long start
, long data
)
4201 size_t count
= GetItemCount();
4202 for (size_t i
= (size_t)pos
; i
< count
; i
++)
4204 wxListLineData
*line
= GetLine(i
);
4206 line
->GetItem( 0, item
);
4207 if (item
.m_data
== data
)
4214 long wxListMainWindow::HitTest( int x
, int y
, int &flags
)
4216 CalcUnscrolledPosition( x
, y
, &x
, &y
);
4218 size_t count
= GetItemCount();
4220 if ( HasFlag(wxLC_REPORT
) )
4222 size_t current
= y
/ GetLineHeight();
4223 if ( current
< count
)
4225 flags
= HitTestLine(current
, x
, y
);
4232 // TODO: optimize it too! this is less simple than for report view but
4233 // enumerating all items is still not a way to do it!!
4234 for ( size_t current
= 0; current
< count
; current
++ )
4236 flags
= HitTestLine(current
, x
, y
);
4245 // ----------------------------------------------------------------------------
4247 // ----------------------------------------------------------------------------
4249 void wxListMainWindow::InsertItem( wxListItem
&item
)
4251 wxASSERT_MSG( !IsVirtual(), _T("can't be used with virtual control") );
4253 size_t count
= GetItemCount();
4254 wxCHECK_RET( item
.m_itemId
>= 0 && (size_t)item
.m_itemId
<= count
,
4255 _T("invalid item index") );
4257 size_t id
= item
.m_itemId
;
4262 if ( HasFlag(wxLC_REPORT
) )
4264 else if ( HasFlag(wxLC_LIST
) )
4266 else if ( HasFlag(wxLC_ICON
) )
4268 else if ( HasFlag(wxLC_SMALL_ICON
) )
4269 mode
= wxLC_ICON
; // no typo
4272 wxFAIL_MSG( _T("unknown mode") );
4275 wxListLineData
*line
= new wxListLineData(this);
4277 line
->SetItem( 0, item
);
4279 m_lines
.Insert( line
, id
);
4282 RefreshLines(id
, GetItemCount() - 1);
4285 void wxListMainWindow::InsertColumn( long col
, wxListItem
&item
)
4288 if ( HasFlag(wxLC_REPORT
) )
4290 if (item
.m_width
== wxLIST_AUTOSIZE_USEHEADER
)
4291 item
.m_width
= GetTextLength( item
.m_text
);
4292 wxListHeaderData
*column
= new wxListHeaderData( item
);
4293 if ((col
>= 0) && (col
< (int)m_columns
.GetCount()))
4295 wxListHeaderDataList::Node
*node
= m_columns
.Item( col
);
4296 m_columns
.Insert( node
, column
);
4300 m_columns
.Append( column
);
4305 // ----------------------------------------------------------------------------
4307 // ----------------------------------------------------------------------------
4309 wxListCtrlCompare list_ctrl_compare_func_2
;
4310 long list_ctrl_compare_data
;
4312 int LINKAGEMODE
list_ctrl_compare_func_1( wxListLineData
**arg1
, wxListLineData
**arg2
)
4314 wxListLineData
*line1
= *arg1
;
4315 wxListLineData
*line2
= *arg2
;
4317 line1
->GetItem( 0, item
);
4318 long data1
= item
.m_data
;
4319 line2
->GetItem( 0, item
);
4320 long data2
= item
.m_data
;
4321 return list_ctrl_compare_func_2( data1
, data2
, list_ctrl_compare_data
);
4324 void wxListMainWindow::SortItems( wxListCtrlCompare fn
, long data
)
4326 list_ctrl_compare_func_2
= fn
;
4327 list_ctrl_compare_data
= data
;
4328 m_lines
.Sort( list_ctrl_compare_func_1
);
4332 // ----------------------------------------------------------------------------
4334 // ----------------------------------------------------------------------------
4336 void wxListMainWindow::OnScroll(wxScrollWinEvent
& event
)
4338 // update our idea of which lines are shown when we redraw the window the
4340 ResetVisibleLinesRange();
4343 #if defined(__WXGTK__) && !defined(__WXUNIVERSAL__)
4344 wxScrolledWindow::OnScroll(event
);
4346 HandleOnScroll( event
);
4349 if ( event
.GetOrientation() == wxHORIZONTAL
&& HasHeader() )
4351 wxListCtrl
* lc
= GetListCtrl();
4352 wxCHECK_RET( lc
, _T("no listctrl window?") );
4354 lc
->m_headerWin
->Refresh() ;
4356 lc
->m_headerWin
->MacUpdateImmediately() ;
4361 int wxListMainWindow::GetCountPerPage() const
4363 if ( !m_linesPerPage
)
4365 wxConstCast(this, wxListMainWindow
)->
4366 m_linesPerPage
= GetClientSize().y
/ GetLineHeight();
4369 return m_linesPerPage
;
4372 void wxListMainWindow::GetVisibleLinesRange(size_t *from
, size_t *to
)
4374 wxASSERT_MSG( HasFlag(wxLC_REPORT
), _T("this is for report mode only") );
4376 if ( m_lineFrom
== (size_t)-1 )
4378 size_t count
= GetItemCount();
4381 m_lineFrom
= GetScrollPos(wxVERTICAL
);
4383 // this may happen if SetScrollbars() hadn't been called yet
4384 if ( m_lineFrom
>= count
)
4385 m_lineFrom
= count
- 1;
4387 // we redraw one extra line but this is needed to make the redrawing
4388 // logic work when there is a fractional number of lines on screen
4389 m_lineTo
= m_lineFrom
+ m_linesPerPage
;
4390 if ( m_lineTo
>= count
)
4391 m_lineTo
= count
- 1;
4393 else // empty control
4396 m_lineTo
= (size_t)-1;
4400 wxASSERT_MSG( IsEmpty() ||
4401 (m_lineFrom
<= m_lineTo
&& m_lineTo
< GetItemCount()),
4402 _T("GetVisibleLinesRange() returns incorrect result") );
4410 // -------------------------------------------------------------------------------------
4412 // -------------------------------------------------------------------------------------
4414 IMPLEMENT_DYNAMIC_CLASS(wxListItem
, wxObject
)
4416 wxListItem::wxListItem()
4423 void wxListItem::Clear()
4432 m_format
= wxLIST_FORMAT_CENTRE
;
4439 void wxListItem::ClearAttributes()
4448 // -------------------------------------------------------------------------------------
4450 // -------------------------------------------------------------------------------------
4452 IMPLEMENT_DYNAMIC_CLASS(wxListEvent
, wxNotifyEvent
)
4454 wxListEvent::wxListEvent( wxEventType commandType
, int id
)
4455 : wxNotifyEvent( commandType
, id
)
4461 m_cancelled
= FALSE
;
4466 void wxListEvent::CopyObject(wxObject
& object_dest
) const
4468 wxListEvent
*obj
= (wxListEvent
*)&object_dest
;
4470 wxNotifyEvent::CopyObject(object_dest
);
4472 obj
->m_code
= m_code
;
4473 obj
->m_itemIndex
= m_itemIndex
;
4474 obj
->m_oldItemIndex
= m_oldItemIndex
;
4476 obj
->m_cancelled
= m_cancelled
;
4477 obj
->m_pointDrag
= m_pointDrag
;
4478 obj
->m_item
.m_mask
= m_item
.m_mask
;
4479 obj
->m_item
.m_itemId
= m_item
.m_itemId
;
4480 obj
->m_item
.m_col
= m_item
.m_col
;
4481 obj
->m_item
.m_state
= m_item
.m_state
;
4482 obj
->m_item
.m_stateMask
= m_item
.m_stateMask
;
4483 obj
->m_item
.m_text
= m_item
.m_text
;
4484 obj
->m_item
.m_image
= m_item
.m_image
;
4485 obj
->m_item
.m_data
= m_item
.m_data
;
4486 obj
->m_item
.m_format
= m_item
.m_format
;
4487 obj
->m_item
.m_width
= m_item
.m_width
;
4489 if ( m_item
.HasAttributes() )
4491 obj
->m_item
.SetTextColour(m_item
.GetTextColour());
4495 // -------------------------------------------------------------------------------------
4497 // -------------------------------------------------------------------------------------
4499 IMPLEMENT_DYNAMIC_CLASS(wxListCtrl
, wxControl
)
4500 IMPLEMENT_DYNAMIC_CLASS(wxListView
, wxListCtrl
)
4502 BEGIN_EVENT_TABLE(wxListCtrl
,wxControl
)
4503 EVT_SIZE(wxListCtrl::OnSize
)
4504 EVT_IDLE(wxListCtrl::OnIdle
)
4507 wxListCtrl::wxListCtrl()
4509 m_imageListNormal
= (wxImageList
*) NULL
;
4510 m_imageListSmall
= (wxImageList
*) NULL
;
4511 m_imageListState
= (wxImageList
*) NULL
;
4513 m_ownsImageListNormal
=
4514 m_ownsImageListSmall
=
4515 m_ownsImageListState
= FALSE
;
4517 m_mainWin
= (wxListMainWindow
*) NULL
;
4518 m_headerWin
= (wxListHeaderWindow
*) NULL
;
4521 wxListCtrl::~wxListCtrl()
4524 m_mainWin
->ResetCurrent();
4526 if (m_ownsImageListNormal
)
4527 delete m_imageListNormal
;
4528 if (m_ownsImageListSmall
)
4529 delete m_imageListSmall
;
4530 if (m_ownsImageListState
)
4531 delete m_imageListState
;
4534 void wxListCtrl::CreateHeaderWindow()
4536 m_headerWin
= new wxListHeaderWindow
4538 this, -1, m_mainWin
,
4540 wxSize(GetClientSize().x
, HEADER_HEIGHT
),
4545 bool wxListCtrl::Create(wxWindow
*parent
,
4550 const wxValidator
&validator
,
4551 const wxString
&name
)
4555 m_imageListState
= (wxImageList
*) NULL
;
4556 m_ownsImageListNormal
=
4557 m_ownsImageListSmall
=
4558 m_ownsImageListState
= FALSE
;
4560 m_mainWin
= (wxListMainWindow
*) NULL
;
4561 m_headerWin
= (wxListHeaderWindow
*) NULL
;
4563 if ( !(style
& wxLC_MASK_TYPE
) )
4565 style
= style
| wxLC_LIST
;
4568 if ( !wxControl::Create( parent
, id
, pos
, size
, style
, validator
, name
) )
4571 // don't create the inner window with the border
4572 style
&= ~wxSUNKEN_BORDER
;
4574 m_mainWin
= new wxListMainWindow( this, -1, wxPoint(0,0), size
, style
);
4576 if ( HasFlag(wxLC_REPORT
) )
4578 CreateHeaderWindow();
4580 if ( HasFlag(wxLC_NO_HEADER
) )
4582 // VZ: why do we create it at all then?
4583 m_headerWin
->Show( FALSE
);
4590 void wxListCtrl::SetSingleStyle( long style
, bool add
)
4592 wxASSERT_MSG( !(style
& wxLC_VIRTUAL
),
4593 _T("wxLC_VIRTUAL can't be [un]set") );
4595 long flag
= GetWindowStyle();
4599 if (style
& wxLC_MASK_TYPE
)
4600 flag
&= ~(wxLC_MASK_TYPE
| wxLC_VIRTUAL
);
4601 if (style
& wxLC_MASK_ALIGN
)
4602 flag
&= ~wxLC_MASK_ALIGN
;
4603 if (style
& wxLC_MASK_SORT
)
4604 flag
&= ~wxLC_MASK_SORT
;
4616 SetWindowStyleFlag( flag
);
4619 void wxListCtrl::SetWindowStyleFlag( long flag
)
4623 m_mainWin
->DeleteEverything();
4625 // has the header visibility changed?
4626 bool hasHeader
= HasFlag(wxLC_REPORT
) && !HasFlag(wxLC_NO_HEADER
),
4627 willHaveHeader
= (flag
& wxLC_REPORT
) && !(flag
& wxLC_NO_HEADER
);
4629 if ( hasHeader
!= willHaveHeader
)
4636 // don't delete, just hide, as we can reuse it later
4637 m_headerWin
->Show(FALSE
);
4639 //else: nothing to do
4641 else // must show header
4645 CreateHeaderWindow();
4647 else // already have it, just show
4649 m_headerWin
->Show( TRUE
);
4653 ResizeReportView(willHaveHeader
);
4657 wxWindow::SetWindowStyleFlag( flag
);
4660 bool wxListCtrl::GetColumn(int col
, wxListItem
&item
) const
4662 m_mainWin
->GetColumn( col
, item
);
4666 bool wxListCtrl::SetColumn( int col
, wxListItem
& item
)
4668 m_mainWin
->SetColumn( col
, item
);
4672 int wxListCtrl::GetColumnWidth( int col
) const
4674 return m_mainWin
->GetColumnWidth( col
);
4677 bool wxListCtrl::SetColumnWidth( int col
, int width
)
4679 m_mainWin
->SetColumnWidth( col
, width
);
4683 int wxListCtrl::GetCountPerPage() const
4685 return m_mainWin
->GetCountPerPage(); // different from Windows ?
4688 bool wxListCtrl::GetItem( wxListItem
&info
) const
4690 m_mainWin
->GetItem( info
);
4694 bool wxListCtrl::SetItem( wxListItem
&info
)
4696 m_mainWin
->SetItem( info
);
4700 long wxListCtrl::SetItem( long index
, int col
, const wxString
& label
, int imageId
)
4703 info
.m_text
= label
;
4704 info
.m_mask
= wxLIST_MASK_TEXT
;
4705 info
.m_itemId
= index
;
4709 info
.m_image
= imageId
;
4710 info
.m_mask
|= wxLIST_MASK_IMAGE
;
4712 m_mainWin
->SetItem(info
);
4716 int wxListCtrl::GetItemState( long item
, long stateMask
) const
4718 return m_mainWin
->GetItemState( item
, stateMask
);
4721 bool wxListCtrl::SetItemState( long item
, long state
, long stateMask
)
4723 m_mainWin
->SetItemState( item
, state
, stateMask
);
4727 bool wxListCtrl::SetItemImage( long item
, int image
, int WXUNUSED(selImage
) )
4730 info
.m_image
= image
;
4731 info
.m_mask
= wxLIST_MASK_IMAGE
;
4732 info
.m_itemId
= item
;
4733 m_mainWin
->SetItem( info
);
4737 wxString
wxListCtrl::GetItemText( long item
) const
4740 info
.m_itemId
= item
;
4741 m_mainWin
->GetItem( info
);
4745 void wxListCtrl::SetItemText( long item
, const wxString
&str
)
4748 info
.m_mask
= wxLIST_MASK_TEXT
;
4749 info
.m_itemId
= item
;
4751 m_mainWin
->SetItem( info
);
4754 long wxListCtrl::GetItemData( long item
) const
4757 info
.m_itemId
= item
;
4758 m_mainWin
->GetItem( info
);
4762 bool wxListCtrl::SetItemData( long item
, long data
)
4765 info
.m_mask
= wxLIST_MASK_DATA
;
4766 info
.m_itemId
= item
;
4768 m_mainWin
->SetItem( info
);
4772 bool wxListCtrl::GetItemRect( long item
, wxRect
&rect
, int WXUNUSED(code
) ) const
4774 m_mainWin
->GetItemRect( item
, rect
);
4778 bool wxListCtrl::GetItemPosition( long item
, wxPoint
& pos
) const
4780 m_mainWin
->GetItemPosition( item
, pos
);
4784 bool wxListCtrl::SetItemPosition( long WXUNUSED(item
), const wxPoint
& WXUNUSED(pos
) )
4789 int wxListCtrl::GetItemCount() const
4791 return m_mainWin
->GetItemCount();
4794 int wxListCtrl::GetColumnCount() const
4796 return m_mainWin
->GetColumnCount();
4799 void wxListCtrl::SetItemSpacing( int spacing
, bool isSmall
)
4801 m_mainWin
->SetItemSpacing( spacing
, isSmall
);
4804 int wxListCtrl::GetItemSpacing( bool isSmall
) const
4806 return m_mainWin
->GetItemSpacing( isSmall
);
4809 int wxListCtrl::GetSelectedItemCount() const
4811 return m_mainWin
->GetSelectedItemCount();
4814 wxColour
wxListCtrl::GetTextColour() const
4816 return GetForegroundColour();
4819 void wxListCtrl::SetTextColour(const wxColour
& col
)
4821 SetForegroundColour(col
);
4824 long wxListCtrl::GetTopItem() const
4829 long wxListCtrl::GetNextItem( long item
, int geom
, int state
) const
4831 return m_mainWin
->GetNextItem( item
, geom
, state
);
4834 wxImageList
*wxListCtrl::GetImageList(int which
) const
4836 if (which
== wxIMAGE_LIST_NORMAL
)
4838 return m_imageListNormal
;
4840 else if (which
== wxIMAGE_LIST_SMALL
)
4842 return m_imageListSmall
;
4844 else if (which
== wxIMAGE_LIST_STATE
)
4846 return m_imageListState
;
4848 return (wxImageList
*) NULL
;
4851 void wxListCtrl::SetImageList( wxImageList
*imageList
, int which
)
4853 if ( which
== wxIMAGE_LIST_NORMAL
)
4855 if (m_ownsImageListNormal
) delete m_imageListNormal
;
4856 m_imageListNormal
= imageList
;
4857 m_ownsImageListNormal
= FALSE
;
4859 else if ( which
== wxIMAGE_LIST_SMALL
)
4861 if (m_ownsImageListSmall
) delete m_imageListSmall
;
4862 m_imageListSmall
= imageList
;
4863 m_ownsImageListSmall
= FALSE
;
4865 else if ( which
== wxIMAGE_LIST_STATE
)
4867 if (m_ownsImageListState
) delete m_imageListState
;
4868 m_imageListState
= imageList
;
4869 m_ownsImageListState
= FALSE
;
4872 m_mainWin
->SetImageList( imageList
, which
);
4875 void wxListCtrl::AssignImageList(wxImageList
*imageList
, int which
)
4877 SetImageList(imageList
, which
);
4878 if ( which
== wxIMAGE_LIST_NORMAL
)
4879 m_ownsImageListNormal
= TRUE
;
4880 else if ( which
== wxIMAGE_LIST_SMALL
)
4881 m_ownsImageListSmall
= TRUE
;
4882 else if ( which
== wxIMAGE_LIST_STATE
)
4883 m_ownsImageListState
= TRUE
;
4886 bool wxListCtrl::Arrange( int WXUNUSED(flag
) )
4891 bool wxListCtrl::DeleteItem( long item
)
4893 m_mainWin
->DeleteItem( item
);
4897 bool wxListCtrl::DeleteAllItems()
4899 m_mainWin
->DeleteAllItems();
4903 bool wxListCtrl::DeleteAllColumns()
4905 size_t count
= m_mainWin
->m_columns
.GetCount();
4906 for ( size_t n
= 0; n
< count
; n
++ )
4912 void wxListCtrl::ClearAll()
4914 m_mainWin
->DeleteEverything();
4917 bool wxListCtrl::DeleteColumn( int col
)
4919 m_mainWin
->DeleteColumn( col
);
4923 void wxListCtrl::Edit( long item
)
4925 m_mainWin
->EditLabel( item
);
4928 bool wxListCtrl::EnsureVisible( long item
)
4930 m_mainWin
->EnsureVisible( item
);
4934 long wxListCtrl::FindItem( long start
, const wxString
& str
, bool partial
)
4936 return m_mainWin
->FindItem( start
, str
, partial
);
4939 long wxListCtrl::FindItem( long start
, long data
)
4941 return m_mainWin
->FindItem( start
, data
);
4944 long wxListCtrl::FindItem( long WXUNUSED(start
), const wxPoint
& WXUNUSED(pt
),
4945 int WXUNUSED(direction
))
4950 long wxListCtrl::HitTest( const wxPoint
&point
, int &flags
)
4952 return m_mainWin
->HitTest( (int)point
.x
, (int)point
.y
, flags
);
4955 long wxListCtrl::InsertItem( wxListItem
& info
)
4957 m_mainWin
->InsertItem( info
);
4958 return info
.m_itemId
;
4961 long wxListCtrl::InsertItem( long index
, const wxString
&label
)
4964 info
.m_text
= label
;
4965 info
.m_mask
= wxLIST_MASK_TEXT
;
4966 info
.m_itemId
= index
;
4967 return InsertItem( info
);
4970 long wxListCtrl::InsertItem( long index
, int imageIndex
)
4973 info
.m_mask
= wxLIST_MASK_IMAGE
;
4974 info
.m_image
= imageIndex
;
4975 info
.m_itemId
= index
;
4976 return InsertItem( info
);
4979 long wxListCtrl::InsertItem( long index
, const wxString
&label
, int imageIndex
)
4982 info
.m_text
= label
;
4983 info
.m_image
= imageIndex
;
4984 info
.m_mask
= wxLIST_MASK_TEXT
| wxLIST_MASK_IMAGE
;
4985 info
.m_itemId
= index
;
4986 return InsertItem( info
);
4989 long wxListCtrl::InsertColumn( long col
, wxListItem
&item
)
4991 wxASSERT( m_headerWin
);
4992 m_mainWin
->InsertColumn( col
, item
);
4993 m_headerWin
->Refresh();
4998 long wxListCtrl::InsertColumn( long col
, const wxString
&heading
,
4999 int format
, int width
)
5002 item
.m_mask
= wxLIST_MASK_TEXT
| wxLIST_MASK_FORMAT
;
5003 item
.m_text
= heading
;
5006 item
.m_mask
|= wxLIST_MASK_WIDTH
;
5007 item
.m_width
= width
;
5009 item
.m_format
= format
;
5011 return InsertColumn( col
, item
);
5014 bool wxListCtrl::ScrollList( int WXUNUSED(dx
), int WXUNUSED(dy
) )
5020 // fn is a function which takes 3 long arguments: item1, item2, data.
5021 // item1 is the long data associated with a first item (NOT the index).
5022 // item2 is the long data associated with a second item (NOT the index).
5023 // data is the same value as passed to SortItems.
5024 // The return value is a negative number if the first item should precede the second
5025 // item, a positive number of the second item should precede the first,
5026 // or zero if the two items are equivalent.
5027 // data is arbitrary data to be passed to the sort function.
5029 bool wxListCtrl::SortItems( wxListCtrlCompare fn
, long data
)
5031 m_mainWin
->SortItems( fn
, data
);
5035 // ----------------------------------------------------------------------------
5037 // ----------------------------------------------------------------------------
5039 void wxListCtrl::OnSize(wxSizeEvent
& event
)
5044 ResizeReportView(m_mainWin
->HasHeader());
5046 m_mainWin
->RecalculatePositions();
5049 void wxListCtrl::ResizeReportView(bool showHeader
)
5052 GetClientSize( &cw
, &ch
);
5056 m_headerWin
->SetSize( 0, 0, cw
, HEADER_HEIGHT
);
5057 m_mainWin
->SetSize( 0, HEADER_HEIGHT
+ 1, cw
, ch
- HEADER_HEIGHT
- 1 );
5059 else // no header window
5061 m_mainWin
->SetSize( 0, 0, cw
, ch
);
5065 void wxListCtrl::OnIdle( wxIdleEvent
& event
)
5069 // do it only if needed
5070 if ( !m_mainWin
->m_dirty
)
5073 m_mainWin
->RecalculatePositions();
5076 // ----------------------------------------------------------------------------
5078 // ----------------------------------------------------------------------------
5080 bool wxListCtrl::SetBackgroundColour( const wxColour
&colour
)
5084 m_mainWin
->SetBackgroundColour( colour
);
5085 m_mainWin
->m_dirty
= TRUE
;
5091 bool wxListCtrl::SetForegroundColour( const wxColour
&colour
)
5093 if ( !wxWindow::SetForegroundColour( colour
) )
5098 m_mainWin
->SetForegroundColour( colour
);
5099 m_mainWin
->m_dirty
= TRUE
;
5104 m_headerWin
->SetForegroundColour( colour
);
5110 bool wxListCtrl::SetFont( const wxFont
&font
)
5112 if ( !wxWindow::SetFont( font
) )
5117 m_mainWin
->SetFont( font
);
5118 m_mainWin
->m_dirty
= TRUE
;
5123 m_headerWin
->SetFont( font
);
5129 // ----------------------------------------------------------------------------
5130 // methods forwarded to m_mainWin
5131 // ----------------------------------------------------------------------------
5133 #if wxUSE_DRAG_AND_DROP
5135 void wxListCtrl::SetDropTarget( wxDropTarget
*dropTarget
)
5137 m_mainWin
->SetDropTarget( dropTarget
);
5140 wxDropTarget
*wxListCtrl::GetDropTarget() const
5142 return m_mainWin
->GetDropTarget();
5145 #endif // wxUSE_DRAG_AND_DROP
5147 bool wxListCtrl::SetCursor( const wxCursor
&cursor
)
5149 return m_mainWin
? m_mainWin
->wxWindow::SetCursor(cursor
) : FALSE
;
5152 wxColour
wxListCtrl::GetBackgroundColour() const
5154 return m_mainWin
? m_mainWin
->GetBackgroundColour() : wxColour();
5157 wxColour
wxListCtrl::GetForegroundColour() const
5159 return m_mainWin
? m_mainWin
->GetForegroundColour() : wxColour();
5162 bool wxListCtrl::DoPopupMenu( wxMenu
*menu
, int x
, int y
)
5165 return m_mainWin
->PopupMenu( menu
, x
, y
);
5168 #endif // wxUSE_MENUS
5171 void wxListCtrl::SetFocus()
5173 /* The test in window.cpp fails as we are a composite
5174 window, so it checks against "this", but not m_mainWin. */
5175 if ( FindFocus() != this )
5176 m_mainWin
->SetFocus();
5179 // ----------------------------------------------------------------------------
5180 // virtual list control support
5181 // ----------------------------------------------------------------------------
5183 wxString
wxListCtrl::OnGetItemText(long item
, long col
) const
5185 // this is a pure virtual function, in fact - which is not really pure
5186 // because the controls which are not virtual don't need to implement it
5187 wxFAIL_MSG( _T("not supposed to be called") );
5189 return wxEmptyString
;
5192 int wxListCtrl::OnGetItemImage(long item
) const
5195 wxFAIL_MSG( _T("not supposed to be called") );
5200 wxListItemAttr
*wxListCtrl::OnGetItemAttr(long item
) const
5202 wxASSERT_MSG( item
>= 0 && item
< GetItemCount(),
5203 _T("invalid item index in OnGetItemAttr()") );
5205 // no attributes by default
5209 void wxListCtrl::SetItemCount(long count
)
5211 wxASSERT_MSG( IsVirtual(), _T("this is for virtual controls only") );
5213 m_mainWin
->SetItemCount(count
);
5216 void wxListCtrl::RefreshItem(long item
)
5218 m_mainWin
->RefreshLine(item
);
5221 void wxListCtrl::RefreshItems(long itemFrom
, long itemTo
)
5223 m_mainWin
->RefreshLines(itemFrom
, itemTo
);
5226 #endif // wxUSE_LISTCTRL