]> git.saurik.com Git - wxWidgets.git/blob - src/generic/listctrl.cpp
use generic dialogs under Palm (generic.diff part of patch 1894861)
[wxWidgets.git] / src / generic / listctrl.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/generic/listctrl.cpp
3 // Purpose: generic implementation of wxListCtrl
4 // Author: Robert Roebling
5 // Vadim Zeitlin (virtual list control support)
6 // Id: $Id$
7 // Copyright: (c) 1998 Robert Roebling
8 // Licence: wxWindows licence
9 /////////////////////////////////////////////////////////////////////////////
10
11 // TODO
12 //
13 // 1. we need to implement searching/sorting for virtual controls somehow
14 // 2. when changing selection the lines are refreshed twice
15
16
17 // For compilers that support precompilation, includes "wx.h".
18 #include "wx/wxprec.h"
19
20 #ifdef __BORLANDC__
21 #pragma hdrstop
22 #endif
23
24 #if wxUSE_LISTCTRL
25
26 #include "wx/listctrl.h"
27
28 #if (!defined(__WXMSW__) || defined(__WXUNIVERSAL__)) && !defined(__WXMAC__)
29 // if we have a native version, its implementation file does all this
30 IMPLEMENT_DYNAMIC_CLASS(wxListItem, wxObject)
31 IMPLEMENT_DYNAMIC_CLASS(wxListView, wxListCtrl)
32 IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxNotifyEvent)
33
34 IMPLEMENT_DYNAMIC_CLASS(wxListCtrl, wxGenericListCtrl)
35 #endif
36
37 #ifndef WX_PRECOMP
38 #include "wx/scrolwin.h"
39 #include "wx/timer.h"
40 #include "wx/settings.h"
41 #include "wx/dynarray.h"
42 #include "wx/dcclient.h"
43 #include "wx/dcscreen.h"
44 #include "wx/math.h"
45 #include "wx/settings.h"
46 #endif
47
48 #include "wx/imaglist.h"
49 #include "wx/selstore.h"
50 #include "wx/renderer.h"
51
52 #ifdef __WXMAC__
53 #include "wx/mac/private.h"
54 #endif
55
56
57 // NOTE: If using the wxListBox visual attributes works everywhere then this can
58 // be removed, as well as the #else case below.
59 #define _USE_VISATTR 0
60
61
62 // ----------------------------------------------------------------------------
63 // constants
64 // ----------------------------------------------------------------------------
65
66 // // the height of the header window (FIXME: should depend on its font!)
67 // static const int HEADER_HEIGHT = 23;
68
69 static const int SCROLL_UNIT_X = 15;
70
71 // the spacing between the lines (in report mode)
72 static const int LINE_SPACING = 0;
73
74 // extra margins around the text label
75 #ifdef __WXGTK__
76 static const int EXTRA_WIDTH = 6;
77 #else
78 static const int EXTRA_WIDTH = 4;
79 #endif
80 static const int EXTRA_HEIGHT = 4;
81
82 // margin between the window and the items
83 static const int EXTRA_BORDER_X = 2;
84 static const int EXTRA_BORDER_Y = 2;
85
86 // offset for the header window
87 static const int HEADER_OFFSET_X = 0;
88 static const int HEADER_OFFSET_Y = 0;
89
90 // margin between rows of icons in [small] icon view
91 static const int MARGIN_BETWEEN_ROWS = 6;
92
93 // when autosizing the columns, add some slack
94 static const int AUTOSIZE_COL_MARGIN = 10;
95
96 // default width for the header columns
97 static const int WIDTH_COL_DEFAULT = 80;
98
99 // the space between the image and the text in the report mode
100 static const int IMAGE_MARGIN_IN_REPORT_MODE = 5;
101
102 // the space between the image and the text in the report mode in header
103 static const int HEADER_IMAGE_MARGIN_IN_REPORT_MODE = 2;
104
105 // ============================================================================
106 // private classes
107 // ============================================================================
108
109 //-----------------------------------------------------------------------------
110 // wxColWidthInfo (internal)
111 //-----------------------------------------------------------------------------
112
113 struct wxColWidthInfo
114 {
115 int nMaxWidth;
116 bool bNeedsUpdate; // only set to true when an item whose
117 // width == nMaxWidth is removed
118
119 wxColWidthInfo(int w = 0, bool needsUpdate = false)
120 {
121 nMaxWidth = w;
122 bNeedsUpdate = needsUpdate;
123 }
124 };
125
126 WX_DEFINE_ARRAY_PTR(wxColWidthInfo *, ColWidthArray);
127
128 //-----------------------------------------------------------------------------
129 // wxListItemData (internal)
130 //-----------------------------------------------------------------------------
131
132 class wxListItemData
133 {
134 public:
135 wxListItemData(wxListMainWindow *owner);
136 ~wxListItemData();
137
138 void SetItem( const wxListItem &info );
139 void SetImage( int image ) { m_image = image; }
140 void SetData( wxUIntPtr data ) { m_data = data; }
141 void SetPosition( int x, int y );
142 void SetSize( int width, int height );
143
144 bool HasText() const { return !m_text.empty(); }
145 const wxString& GetText() const { return m_text; }
146 void SetText(const wxString& text) { m_text = text; }
147
148 // we can't use empty string for measuring the string width/height, so
149 // always return something
150 wxString GetTextForMeasuring() const
151 {
152 wxString s = GetText();
153 if ( s.empty() )
154 s = _T('H');
155
156 return s;
157 }
158
159 bool IsHit( int x, int y ) const;
160
161 int GetX() const;
162 int GetY() const;
163 int GetWidth() const;
164 int GetHeight() const;
165
166 int GetImage() const { return m_image; }
167 bool HasImage() const { return GetImage() != -1; }
168
169 void GetItem( wxListItem &info ) const;
170
171 void SetAttr(wxListItemAttr *attr) { m_attr = attr; }
172 wxListItemAttr *GetAttr() const { return m_attr; }
173
174 public:
175 // the item image or -1
176 int m_image;
177
178 // user data associated with the item
179 wxUIntPtr m_data;
180
181 // the item coordinates are not used in report mode; instead this pointer is
182 // NULL and the owner window is used to retrieve the item position and size
183 wxRect *m_rect;
184
185 // the list ctrl we are in
186 wxListMainWindow *m_owner;
187
188 // custom attributes or NULL
189 wxListItemAttr *m_attr;
190
191 protected:
192 // common part of all ctors
193 void Init();
194
195 wxString m_text;
196 };
197
198 //-----------------------------------------------------------------------------
199 // wxListHeaderData (internal)
200 //-----------------------------------------------------------------------------
201
202 class wxListHeaderData : public wxObject
203 {
204 public:
205 wxListHeaderData();
206 wxListHeaderData( const wxListItem &info );
207 void SetItem( const wxListItem &item );
208 void SetPosition( int x, int y );
209 void SetWidth( int w );
210 void SetState( int state );
211 void SetFormat( int format );
212 void SetHeight( int h );
213 bool HasImage() const;
214
215 bool HasText() const { return !m_text.empty(); }
216 const wxString& GetText() const { return m_text; }
217 void SetText(const wxString& text) { m_text = text; }
218
219 void GetItem( wxListItem &item );
220
221 bool IsHit( int x, int y ) const;
222 int GetImage() const;
223 int GetWidth() const;
224 int GetFormat() const;
225 int GetState() const;
226
227 protected:
228 long m_mask;
229 int m_image;
230 wxString m_text;
231 int m_format;
232 int m_width;
233 int m_xpos,
234 m_ypos;
235 int m_height;
236 int m_state;
237
238 private:
239 void Init();
240 };
241
242 //-----------------------------------------------------------------------------
243 // wxListLineData (internal)
244 //-----------------------------------------------------------------------------
245
246 WX_DECLARE_EXPORTED_LIST(wxListItemData, wxListItemDataList);
247 #include "wx/listimpl.cpp"
248 WX_DEFINE_LIST(wxListItemDataList)
249
250 class wxListLineData
251 {
252 public:
253 // the list of subitems: only may have more than one item in report mode
254 wxListItemDataList m_items;
255
256 // this is not used in report view
257 struct GeometryInfo
258 {
259 // total item rect
260 wxRect m_rectAll;
261
262 // label only
263 wxRect m_rectLabel;
264
265 // icon only
266 wxRect m_rectIcon;
267
268 // the part to be highlighted
269 wxRect m_rectHighlight;
270
271 // extend all our rects to be centered inside the one of given width
272 void ExtendWidth(wxCoord w)
273 {
274 wxASSERT_MSG( m_rectAll.width <= w,
275 _T("width can only be increased") );
276
277 m_rectAll.width = w;
278 m_rectLabel.x = m_rectAll.x + (w - m_rectLabel.width) / 2;
279 m_rectIcon.x = m_rectAll.x + (w - m_rectIcon.width) / 2;
280 m_rectHighlight.x = m_rectAll.x + (w - m_rectHighlight.width) / 2;
281 }
282 }
283 *m_gi;
284
285 // is this item selected? [NB: not used in virtual mode]
286 bool m_highlighted;
287
288 // back pointer to the list ctrl
289 wxListMainWindow *m_owner;
290
291 public:
292 wxListLineData(wxListMainWindow *owner);
293
294 ~wxListLineData()
295 {
296 WX_CLEAR_LIST(wxListItemDataList, m_items);
297 delete m_gi;
298 }
299
300 // are we in report mode?
301 inline bool InReportView() const;
302
303 // are we in virtual report mode?
304 inline bool IsVirtual() const;
305
306 // these 2 methods shouldn't be called for report view controls, in that
307 // case we determine our position/size ourselves
308
309 // calculate the size of the line
310 void CalculateSize( wxDC *dc, int spacing );
311
312 // remember the position this line appears at
313 void SetPosition( int x, int y, int spacing );
314
315 // wxListCtrl API
316
317 void SetImage( int image ) { SetImage(0, image); }
318 int GetImage() const { return GetImage(0); }
319 void SetImage( int index, int image );
320 int GetImage( int index ) const;
321
322 bool HasImage() const { return GetImage() != -1; }
323 bool HasText() const { return !GetText(0).empty(); }
324
325 void SetItem( int index, const wxListItem &info );
326 void GetItem( int index, wxListItem &info );
327
328 wxString GetText(int index) const;
329 void SetText( int index, const wxString& s );
330
331 wxListItemAttr *GetAttr() const;
332 void SetAttr(wxListItemAttr *attr);
333
334 // return true if the highlighting really changed
335 bool Highlight( bool on );
336
337 void ReverseHighlight();
338
339 bool IsHighlighted() const
340 {
341 wxASSERT_MSG( !IsVirtual(), _T("unexpected call to IsHighlighted") );
342
343 return m_highlighted;
344 }
345
346 // draw the line on the given DC in icon/list mode
347 void Draw( wxDC *dc );
348
349 // the same in report mode
350 void DrawInReportMode( wxDC *dc,
351 const wxRect& rect,
352 const wxRect& rectHL,
353 bool highlighted );
354
355 private:
356 // set the line to contain num items (only can be > 1 in report mode)
357 void InitItems( int num );
358
359 // get the mode (i.e. style) of the list control
360 inline int GetMode() const;
361
362 // prepare the DC for drawing with these item's attributes, return true if
363 // we need to draw the items background to highlight it, false otherwise
364 bool SetAttributes(wxDC *dc,
365 const wxListItemAttr *attr,
366 bool highlight);
367
368 // draw the text on the DC with the correct justification; also add an
369 // ellipsis if the text is too large to fit in the current width
370 void DrawTextFormatted(wxDC *dc,
371 const wxString &text,
372 int col,
373 int x,
374 int yMid, // this is middle, not top, of the text
375 int width);
376 };
377
378 WX_DECLARE_EXPORTED_OBJARRAY(wxListLineData, wxListLineDataArray);
379 #include "wx/arrimpl.cpp"
380 WX_DEFINE_OBJARRAY(wxListLineDataArray)
381
382 //-----------------------------------------------------------------------------
383 // wxListHeaderWindow (internal)
384 //-----------------------------------------------------------------------------
385
386 class wxListHeaderWindow : public wxWindow
387 {
388 protected:
389 wxListMainWindow *m_owner;
390 const wxCursor *m_currentCursor;
391 wxCursor *m_resizeCursor;
392 bool m_isDragging;
393
394 // column being resized or -1
395 int m_column;
396
397 // divider line position in logical (unscrolled) coords
398 int m_currentX;
399
400 // minimal position beyond which the divider line
401 // can't be dragged in logical coords
402 int m_minX;
403
404 public:
405 wxListHeaderWindow();
406
407 wxListHeaderWindow( wxWindow *win,
408 wxWindowID id,
409 wxListMainWindow *owner,
410 const wxPoint &pos = wxDefaultPosition,
411 const wxSize &size = wxDefaultSize,
412 long style = 0,
413 const wxString &name = wxT("wxlistctrlcolumntitles") );
414
415 virtual ~wxListHeaderWindow();
416
417 void DrawCurrent();
418 void AdjustDC( wxDC& dc );
419
420 void OnPaint( wxPaintEvent &event );
421 void OnMouse( wxMouseEvent &event );
422 void OnSetFocus( wxFocusEvent &event );
423
424 // needs refresh
425 bool m_dirty;
426
427 private:
428 // common part of all ctors
429 void Init();
430
431 // generate and process the list event of the given type, return true if
432 // it wasn't vetoed, i.e. if we should proceed
433 bool SendListEvent(wxEventType type, const wxPoint& pos);
434
435 DECLARE_DYNAMIC_CLASS(wxListHeaderWindow)
436 DECLARE_EVENT_TABLE()
437 };
438
439 //-----------------------------------------------------------------------------
440 // wxListRenameTimer (internal)
441 //-----------------------------------------------------------------------------
442
443 class wxListRenameTimer: public wxTimer
444 {
445 private:
446 wxListMainWindow *m_owner;
447
448 public:
449 wxListRenameTimer( wxListMainWindow *owner );
450 void Notify();
451 };
452
453 //-----------------------------------------------------------------------------
454 // wxListTextCtrlWrapper: wraps a wxTextCtrl to make it work for inline editing
455 //-----------------------------------------------------------------------------
456
457 class wxListTextCtrlWrapper : public wxEvtHandler
458 {
459 public:
460 // NB: text must be a valid object but not Create()d yet
461 wxListTextCtrlWrapper(wxListMainWindow *owner,
462 wxTextCtrl *text,
463 size_t itemEdit);
464
465 wxTextCtrl *GetText() const { return m_text; }
466
467 void EndEdit( bool discardChanges );
468
469 protected:
470 void OnChar( wxKeyEvent &event );
471 void OnKeyUp( wxKeyEvent &event );
472 void OnKillFocus( wxFocusEvent &event );
473
474 bool AcceptChanges();
475 void Finish( bool setfocus );
476
477 private:
478 wxListMainWindow *m_owner;
479 wxTextCtrl *m_text;
480 wxString m_startValue;
481 size_t m_itemEdited;
482 bool m_aboutToFinish;
483
484 DECLARE_EVENT_TABLE()
485 };
486
487 //-----------------------------------------------------------------------------
488 // wxListMainWindow (internal)
489 //-----------------------------------------------------------------------------
490
491 WX_DECLARE_EXPORTED_LIST(wxListHeaderData, wxListHeaderDataList);
492 #include "wx/listimpl.cpp"
493 WX_DEFINE_LIST(wxListHeaderDataList)
494
495 class wxListMainWindow : public wxScrolledWindow
496 {
497 public:
498 wxListMainWindow();
499 wxListMainWindow( wxWindow *parent,
500 wxWindowID id,
501 const wxPoint& pos = wxDefaultPosition,
502 const wxSize& size = wxDefaultSize,
503 long style = 0,
504 const wxString &name = _T("listctrlmainwindow") );
505
506 virtual ~wxListMainWindow();
507
508 bool HasFlag(int flag) const { return m_parent->HasFlag(flag); }
509
510 // return true if this is a virtual list control
511 bool IsVirtual() const { return HasFlag(wxLC_VIRTUAL); }
512
513 // return true if the control is in report mode
514 bool InReportView() const { return HasFlag(wxLC_REPORT); }
515
516 // return true if we are in single selection mode, false if multi sel
517 bool IsSingleSel() const { return HasFlag(wxLC_SINGLE_SEL); }
518
519 // do we have a header window?
520 bool HasHeader() const
521 { return InReportView() && !HasFlag(wxLC_NO_HEADER); }
522
523 void HighlightAll( bool on );
524
525 // all these functions only do something if the line is currently visible
526
527 // change the line "selected" state, return true if it really changed
528 bool HighlightLine( size_t line, bool highlight = true);
529
530 // as HighlightLine() but do it for the range of lines: this is incredibly
531 // more efficient for virtual list controls!
532 //
533 // NB: unlike HighlightLine() this one does refresh the lines on screen
534 void HighlightLines( size_t lineFrom, size_t lineTo, bool on = true );
535
536 // toggle the line state and refresh it
537 void ReverseHighlight( size_t line )
538 { HighlightLine(line, !IsHighlighted(line)); RefreshLine(line); }
539
540 // return true if the line is highlighted
541 bool IsHighlighted(size_t line) const;
542
543 // refresh one or several lines at once
544 void RefreshLine( size_t line );
545 void RefreshLines( size_t lineFrom, size_t lineTo );
546
547 // refresh all selected items
548 void RefreshSelected();
549
550 // refresh all lines below the given one: the difference with
551 // RefreshLines() is that the index here might not be a valid one (happens
552 // when the last line is deleted)
553 void RefreshAfter( size_t lineFrom );
554
555 // the methods which are forwarded to wxListLineData itself in list/icon
556 // modes but are here because the lines don't store their positions in the
557 // report mode
558
559 // get the bound rect for the entire line
560 wxRect GetLineRect(size_t line) const;
561
562 // get the bound rect of the label
563 wxRect GetLineLabelRect(size_t line) const;
564
565 // get the bound rect of the items icon (only may be called if we do have
566 // an icon!)
567 wxRect GetLineIconRect(size_t line) const;
568
569 // get the rect to be highlighted when the item has focus
570 wxRect GetLineHighlightRect(size_t line) const;
571
572 // get the size of the total line rect
573 wxSize GetLineSize(size_t line) const
574 { return GetLineRect(line).GetSize(); }
575
576 // return the hit code for the corresponding position (in this line)
577 long HitTestLine(size_t line, int x, int y) const;
578
579 // bring the selected item into view, scrolling to it if necessary
580 void MoveToItem(size_t item);
581
582 bool ScrollList( int WXUNUSED(dx), int dy );
583
584 // bring the current item into view
585 void MoveToFocus() { MoveToItem(m_current); }
586
587 // start editing the label of the given item
588 wxTextCtrl *EditLabel(long item,
589 wxClassInfo* textControlClass = CLASSINFO(wxTextCtrl));
590 wxTextCtrl *GetEditControl() const
591 {
592 return m_textctrlWrapper ? m_textctrlWrapper->GetText() : NULL;
593 }
594
595 void ResetTextControl(wxTextCtrl *text)
596 {
597 delete text;
598 m_textctrlWrapper = NULL;
599 }
600
601 // we don't draw anything while we're frozen so we must refresh ourselves
602 // when we're thawed to make sure the changes are displayed correctly
603 virtual void DoThaw() { Refresh(); }
604
605 void OnRenameTimer();
606 bool OnRenameAccept(size_t itemEdit, const wxString& value);
607 void OnRenameCancelled(size_t itemEdit);
608
609 void OnMouse( wxMouseEvent &event );
610
611 // called to switch the selection from the current item to newCurrent,
612 void OnArrowChar( size_t newCurrent, const wxKeyEvent& event );
613
614 void OnChar( wxKeyEvent &event );
615 void OnKeyDown( wxKeyEvent &event );
616 void OnKeyUp( wxKeyEvent &event );
617 void OnSetFocus( wxFocusEvent &event );
618 void OnKillFocus( wxFocusEvent &event );
619 void OnScroll( wxScrollWinEvent& event );
620
621 void OnPaint( wxPaintEvent &event );
622
623 void DrawImage( int index, wxDC *dc, int x, int y );
624 void GetImageSize( int index, int &width, int &height ) const;
625 int GetTextLength( const wxString &s ) const;
626
627 void SetImageList( wxImageList *imageList, int which );
628 void SetItemSpacing( int spacing, bool isSmall = false );
629 int GetItemSpacing( bool isSmall = false );
630
631 void SetColumn( int col, wxListItem &item );
632 void SetColumnWidth( int col, int width );
633 void GetColumn( int col, wxListItem &item ) const;
634 int GetColumnWidth( int col ) const;
635 int GetColumnCount() const { return m_columns.GetCount(); }
636
637 // returns the sum of the heights of all columns
638 int GetHeaderWidth() const;
639
640 int GetCountPerPage() const;
641
642 void SetItem( wxListItem &item );
643 void GetItem( wxListItem &item ) const;
644 void SetItemState( long item, long state, long stateMask );
645 void SetItemStateAll( long state, long stateMask );
646 int GetItemState( long item, long stateMask ) const;
647 void GetItemRect( long index, wxRect &rect ) const;
648 wxRect GetViewRect() const;
649 bool GetItemPosition( long item, wxPoint& pos ) const;
650 int GetSelectedItemCount() const;
651
652 wxString GetItemText(long item) const
653 {
654 wxListItem info;
655 info.m_mask = wxLIST_MASK_TEXT;
656 info.m_itemId = item;
657 GetItem( info );
658 return info.m_text;
659 }
660
661 void SetItemText(long item, const wxString& value)
662 {
663 wxListItem info;
664 info.m_mask = wxLIST_MASK_TEXT;
665 info.m_itemId = item;
666 info.m_text = value;
667 SetItem( info );
668 }
669
670 // set the scrollbars and update the positions of the items
671 void RecalculatePositions(bool noRefresh = false);
672
673 // refresh the window and the header
674 void RefreshAll();
675
676 long GetNextItem( long item, int geometry, int state ) const;
677 void DeleteItem( long index );
678 void DeleteAllItems();
679 void DeleteColumn( int col );
680 void DeleteEverything();
681 void EnsureVisible( long index );
682 long FindItem( long start, const wxString& str, bool partial = false );
683 long FindItem( long start, wxUIntPtr data);
684 long FindItem( const wxPoint& pt );
685 long HitTest( int x, int y, int &flags ) const;
686 void InsertItem( wxListItem &item );
687 void InsertColumn( long col, wxListItem &item );
688 int GetItemWidthWithImage(wxListItem * item);
689 void SortItems( wxListCtrlCompare fn, long data );
690
691 size_t GetItemCount() const;
692 bool IsEmpty() const { return GetItemCount() == 0; }
693 void SetItemCount(long count);
694
695 // change the current (== focused) item, send a notification event
696 void ChangeCurrent(size_t current);
697 void ResetCurrent() { ChangeCurrent((size_t)-1); }
698 bool HasCurrent() const { return m_current != (size_t)-1; }
699
700 // send out a wxListEvent
701 void SendNotify( size_t line,
702 wxEventType command,
703 const wxPoint& point = wxDefaultPosition );
704
705 // override base class virtual to reset m_lineHeight when the font changes
706 virtual bool SetFont(const wxFont& font)
707 {
708 if ( !wxScrolledWindow::SetFont(font) )
709 return false;
710
711 m_lineHeight = 0;
712
713 return true;
714 }
715
716 // these are for wxListLineData usage only
717
718 // get the backpointer to the list ctrl
719 wxGenericListCtrl *GetListCtrl() const
720 {
721 return wxStaticCast(GetParent(), wxGenericListCtrl);
722 }
723
724 // get the height of all lines (assuming they all do have the same height)
725 wxCoord GetLineHeight() const;
726
727 // get the y position of the given line (only for report view)
728 wxCoord GetLineY(size_t line) const;
729
730 // get the brush to use for the item highlighting
731 wxBrush *GetHighlightBrush() const
732 {
733 return m_hasFocus ? m_highlightBrush : m_highlightUnfocusedBrush;
734 }
735
736 bool HasFocus() const
737 {
738 return m_hasFocus;
739 }
740
741 //protected:
742 // the array of all line objects for a non virtual list control (for the
743 // virtual list control we only ever use m_lines[0])
744 wxListLineDataArray m_lines;
745
746 // the list of column objects
747 wxListHeaderDataList m_columns;
748
749 // currently focused item or -1
750 size_t m_current;
751
752 // the number of lines per page
753 int m_linesPerPage;
754
755 // this flag is set when something which should result in the window
756 // redrawing happens (i.e. an item was added or deleted, or its appearance
757 // changed) and OnPaint() doesn't redraw the window while it is set which
758 // allows to minimize the number of repaintings when a lot of items are
759 // being added. The real repainting occurs only after the next OnIdle()
760 // call
761 bool m_dirty;
762
763 wxColour *m_highlightColour;
764 wxImageList *m_small_image_list;
765 wxImageList *m_normal_image_list;
766 int m_small_spacing;
767 int m_normal_spacing;
768 bool m_hasFocus;
769
770 bool m_lastOnSame;
771 wxTimer *m_renameTimer;
772 bool m_isCreated;
773 int m_dragCount;
774 wxPoint m_dragStart;
775 ColWidthArray m_aColWidths;
776
777 // for double click logic
778 size_t m_lineLastClicked,
779 m_lineBeforeLastClicked,
780 m_lineSelectSingleOnUp;
781
782 protected:
783 wxWindow *GetMainWindowOfCompositeControl() { return GetParent(); }
784
785 // the total count of items in a virtual list control
786 size_t m_countVirt;
787
788 // the object maintaining the items selection state, only used in virtual
789 // controls
790 wxSelectionStore m_selStore;
791
792 // common part of all ctors
793 void Init();
794
795 // get the line data for the given index
796 wxListLineData *GetLine(size_t n) const
797 {
798 wxASSERT_MSG( n != (size_t)-1, _T("invalid line index") );
799
800 if ( IsVirtual() )
801 {
802 wxConstCast(this, wxListMainWindow)->CacheLineData(n);
803 n = 0;
804 }
805
806 return &m_lines[n];
807 }
808
809 // get a dummy line which can be used for geometry calculations and such:
810 // you must use GetLine() if you want to really draw the line
811 wxListLineData *GetDummyLine() const;
812
813 // cache the line data of the n-th line in m_lines[0]
814 void CacheLineData(size_t line);
815
816 // get the range of visible lines
817 void GetVisibleLinesRange(size_t *from, size_t *to);
818
819 // force us to recalculate the range of visible lines
820 void ResetVisibleLinesRange() { m_lineFrom = (size_t)-1; }
821
822 // get the colour to be used for drawing the rules
823 wxColour GetRuleColour() const
824 {
825 return wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT);
826 }
827
828 private:
829 // initialize the current item if needed
830 void UpdateCurrent();
831
832 // delete all items but don't refresh: called from dtor
833 void DoDeleteAllItems();
834
835 // the height of one line using the current font
836 wxCoord m_lineHeight;
837
838 // the total header width or 0 if not calculated yet
839 wxCoord m_headerWidth;
840
841 // the first and last lines being shown on screen right now (inclusive),
842 // both may be -1 if they must be calculated so never access them directly:
843 // use GetVisibleLinesRange() above instead
844 size_t m_lineFrom,
845 m_lineTo;
846
847 // the brushes to use for item highlighting when we do/don't have focus
848 wxBrush *m_highlightBrush,
849 *m_highlightUnfocusedBrush;
850
851 // wrapper around the text control currently used for in place editing or
852 // NULL if no item is being edited
853 wxListTextCtrlWrapper *m_textctrlWrapper;
854
855
856 DECLARE_DYNAMIC_CLASS(wxListMainWindow)
857 DECLARE_EVENT_TABLE()
858
859 friend class wxGenericListCtrl;
860 };
861
862
863 wxListItemData::~wxListItemData()
864 {
865 // in the virtual list control the attributes are managed by the main
866 // program, so don't delete them
867 if ( !m_owner->IsVirtual() )
868 delete m_attr;
869
870 delete m_rect;
871 }
872
873 void wxListItemData::Init()
874 {
875 m_image = -1;
876 m_data = 0;
877
878 m_attr = NULL;
879 }
880
881 wxListItemData::wxListItemData(wxListMainWindow *owner)
882 {
883 Init();
884
885 m_owner = owner;
886
887 if ( owner->InReportView() )
888 m_rect = NULL;
889 else
890 m_rect = new wxRect;
891 }
892
893 void wxListItemData::SetItem( const wxListItem &info )
894 {
895 if ( info.m_mask & wxLIST_MASK_TEXT )
896 SetText(info.m_text);
897 if ( info.m_mask & wxLIST_MASK_IMAGE )
898 m_image = info.m_image;
899 if ( info.m_mask & wxLIST_MASK_DATA )
900 m_data = info.m_data;
901
902 if ( info.HasAttributes() )
903 {
904 if ( m_attr )
905 m_attr->AssignFrom(*info.GetAttributes());
906 else
907 m_attr = new wxListItemAttr(*info.GetAttributes());
908 }
909
910 if ( m_rect )
911 {
912 m_rect->x =
913 m_rect->y =
914 m_rect->height = 0;
915 m_rect->width = info.m_width;
916 }
917 }
918
919 void wxListItemData::SetPosition( int x, int y )
920 {
921 wxCHECK_RET( m_rect, _T("unexpected SetPosition() call") );
922
923 m_rect->x = x;
924 m_rect->y = y;
925 }
926
927 void wxListItemData::SetSize( int width, int height )
928 {
929 wxCHECK_RET( m_rect, _T("unexpected SetSize() call") );
930
931 if ( width != -1 )
932 m_rect->width = width;
933 if ( height != -1 )
934 m_rect->height = height;
935 }
936
937 bool wxListItemData::IsHit( int x, int y ) const
938 {
939 wxCHECK_MSG( m_rect, false, _T("can't be called in this mode") );
940
941 return wxRect(GetX(), GetY(), GetWidth(), GetHeight()).Contains(x, y);
942 }
943
944 int wxListItemData::GetX() const
945 {
946 wxCHECK_MSG( m_rect, 0, _T("can't be called in this mode") );
947
948 return m_rect->x;
949 }
950
951 int wxListItemData::GetY() const
952 {
953 wxCHECK_MSG( m_rect, 0, _T("can't be called in this mode") );
954
955 return m_rect->y;
956 }
957
958 int wxListItemData::GetWidth() const
959 {
960 wxCHECK_MSG( m_rect, 0, _T("can't be called in this mode") );
961
962 return m_rect->width;
963 }
964
965 int wxListItemData::GetHeight() const
966 {
967 wxCHECK_MSG( m_rect, 0, _T("can't be called in this mode") );
968
969 return m_rect->height;
970 }
971
972 void wxListItemData::GetItem( wxListItem &info ) const
973 {
974 long mask = info.m_mask;
975 if ( !mask )
976 // by default, get everything for backwards compatibility
977 mask = -1;
978
979 if ( mask & wxLIST_MASK_TEXT )
980 info.m_text = m_text;
981 if ( mask & wxLIST_MASK_IMAGE )
982 info.m_image = m_image;
983 if ( mask & wxLIST_MASK_DATA )
984 info.m_data = m_data;
985
986 if ( m_attr )
987 {
988 if ( m_attr->HasTextColour() )
989 info.SetTextColour(m_attr->GetTextColour());
990 if ( m_attr->HasBackgroundColour() )
991 info.SetBackgroundColour(m_attr->GetBackgroundColour());
992 if ( m_attr->HasFont() )
993 info.SetFont(m_attr->GetFont());
994 }
995 }
996
997 //-----------------------------------------------------------------------------
998 // wxListHeaderData
999 //-----------------------------------------------------------------------------
1000
1001 void wxListHeaderData::Init()
1002 {
1003 m_mask = 0;
1004 m_image = -1;
1005 m_format = 0;
1006 m_width = 0;
1007 m_xpos = 0;
1008 m_ypos = 0;
1009 m_height = 0;
1010 m_state = 0;
1011 }
1012
1013 wxListHeaderData::wxListHeaderData()
1014 {
1015 Init();
1016 }
1017
1018 wxListHeaderData::wxListHeaderData( const wxListItem &item )
1019 {
1020 Init();
1021
1022 SetItem( item );
1023 }
1024
1025 void wxListHeaderData::SetItem( const wxListItem &item )
1026 {
1027 m_mask = item.m_mask;
1028
1029 if ( m_mask & wxLIST_MASK_TEXT )
1030 m_text = item.m_text;
1031
1032 if ( m_mask & wxLIST_MASK_IMAGE )
1033 m_image = item.m_image;
1034
1035 if ( m_mask & wxLIST_MASK_FORMAT )
1036 m_format = item.m_format;
1037
1038 if ( m_mask & wxLIST_MASK_WIDTH )
1039 SetWidth(item.m_width);
1040
1041 if ( m_mask & wxLIST_MASK_STATE )
1042 SetState(item.m_state);
1043 }
1044
1045 void wxListHeaderData::SetPosition( int x, int y )
1046 {
1047 m_xpos = x;
1048 m_ypos = y;
1049 }
1050
1051 void wxListHeaderData::SetHeight( int h )
1052 {
1053 m_height = h;
1054 }
1055
1056 void wxListHeaderData::SetWidth( int w )
1057 {
1058 m_width = w < 0 ? WIDTH_COL_DEFAULT : w;
1059 }
1060
1061 void wxListHeaderData::SetState( int flag )
1062 {
1063 m_state = flag;
1064 }
1065
1066 void wxListHeaderData::SetFormat( int format )
1067 {
1068 m_format = format;
1069 }
1070
1071 bool wxListHeaderData::HasImage() const
1072 {
1073 return m_image != -1;
1074 }
1075
1076 bool wxListHeaderData::IsHit( int x, int y ) const
1077 {
1078 return ((x >= m_xpos) && (x <= m_xpos+m_width) && (y >= m_ypos) && (y <= m_ypos+m_height));
1079 }
1080
1081 void wxListHeaderData::GetItem( wxListItem& item )
1082 {
1083 item.m_mask = m_mask;
1084 item.m_text = m_text;
1085 item.m_image = m_image;
1086 item.m_format = m_format;
1087 item.m_width = m_width;
1088 item.m_state = m_state;
1089 }
1090
1091 int wxListHeaderData::GetImage() const
1092 {
1093 return m_image;
1094 }
1095
1096 int wxListHeaderData::GetWidth() const
1097 {
1098 return m_width;
1099 }
1100
1101 int wxListHeaderData::GetFormat() const
1102 {
1103 return m_format;
1104 }
1105
1106 int wxListHeaderData::GetState() const
1107 {
1108 return m_state;
1109 }
1110
1111 //-----------------------------------------------------------------------------
1112 // wxListLineData
1113 //-----------------------------------------------------------------------------
1114
1115 inline int wxListLineData::GetMode() const
1116 {
1117 return m_owner->GetListCtrl()->GetWindowStyleFlag() & wxLC_MASK_TYPE;
1118 }
1119
1120 inline bool wxListLineData::InReportView() const
1121 {
1122 return m_owner->HasFlag(wxLC_REPORT);
1123 }
1124
1125 inline bool wxListLineData::IsVirtual() const
1126 {
1127 return m_owner->IsVirtual();
1128 }
1129
1130 wxListLineData::wxListLineData( wxListMainWindow *owner )
1131 {
1132 m_owner = owner;
1133
1134 if ( InReportView() )
1135 m_gi = NULL;
1136 else // !report
1137 m_gi = new GeometryInfo;
1138
1139 m_highlighted = false;
1140
1141 InitItems( GetMode() == wxLC_REPORT ? m_owner->GetColumnCount() : 1 );
1142 }
1143
1144 void wxListLineData::CalculateSize( wxDC *dc, int spacing )
1145 {
1146 wxListItemDataList::compatibility_iterator node = m_items.GetFirst();
1147 wxCHECK_RET( node, _T("no subitems at all??") );
1148
1149 wxListItemData *item = node->GetData();
1150
1151 wxString s;
1152 wxCoord lw, lh;
1153
1154 switch ( GetMode() )
1155 {
1156 case wxLC_ICON:
1157 case wxLC_SMALL_ICON:
1158 m_gi->m_rectAll.width = spacing;
1159
1160 s = item->GetText();
1161
1162 if ( s.empty() )
1163 {
1164 lh =
1165 m_gi->m_rectLabel.width =
1166 m_gi->m_rectLabel.height = 0;
1167 }
1168 else // has label
1169 {
1170 dc->GetTextExtent( s, &lw, &lh );
1171 lw += EXTRA_WIDTH;
1172 lh += EXTRA_HEIGHT;
1173
1174 m_gi->m_rectAll.height = spacing + lh;
1175 if (lw > spacing)
1176 m_gi->m_rectAll.width = lw;
1177
1178 m_gi->m_rectLabel.width = lw;
1179 m_gi->m_rectLabel.height = lh;
1180 }
1181
1182 if (item->HasImage())
1183 {
1184 int w, h;
1185 m_owner->GetImageSize( item->GetImage(), w, h );
1186 m_gi->m_rectIcon.width = w + 8;
1187 m_gi->m_rectIcon.height = h + 8;
1188
1189 if ( m_gi->m_rectIcon.width > m_gi->m_rectAll.width )
1190 m_gi->m_rectAll.width = m_gi->m_rectIcon.width;
1191 if ( m_gi->m_rectIcon.height + lh > m_gi->m_rectAll.height - 4 )
1192 m_gi->m_rectAll.height = m_gi->m_rectIcon.height + lh + 4;
1193 }
1194
1195 if ( item->HasText() )
1196 {
1197 m_gi->m_rectHighlight.width = m_gi->m_rectLabel.width;
1198 m_gi->m_rectHighlight.height = m_gi->m_rectLabel.height;
1199 }
1200 else // no text, highlight the icon
1201 {
1202 m_gi->m_rectHighlight.width = m_gi->m_rectIcon.width;
1203 m_gi->m_rectHighlight.height = m_gi->m_rectIcon.height;
1204 }
1205 break;
1206
1207 case wxLC_LIST:
1208 s = item->GetTextForMeasuring();
1209
1210 dc->GetTextExtent( s, &lw, &lh );
1211 lw += EXTRA_WIDTH;
1212 lh += EXTRA_HEIGHT;
1213
1214 m_gi->m_rectLabel.width = lw;
1215 m_gi->m_rectLabel.height = lh;
1216
1217 m_gi->m_rectAll.width = lw;
1218 m_gi->m_rectAll.height = lh;
1219
1220 if (item->HasImage())
1221 {
1222 int w, h;
1223 m_owner->GetImageSize( item->GetImage(), w, h );
1224 m_gi->m_rectIcon.width = w;
1225 m_gi->m_rectIcon.height = h;
1226
1227 m_gi->m_rectAll.width += 4 + w;
1228 if (h > m_gi->m_rectAll.height)
1229 m_gi->m_rectAll.height = h;
1230 }
1231
1232 m_gi->m_rectHighlight.width = m_gi->m_rectAll.width;
1233 m_gi->m_rectHighlight.height = m_gi->m_rectAll.height;
1234 break;
1235
1236 case wxLC_REPORT:
1237 wxFAIL_MSG( _T("unexpected call to SetSize") );
1238 break;
1239
1240 default:
1241 wxFAIL_MSG( _T("unknown mode") );
1242 break;
1243 }
1244 }
1245
1246 void wxListLineData::SetPosition( int x, int y, int spacing )
1247 {
1248 wxListItemDataList::compatibility_iterator node = m_items.GetFirst();
1249 wxCHECK_RET( node, _T("no subitems at all??") );
1250
1251 wxListItemData *item = node->GetData();
1252
1253 switch ( GetMode() )
1254 {
1255 case wxLC_ICON:
1256 case wxLC_SMALL_ICON:
1257 m_gi->m_rectAll.x = x;
1258 m_gi->m_rectAll.y = y;
1259
1260 if ( item->HasImage() )
1261 {
1262 m_gi->m_rectIcon.x = m_gi->m_rectAll.x + 4 +
1263 (m_gi->m_rectAll.width - m_gi->m_rectIcon.width) / 2;
1264 m_gi->m_rectIcon.y = m_gi->m_rectAll.y + 4;
1265 }
1266
1267 if ( item->HasText() )
1268 {
1269 if (m_gi->m_rectAll.width > spacing)
1270 m_gi->m_rectLabel.x = m_gi->m_rectAll.x + (EXTRA_WIDTH/2);
1271 else
1272 m_gi->m_rectLabel.x = m_gi->m_rectAll.x + (EXTRA_WIDTH/2) + (spacing / 2) - (m_gi->m_rectLabel.width / 2);
1273 m_gi->m_rectLabel.y = m_gi->m_rectAll.y + m_gi->m_rectAll.height + 2 - m_gi->m_rectLabel.height;
1274 m_gi->m_rectHighlight.x = m_gi->m_rectLabel.x - 2;
1275 m_gi->m_rectHighlight.y = m_gi->m_rectLabel.y - 2;
1276 }
1277 else // no text, highlight the icon
1278 {
1279 m_gi->m_rectHighlight.x = m_gi->m_rectIcon.x - 4;
1280 m_gi->m_rectHighlight.y = m_gi->m_rectIcon.y - 4;
1281 }
1282 break;
1283
1284 case wxLC_LIST:
1285 m_gi->m_rectAll.x = x;
1286 m_gi->m_rectAll.y = y;
1287
1288 m_gi->m_rectHighlight.x = m_gi->m_rectAll.x;
1289 m_gi->m_rectHighlight.y = m_gi->m_rectAll.y;
1290 m_gi->m_rectLabel.y = m_gi->m_rectAll.y + 2;
1291
1292 if (item->HasImage())
1293 {
1294 m_gi->m_rectIcon.x = m_gi->m_rectAll.x + 2;
1295 m_gi->m_rectIcon.y = m_gi->m_rectAll.y + 2;
1296 m_gi->m_rectLabel.x = m_gi->m_rectAll.x + 4 + (EXTRA_WIDTH/2) + m_gi->m_rectIcon.width;
1297 }
1298 else
1299 {
1300 m_gi->m_rectLabel.x = m_gi->m_rectAll.x + (EXTRA_WIDTH/2);
1301 }
1302 break;
1303
1304 case wxLC_REPORT:
1305 wxFAIL_MSG( _T("unexpected call to SetPosition") );
1306 break;
1307
1308 default:
1309 wxFAIL_MSG( _T("unknown mode") );
1310 break;
1311 }
1312 }
1313
1314 void wxListLineData::InitItems( int num )
1315 {
1316 for (int i = 0; i < num; i++)
1317 m_items.Append( new wxListItemData(m_owner) );
1318 }
1319
1320 void wxListLineData::SetItem( int index, const wxListItem &info )
1321 {
1322 wxListItemDataList::compatibility_iterator node = m_items.Item( index );
1323 wxCHECK_RET( node, _T("invalid column index in SetItem") );
1324
1325 wxListItemData *item = node->GetData();
1326 item->SetItem( info );
1327 }
1328
1329 void wxListLineData::GetItem( int index, wxListItem &info )
1330 {
1331 wxListItemDataList::compatibility_iterator node = m_items.Item( index );
1332 if (node)
1333 {
1334 wxListItemData *item = node->GetData();
1335 item->GetItem( info );
1336 }
1337 }
1338
1339 wxString wxListLineData::GetText(int index) const
1340 {
1341 wxString s;
1342
1343 wxListItemDataList::compatibility_iterator node = m_items.Item( index );
1344 if (node)
1345 {
1346 wxListItemData *item = node->GetData();
1347 s = item->GetText();
1348 }
1349
1350 return s;
1351 }
1352
1353 void wxListLineData::SetText( int index, const wxString& s )
1354 {
1355 wxListItemDataList::compatibility_iterator node = m_items.Item( index );
1356 if (node)
1357 {
1358 wxListItemData *item = node->GetData();
1359 item->SetText( s );
1360 }
1361 }
1362
1363 void wxListLineData::SetImage( int index, int image )
1364 {
1365 wxListItemDataList::compatibility_iterator node = m_items.Item( index );
1366 wxCHECK_RET( node, _T("invalid column index in SetImage()") );
1367
1368 wxListItemData *item = node->GetData();
1369 item->SetImage(image);
1370 }
1371
1372 int wxListLineData::GetImage( int index ) const
1373 {
1374 wxListItemDataList::compatibility_iterator node = m_items.Item( index );
1375 wxCHECK_MSG( node, -1, _T("invalid column index in GetImage()") );
1376
1377 wxListItemData *item = node->GetData();
1378 return item->GetImage();
1379 }
1380
1381 wxListItemAttr *wxListLineData::GetAttr() const
1382 {
1383 wxListItemDataList::compatibility_iterator node = m_items.GetFirst();
1384 wxCHECK_MSG( node, NULL, _T("invalid column index in GetAttr()") );
1385
1386 wxListItemData *item = node->GetData();
1387 return item->GetAttr();
1388 }
1389
1390 void wxListLineData::SetAttr(wxListItemAttr *attr)
1391 {
1392 wxListItemDataList::compatibility_iterator node = m_items.GetFirst();
1393 wxCHECK_RET( node, _T("invalid column index in SetAttr()") );
1394
1395 wxListItemData *item = node->GetData();
1396 item->SetAttr(attr);
1397 }
1398
1399 bool wxListLineData::SetAttributes(wxDC *dc,
1400 const wxListItemAttr *attr,
1401 bool highlighted)
1402 {
1403 wxWindow *listctrl = m_owner->GetParent();
1404
1405 // fg colour
1406
1407 // don't use foreground colour for drawing highlighted items - this might
1408 // make them completely invisible (and there is no way to do bit
1409 // arithmetics on wxColour, unfortunately)
1410 wxColour colText;
1411 if ( highlighted )
1412 #ifdef __WXMAC__
1413 {
1414 if (m_owner->HasFocus()
1415 #if !defined(__WXUNIVERSAL__)
1416 && IsControlActive( (ControlRef)m_owner->GetHandle() )
1417 #endif
1418 )
1419 colText = *wxWHITE;
1420 else
1421 colText = *wxBLACK;
1422 }
1423 #else
1424 colText = wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
1425 #endif
1426 else if ( attr && attr->HasTextColour() )
1427 colText = attr->GetTextColour();
1428 else
1429 colText = listctrl->GetForegroundColour();
1430
1431 dc->SetTextForeground(colText);
1432
1433 // font
1434 wxFont font;
1435 if ( attr && attr->HasFont() )
1436 font = attr->GetFont();
1437 else
1438 font = listctrl->GetFont();
1439
1440 dc->SetFont(font);
1441
1442 // bg colour
1443 bool hasBgCol = attr && attr->HasBackgroundColour();
1444 if ( highlighted || hasBgCol )
1445 {
1446 if ( highlighted )
1447 dc->SetBrush( *m_owner->GetHighlightBrush() );
1448 else
1449 dc->SetBrush(wxBrush(attr->GetBackgroundColour(), wxSOLID));
1450
1451 dc->SetPen( *wxTRANSPARENT_PEN );
1452
1453 return true;
1454 }
1455
1456 return false;
1457 }
1458
1459 void wxListLineData::Draw( wxDC *dc )
1460 {
1461 wxListItemDataList::compatibility_iterator node = m_items.GetFirst();
1462 wxCHECK_RET( node, _T("no subitems at all??") );
1463
1464 bool highlighted = IsHighlighted();
1465
1466 wxListItemAttr *attr = GetAttr();
1467
1468 if ( SetAttributes(dc, attr, highlighted) )
1469 #if ( !defined(__WXGTK20__) && !defined(__WXMAC__) )
1470 {
1471 dc->DrawRectangle( m_gi->m_rectHighlight );
1472 }
1473 #else
1474 {
1475 if (highlighted)
1476 {
1477 int flags = wxCONTROL_SELECTED;
1478 if (m_owner->HasFocus()
1479 #if defined( __WXMAC__ ) && !defined(__WXUNIVERSAL__)
1480 && IsControlActive( (ControlRef)m_owner->GetHandle() )
1481 #endif
1482 )
1483 flags |= wxCONTROL_FOCUSED;
1484 wxRendererNative::Get().DrawItemSelectionRect( m_owner, *dc, m_gi->m_rectHighlight, flags );
1485
1486 }
1487 else
1488 {
1489 dc->DrawRectangle( m_gi->m_rectHighlight );
1490 }
1491 }
1492 #endif
1493
1494 // just for debugging to better see where the items are
1495 #if 0
1496 dc->SetPen(*wxRED_PEN);
1497 dc->SetBrush(*wxTRANSPARENT_BRUSH);
1498 dc->DrawRectangle( m_gi->m_rectAll );
1499 dc->SetPen(*wxGREEN_PEN);
1500 dc->DrawRectangle( m_gi->m_rectIcon );
1501 #endif
1502
1503 wxListItemData *item = node->GetData();
1504 if (item->HasImage())
1505 {
1506 // centre the image inside our rectangle, this looks nicer when items
1507 // ae aligned in a row
1508 const wxRect& rectIcon = m_gi->m_rectIcon;
1509
1510 m_owner->DrawImage(item->GetImage(), dc, rectIcon.x, rectIcon.y);
1511 }
1512
1513 if (item->HasText())
1514 {
1515 const wxRect& rectLabel = m_gi->m_rectLabel;
1516
1517 wxDCClipper clipper(*dc, rectLabel);
1518 dc->DrawText(item->GetText(), rectLabel.x, rectLabel.y);
1519 }
1520 }
1521
1522 void wxListLineData::DrawInReportMode( wxDC *dc,
1523 const wxRect& rect,
1524 const wxRect& rectHL,
1525 bool highlighted )
1526 {
1527 // TODO: later we should support setting different attributes for
1528 // different columns - to do it, just add "col" argument to
1529 // GetAttr() and move these lines into the loop below
1530 wxListItemAttr *attr = GetAttr();
1531 if ( SetAttributes(dc, attr, highlighted) )
1532 #if ( !defined(__WXGTK20__) && !defined(__WXMAC__) )
1533 {
1534 dc->DrawRectangle( rectHL );
1535 }
1536 #else
1537 {
1538 if (highlighted)
1539 {
1540 int flags = wxCONTROL_SELECTED;
1541 if (m_owner->HasFocus())
1542 flags |= wxCONTROL_FOCUSED;
1543 wxRendererNative::Get().DrawItemSelectionRect( m_owner, *dc, rectHL, flags );
1544 }
1545 else
1546 {
1547 dc->DrawRectangle( rectHL );
1548 }
1549 }
1550 #endif
1551
1552 wxCoord x = rect.x + HEADER_OFFSET_X,
1553 yMid = rect.y + rect.height/2;
1554 #ifdef __WXGTK__
1555 // This probably needs to be done
1556 // on all platforms as the icons
1557 // otherwise nearly touch the border
1558 x += 2;
1559 #endif
1560
1561 size_t col = 0;
1562 for ( wxListItemDataList::compatibility_iterator node = m_items.GetFirst();
1563 node;
1564 node = node->GetNext(), col++ )
1565 {
1566 wxListItemData *item = node->GetData();
1567
1568 int width = m_owner->GetColumnWidth(col);
1569 int xOld = x;
1570 x += width;
1571
1572 const int wText = width - 8;
1573 wxDCClipper clipper(*dc, xOld, rect.y, wText, rect.height);
1574
1575 if ( item->HasImage() )
1576 {
1577 int ix, iy;
1578 m_owner->GetImageSize( item->GetImage(), ix, iy );
1579 m_owner->DrawImage( item->GetImage(), dc, xOld, yMid - iy/2 );
1580
1581 ix += IMAGE_MARGIN_IN_REPORT_MODE;
1582
1583 xOld += ix;
1584 width -= ix;
1585 }
1586
1587 if ( item->HasText() )
1588 DrawTextFormatted(dc, item->GetText(), col, xOld, yMid, wText);
1589 }
1590 }
1591
1592 void wxListLineData::DrawTextFormatted(wxDC *dc,
1593 const wxString& textOrig,
1594 int col,
1595 int x,
1596 int yMid,
1597 int width)
1598 {
1599 // we don't support displaying multiple lines currently (and neither does
1600 // wxMSW FWIW) so just merge all the lines
1601 wxString text(textOrig);
1602 text.Replace(_T("\n"), _T(" "));
1603
1604 wxCoord w, h;
1605 dc->GetTextExtent(text, &w, &h);
1606
1607 const wxCoord y = yMid - (h + 1)/2;
1608
1609 wxDCClipper clipper(*dc, x, y, width, h);
1610
1611 // determine if the string can fit inside the current width
1612 if (w <= width)
1613 {
1614 // it can, draw it using the items alignment
1615 wxListItem item;
1616 m_owner->GetColumn(col, item);
1617 switch ( item.GetAlign() )
1618 {
1619 case wxLIST_FORMAT_LEFT:
1620 // nothing to do
1621 break;
1622
1623 case wxLIST_FORMAT_RIGHT:
1624 x += width - w;
1625 break;
1626
1627 case wxLIST_FORMAT_CENTER:
1628 x += (width - w) / 2;
1629 break;
1630
1631 default:
1632 wxFAIL_MSG( _T("unknown list item format") );
1633 break;
1634 }
1635
1636 dc->DrawText(text, x, y);
1637 }
1638 else // otherwise, truncate and add an ellipsis if possible
1639 {
1640 // determine the base width
1641 wxString ellipsis(wxT("..."));
1642 wxCoord base_w;
1643 dc->GetTextExtent(ellipsis, &base_w, &h);
1644
1645 // continue until we have enough space or only one character left
1646 wxCoord w_c, h_c;
1647 size_t len = text.length();
1648 wxString drawntext = text.Left(len);
1649 while (len > 1)
1650 {
1651 dc->GetTextExtent(drawntext.Last(), &w_c, &h_c);
1652 drawntext.RemoveLast();
1653 len--;
1654 w -= w_c;
1655 if (w + base_w <= width)
1656 break;
1657 }
1658
1659 // if still not enough space, remove ellipsis characters
1660 while (ellipsis.length() > 0 && w + base_w > width)
1661 {
1662 ellipsis = ellipsis.Left(ellipsis.length() - 1);
1663 dc->GetTextExtent(ellipsis, &base_w, &h);
1664 }
1665
1666 // now draw the text
1667 dc->DrawText(drawntext, x, y);
1668 dc->DrawText(ellipsis, x + w, y);
1669 }
1670 }
1671
1672 bool wxListLineData::Highlight( bool on )
1673 {
1674 wxCHECK_MSG( !IsVirtual(), false, _T("unexpected call to Highlight") );
1675
1676 if ( on == m_highlighted )
1677 return false;
1678
1679 m_highlighted = on;
1680
1681 return true;
1682 }
1683
1684 void wxListLineData::ReverseHighlight( void )
1685 {
1686 Highlight(!IsHighlighted());
1687 }
1688
1689 //-----------------------------------------------------------------------------
1690 // wxListHeaderWindow
1691 //-----------------------------------------------------------------------------
1692
1693 IMPLEMENT_DYNAMIC_CLASS(wxListHeaderWindow,wxWindow)
1694
1695 BEGIN_EVENT_TABLE(wxListHeaderWindow,wxWindow)
1696 EVT_PAINT (wxListHeaderWindow::OnPaint)
1697 EVT_MOUSE_EVENTS (wxListHeaderWindow::OnMouse)
1698 EVT_SET_FOCUS (wxListHeaderWindow::OnSetFocus)
1699 END_EVENT_TABLE()
1700
1701 void wxListHeaderWindow::Init()
1702 {
1703 m_currentCursor = (wxCursor *) NULL;
1704 m_isDragging = false;
1705 m_dirty = false;
1706 }
1707
1708 wxListHeaderWindow::wxListHeaderWindow()
1709 {
1710 Init();
1711
1712 m_owner = (wxListMainWindow *) NULL;
1713 m_resizeCursor = (wxCursor *) NULL;
1714 }
1715
1716 wxListHeaderWindow::wxListHeaderWindow( wxWindow *win,
1717 wxWindowID id,
1718 wxListMainWindow *owner,
1719 const wxPoint& pos,
1720 const wxSize& size,
1721 long style,
1722 const wxString &name )
1723 : wxWindow( win, id, pos, size, style, name )
1724 {
1725 Init();
1726
1727 m_owner = owner;
1728 m_resizeCursor = new wxCursor( wxCURSOR_SIZEWE );
1729
1730 #if _USE_VISATTR
1731 wxVisualAttributes attr = wxPanel::GetClassDefaultAttributes();
1732 SetOwnForegroundColour( attr.colFg );
1733 SetOwnBackgroundColour( attr.colBg );
1734 if (!m_hasFont)
1735 SetOwnFont( attr.font );
1736 #else
1737 SetOwnForegroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT));
1738 SetOwnBackgroundColour( wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
1739 if (!m_hasFont)
1740 SetOwnFont( wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT ));
1741 #endif
1742 }
1743
1744 wxListHeaderWindow::~wxListHeaderWindow()
1745 {
1746 delete m_resizeCursor;
1747 }
1748
1749 #ifdef __WXUNIVERSAL__
1750 #include "wx/univ/renderer.h"
1751 #include "wx/univ/theme.h"
1752 #endif
1753
1754 // shift the DC origin to match the position of the main window horz
1755 // scrollbar: this allows us to always use logical coords
1756 void wxListHeaderWindow::AdjustDC(wxDC& dc)
1757 {
1758 int xpix;
1759 m_owner->GetScrollPixelsPerUnit( &xpix, NULL );
1760
1761 int view_start;
1762 m_owner->GetViewStart( &view_start, NULL );
1763
1764
1765 int org_x = 0;
1766 int org_y = 0;
1767 dc.GetDeviceOrigin( &org_x, &org_y );
1768
1769 // account for the horz scrollbar offset
1770 #ifdef __WXGTK__
1771 if (GetLayoutDirection() == wxLayout_RightToLeft)
1772 {
1773 // Maybe we just have to check for m_signX
1774 // in the DC, but I leave the #ifdef __WXGTK__
1775 // for now
1776 dc.SetDeviceOrigin( org_x + (view_start * xpix), org_y );
1777 }
1778 else
1779 #endif
1780 dc.SetDeviceOrigin( org_x - (view_start * xpix), org_y );
1781 }
1782
1783 void wxListHeaderWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
1784 {
1785 wxPaintDC dc( this );
1786
1787 PrepareDC( dc );
1788 AdjustDC( dc );
1789
1790 dc.SetFont( GetFont() );
1791
1792 // width and height of the entire header window
1793 int w, h;
1794 GetClientSize( &w, &h );
1795 m_owner->CalcUnscrolledPosition(w, 0, &w, NULL);
1796
1797 dc.SetBackgroundMode(wxTRANSPARENT);
1798 dc.SetTextForeground(GetForegroundColour());
1799
1800 int x = HEADER_OFFSET_X;
1801 int numColumns = m_owner->GetColumnCount();
1802 wxListItem item;
1803 for ( int i = 0; i < numColumns && x < w; i++ )
1804 {
1805 m_owner->GetColumn( i, item );
1806 int wCol = item.m_width;
1807
1808 int cw = wCol;
1809 int ch = h;
1810
1811 int flags = 0;
1812 if (!m_parent->IsEnabled())
1813 flags |= wxCONTROL_DISABLED;
1814
1815 // NB: The code below is not really Mac-specific, but since we are close
1816 // to 2.8 release and I don't have time to test on other platforms, I
1817 // defined this only for wxMac. If this behavior is desired on
1818 // other platforms, please go ahead and revise or remove the #ifdef.
1819 #ifdef __WXMAC__
1820 if ( !m_owner->IsVirtual() && (item.m_mask & wxLIST_MASK_STATE) &&
1821 (item.m_state & wxLIST_STATE_SELECTED) )
1822 flags |= wxCONTROL_SELECTED;
1823 #endif
1824
1825 wxRendererNative::Get().DrawHeaderButton
1826 (
1827 this,
1828 dc,
1829 wxRect(x, HEADER_OFFSET_Y, cw, ch),
1830 flags
1831 );
1832
1833 // see if we have enough space for the column label
1834
1835 // for this we need the width of the text
1836 wxCoord wLabel;
1837 wxCoord hLabel;
1838 dc.GetTextExtent(item.GetText(), &wLabel, &hLabel);
1839 wLabel += 2 * EXTRA_WIDTH;
1840
1841 // and the width of the icon, if any
1842 int ix = 0, iy = 0; // init them just to suppress the compiler warnings
1843 const int image = item.m_image;
1844 wxImageList *imageList;
1845 if ( image != -1 )
1846 {
1847 imageList = m_owner->m_small_image_list;
1848 if ( imageList )
1849 {
1850 imageList->GetSize(image, ix, iy);
1851 wLabel += ix + HEADER_IMAGE_MARGIN_IN_REPORT_MODE;
1852 }
1853 }
1854 else
1855 {
1856 imageList = NULL;
1857 }
1858
1859 // ignore alignment if there is not enough space anyhow
1860 int xAligned;
1861 switch ( wLabel < cw ? item.GetAlign() : wxLIST_FORMAT_LEFT )
1862 {
1863 default:
1864 wxFAIL_MSG( _T("unknown list item format") );
1865 // fall through
1866
1867 case wxLIST_FORMAT_LEFT:
1868 xAligned = x;
1869 break;
1870
1871 case wxLIST_FORMAT_RIGHT:
1872 xAligned = x + cw - wLabel;
1873 break;
1874
1875 case wxLIST_FORMAT_CENTER:
1876 xAligned = x + (cw - wLabel) / 2;
1877 break;
1878 }
1879
1880 // draw the text and image clipping them so that they
1881 // don't overwrite the column boundary
1882 wxDCClipper clipper(dc, x, HEADER_OFFSET_Y, cw, h - 4 );
1883
1884 // if we have an image, draw it on the right of the label
1885 if ( imageList )
1886 {
1887 imageList->Draw
1888 (
1889 image,
1890 dc,
1891 xAligned + wLabel - ix - HEADER_IMAGE_MARGIN_IN_REPORT_MODE,
1892 HEADER_OFFSET_Y + (h - 4 - iy)/2,
1893 wxIMAGELIST_DRAW_TRANSPARENT
1894 );
1895 }
1896
1897 dc.DrawText( item.GetText(),
1898 xAligned + EXTRA_WIDTH, h / 2 - hLabel / 2 ); //HEADER_OFFSET_Y + EXTRA_HEIGHT );
1899
1900 x += wCol;
1901 }
1902 }
1903
1904 void wxListHeaderWindow::DrawCurrent()
1905 {
1906 #if 1
1907 m_owner->SetColumnWidth( m_column, m_currentX - m_minX );
1908 #else
1909 int x1 = m_currentX;
1910 int y1 = 0;
1911 m_owner->ClientToScreen( &x1, &y1 );
1912
1913 int x2 = m_currentX;
1914 int y2 = 0;
1915 m_owner->GetClientSize( NULL, &y2 );
1916 m_owner->ClientToScreen( &x2, &y2 );
1917
1918 wxScreenDC dc;
1919 dc.SetLogicalFunction( wxINVERT );
1920 dc.SetPen( wxPen( *wxBLACK, 2, wxSOLID ) );
1921 dc.SetBrush( *wxTRANSPARENT_BRUSH );
1922
1923 AdjustDC(dc);
1924
1925 dc.DrawLine( x1, y1, x2, y2 );
1926
1927 dc.SetLogicalFunction( wxCOPY );
1928
1929 dc.SetPen( wxNullPen );
1930 dc.SetBrush( wxNullBrush );
1931 #endif
1932 }
1933
1934 void wxListHeaderWindow::OnMouse( wxMouseEvent &event )
1935 {
1936 // we want to work with logical coords
1937 int x;
1938 m_owner->CalcUnscrolledPosition(event.GetX(), 0, &x, NULL);
1939 int y = event.GetY();
1940
1941 if (m_isDragging)
1942 {
1943 SendListEvent(wxEVT_COMMAND_LIST_COL_DRAGGING, event.GetPosition());
1944
1945 // we don't draw the line beyond our window, but we allow dragging it
1946 // there
1947 int w = 0;
1948 GetClientSize( &w, NULL );
1949 m_owner->CalcUnscrolledPosition(w, 0, &w, NULL);
1950 w -= 6;
1951
1952 // erase the line if it was drawn
1953 if ( m_currentX < w )
1954 DrawCurrent();
1955
1956 if (event.ButtonUp())
1957 {
1958 ReleaseMouse();
1959 m_isDragging = false;
1960 m_dirty = true;
1961 m_owner->SetColumnWidth( m_column, m_currentX - m_minX );
1962 SendListEvent(wxEVT_COMMAND_LIST_COL_END_DRAG, event.GetPosition());
1963 }
1964 else
1965 {
1966 if (x > m_minX + 7)
1967 m_currentX = x;
1968 else
1969 m_currentX = m_minX + 7;
1970
1971 // draw in the new location
1972 if ( m_currentX < w )
1973 DrawCurrent();
1974 }
1975 }
1976 else // not dragging
1977 {
1978 m_minX = 0;
1979 bool hit_border = false;
1980
1981 // end of the current column
1982 int xpos = 0;
1983
1984 // find the column where this event occurred
1985 int col,
1986 countCol = m_owner->GetColumnCount();
1987 for (col = 0; col < countCol; col++)
1988 {
1989 xpos += m_owner->GetColumnWidth( col );
1990 m_column = col;
1991
1992 if ( (abs(x-xpos) < 3) && (y < 22) )
1993 {
1994 // near the column border
1995 hit_border = true;
1996 break;
1997 }
1998
1999 if ( x < xpos )
2000 {
2001 // inside the column
2002 break;
2003 }
2004
2005 m_minX = xpos;
2006 }
2007
2008 if ( col == countCol )
2009 m_column = -1;
2010
2011 if (event.LeftDown() || event.RightUp())
2012 {
2013 if (hit_border && event.LeftDown())
2014 {
2015 if ( SendListEvent(wxEVT_COMMAND_LIST_COL_BEGIN_DRAG,
2016 event.GetPosition()) )
2017 {
2018 m_isDragging = true;
2019 m_currentX = x;
2020 CaptureMouse();
2021 DrawCurrent();
2022 }
2023 //else: column resizing was vetoed by the user code
2024 }
2025 else // click on a column
2026 {
2027 // record the selected state of the columns
2028 if (event.LeftDown())
2029 {
2030 for (int i=0; i < m_owner->GetColumnCount(); i++)
2031 {
2032 wxListItem colItem;
2033 m_owner->GetColumn(i, colItem);
2034 long state = colItem.GetState();
2035 if (i == m_column)
2036 colItem.SetState(state | wxLIST_STATE_SELECTED);
2037 else
2038 colItem.SetState(state & ~wxLIST_STATE_SELECTED);
2039 m_owner->SetColumn(i, colItem);
2040 }
2041 }
2042
2043 SendListEvent( event.LeftDown()
2044 ? wxEVT_COMMAND_LIST_COL_CLICK
2045 : wxEVT_COMMAND_LIST_COL_RIGHT_CLICK,
2046 event.GetPosition());
2047 }
2048 }
2049 else if (event.Moving())
2050 {
2051 bool setCursor;
2052 if (hit_border)
2053 {
2054 setCursor = m_currentCursor == wxSTANDARD_CURSOR;
2055 m_currentCursor = m_resizeCursor;
2056 }
2057 else
2058 {
2059 setCursor = m_currentCursor != wxSTANDARD_CURSOR;
2060 m_currentCursor = wxSTANDARD_CURSOR;
2061 }
2062
2063 if ( setCursor )
2064 SetCursor(*m_currentCursor);
2065 }
2066 }
2067 }
2068
2069 void wxListHeaderWindow::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
2070 {
2071 m_owner->SetFocus();
2072 m_owner->Update();
2073 }
2074
2075 bool wxListHeaderWindow::SendListEvent(wxEventType type, const wxPoint& pos)
2076 {
2077 wxWindow *parent = GetParent();
2078 wxListEvent le( type, parent->GetId() );
2079 le.SetEventObject( parent );
2080 le.m_pointDrag = pos;
2081
2082 // the position should be relative to the parent window, not
2083 // this one for compatibility with MSW and common sense: the
2084 // user code doesn't know anything at all about this header
2085 // window, so why should it get positions relative to it?
2086 le.m_pointDrag.y -= GetSize().y;
2087
2088 le.m_col = m_column;
2089 return !parent->GetEventHandler()->ProcessEvent( le ) || le.IsAllowed();
2090 }
2091
2092 //-----------------------------------------------------------------------------
2093 // wxListRenameTimer (internal)
2094 //-----------------------------------------------------------------------------
2095
2096 wxListRenameTimer::wxListRenameTimer( wxListMainWindow *owner )
2097 {
2098 m_owner = owner;
2099 }
2100
2101 void wxListRenameTimer::Notify()
2102 {
2103 m_owner->OnRenameTimer();
2104 }
2105
2106 //-----------------------------------------------------------------------------
2107 // wxListTextCtrlWrapper (internal)
2108 //-----------------------------------------------------------------------------
2109
2110 BEGIN_EVENT_TABLE(wxListTextCtrlWrapper, wxEvtHandler)
2111 EVT_CHAR (wxListTextCtrlWrapper::OnChar)
2112 EVT_KEY_UP (wxListTextCtrlWrapper::OnKeyUp)
2113 EVT_KILL_FOCUS (wxListTextCtrlWrapper::OnKillFocus)
2114 END_EVENT_TABLE()
2115
2116 wxListTextCtrlWrapper::wxListTextCtrlWrapper(wxListMainWindow *owner,
2117 wxTextCtrl *text,
2118 size_t itemEdit)
2119 : m_startValue(owner->GetItemText(itemEdit)),
2120 m_itemEdited(itemEdit)
2121 {
2122 m_owner = owner;
2123 m_text = text;
2124 m_aboutToFinish = false;
2125
2126 wxRect rectLabel = owner->GetLineLabelRect(itemEdit);
2127
2128 m_owner->CalcScrolledPosition(rectLabel.x, rectLabel.y,
2129 &rectLabel.x, &rectLabel.y);
2130
2131 m_text->Create(owner, wxID_ANY, m_startValue,
2132 wxPoint(rectLabel.x-4,rectLabel.y-4),
2133 wxSize(rectLabel.width+11,rectLabel.height+8));
2134 m_text->SetFocus();
2135
2136 m_text->PushEventHandler(this);
2137 }
2138
2139 void wxListTextCtrlWrapper::EndEdit(bool discardChanges)
2140 {
2141 m_aboutToFinish = true;
2142
2143 if ( discardChanges )
2144 {
2145 m_owner->OnRenameCancelled(m_itemEdited);
2146
2147 Finish( true );
2148 }
2149 else
2150 {
2151 // Notify the owner about the changes
2152 AcceptChanges();
2153
2154 // Even if vetoed, close the control (consistent with MSW)
2155 Finish( true );
2156 }
2157 }
2158
2159 void wxListTextCtrlWrapper::Finish( bool setfocus )
2160 {
2161 m_text->RemoveEventHandler(this);
2162 m_owner->ResetTextControl( m_text );
2163
2164 wxPendingDelete.Append( this );
2165
2166 if (setfocus)
2167 m_owner->SetFocusIgnoringChildren();
2168 }
2169
2170 bool wxListTextCtrlWrapper::AcceptChanges()
2171 {
2172 const wxString value = m_text->GetValue();
2173
2174 // notice that we should always call OnRenameAccept() to generate the "end
2175 // label editing" event, even if the user hasn't really changed anything
2176 if ( !m_owner->OnRenameAccept(m_itemEdited, value) )
2177 {
2178 // vetoed by the user
2179 return false;
2180 }
2181
2182 // accepted, do rename the item (unless nothing changed)
2183 if ( value != m_startValue )
2184 m_owner->SetItemText(m_itemEdited, value);
2185
2186 return true;
2187 }
2188
2189 void wxListTextCtrlWrapper::OnChar( wxKeyEvent &event )
2190 {
2191 switch ( event.m_keyCode )
2192 {
2193 case WXK_RETURN:
2194 EndEdit( false );
2195 break;
2196
2197 case WXK_ESCAPE:
2198 EndEdit( true );
2199 break;
2200
2201 default:
2202 event.Skip();
2203 }
2204 }
2205
2206 void wxListTextCtrlWrapper::OnKeyUp( wxKeyEvent &event )
2207 {
2208 if (m_aboutToFinish)
2209 {
2210 // auto-grow the textctrl:
2211 wxSize parentSize = m_owner->GetSize();
2212 wxPoint myPos = m_text->GetPosition();
2213 wxSize mySize = m_text->GetSize();
2214 int sx, sy;
2215 m_text->GetTextExtent(m_text->GetValue() + _T("MM"), &sx, &sy);
2216 if (myPos.x + sx > parentSize.x)
2217 sx = parentSize.x - myPos.x;
2218 if (mySize.x > sx)
2219 sx = mySize.x;
2220 m_text->SetSize(sx, wxDefaultCoord);
2221 }
2222
2223 event.Skip();
2224 }
2225
2226 void wxListTextCtrlWrapper::OnKillFocus( wxFocusEvent &event )
2227 {
2228 if ( !m_aboutToFinish )
2229 {
2230 if ( !AcceptChanges() )
2231 m_owner->OnRenameCancelled( m_itemEdited );
2232
2233 Finish( false );
2234 }
2235
2236 // We must let the native text control handle focus
2237 event.Skip();
2238 }
2239
2240 //-----------------------------------------------------------------------------
2241 // wxListMainWindow
2242 //-----------------------------------------------------------------------------
2243
2244 IMPLEMENT_DYNAMIC_CLASS(wxListMainWindow,wxScrolledWindow)
2245
2246 BEGIN_EVENT_TABLE(wxListMainWindow,wxScrolledWindow)
2247 EVT_PAINT (wxListMainWindow::OnPaint)
2248 EVT_MOUSE_EVENTS (wxListMainWindow::OnMouse)
2249 EVT_CHAR (wxListMainWindow::OnChar)
2250 EVT_KEY_DOWN (wxListMainWindow::OnKeyDown)
2251 EVT_KEY_UP (wxListMainWindow::OnKeyUp)
2252 EVT_SET_FOCUS (wxListMainWindow::OnSetFocus)
2253 EVT_KILL_FOCUS (wxListMainWindow::OnKillFocus)
2254 EVT_SCROLLWIN (wxListMainWindow::OnScroll)
2255 END_EVENT_TABLE()
2256
2257 void wxListMainWindow::Init()
2258 {
2259 m_dirty = true;
2260 m_countVirt = 0;
2261 m_lineFrom =
2262 m_lineTo = (size_t)-1;
2263 m_linesPerPage = 0;
2264
2265 m_headerWidth =
2266 m_lineHeight = 0;
2267
2268 m_small_image_list = (wxImageList *) NULL;
2269 m_normal_image_list = (wxImageList *) NULL;
2270
2271 m_small_spacing = 30;
2272 m_normal_spacing = 40;
2273
2274 m_hasFocus = false;
2275 m_dragCount = 0;
2276 m_isCreated = false;
2277
2278 m_lastOnSame = false;
2279 m_renameTimer = new wxListRenameTimer( this );
2280 m_textctrlWrapper = NULL;
2281
2282 m_current =
2283 m_lineLastClicked =
2284 m_lineSelectSingleOnUp =
2285 m_lineBeforeLastClicked = (size_t)-1;
2286 }
2287
2288 wxListMainWindow::wxListMainWindow()
2289 {
2290 Init();
2291
2292 m_highlightBrush =
2293 m_highlightUnfocusedBrush = (wxBrush *) NULL;
2294 }
2295
2296 wxListMainWindow::wxListMainWindow( wxWindow *parent,
2297 wxWindowID id,
2298 const wxPoint& pos,
2299 const wxSize& size,
2300 long style,
2301 const wxString &name )
2302 : wxScrolledWindow( parent, id, pos, size,
2303 style | wxHSCROLL | wxVSCROLL, name )
2304 {
2305 Init();
2306
2307 m_highlightBrush = new wxBrush
2308 (
2309 wxSystemSettings::GetColour
2310 (
2311 wxSYS_COLOUR_HIGHLIGHT
2312 ),
2313 wxSOLID
2314 );
2315
2316 m_highlightUnfocusedBrush = new wxBrush
2317 (
2318 wxSystemSettings::GetColour
2319 (
2320 wxSYS_COLOUR_BTNSHADOW
2321 ),
2322 wxSOLID
2323 );
2324
2325 SetScrollbars( 0, 0, 0, 0, 0, 0 );
2326
2327 wxVisualAttributes attr = wxGenericListCtrl::GetClassDefaultAttributes();
2328 SetOwnForegroundColour( attr.colFg );
2329 SetOwnBackgroundColour( attr.colBg );
2330 if (!m_hasFont)
2331 SetOwnFont( attr.font );
2332 }
2333
2334 wxListMainWindow::~wxListMainWindow()
2335 {
2336 DoDeleteAllItems();
2337 WX_CLEAR_LIST(wxListHeaderDataList, m_columns);
2338 WX_CLEAR_ARRAY(m_aColWidths);
2339
2340 delete m_highlightBrush;
2341 delete m_highlightUnfocusedBrush;
2342 delete m_renameTimer;
2343 }
2344
2345 void wxListMainWindow::CacheLineData(size_t line)
2346 {
2347 wxGenericListCtrl *listctrl = GetListCtrl();
2348
2349 wxListLineData *ld = GetDummyLine();
2350
2351 size_t countCol = GetColumnCount();
2352 for ( size_t col = 0; col < countCol; col++ )
2353 {
2354 ld->SetText(col, listctrl->OnGetItemText(line, col));
2355 ld->SetImage(col, listctrl->OnGetItemColumnImage(line, col));
2356 }
2357
2358 ld->SetAttr(listctrl->OnGetItemAttr(line));
2359 }
2360
2361 wxListLineData *wxListMainWindow::GetDummyLine() const
2362 {
2363 wxASSERT_MSG( !IsEmpty(), _T("invalid line index") );
2364 wxASSERT_MSG( IsVirtual(), _T("GetDummyLine() shouldn't be called") );
2365
2366 wxListMainWindow *self = wxConstCast(this, wxListMainWindow);
2367
2368 // we need to recreate the dummy line if the number of columns in the
2369 // control changed as it would have the incorrect number of fields
2370 // otherwise
2371 if ( !m_lines.IsEmpty() &&
2372 m_lines[0].m_items.GetCount() != (size_t)GetColumnCount() )
2373 {
2374 self->m_lines.Clear();
2375 }
2376
2377 if ( m_lines.IsEmpty() )
2378 {
2379 wxListLineData *line = new wxListLineData(self);
2380 self->m_lines.Add(line);
2381
2382 // don't waste extra memory -- there never going to be anything
2383 // else/more in this array
2384 self->m_lines.Shrink();
2385 }
2386
2387 return &m_lines[0];
2388 }
2389
2390 // ----------------------------------------------------------------------------
2391 // line geometry (report mode only)
2392 // ----------------------------------------------------------------------------
2393
2394 wxCoord wxListMainWindow::GetLineHeight() const
2395 {
2396 // we cache the line height as calling GetTextExtent() is slow
2397 if ( !m_lineHeight )
2398 {
2399 wxListMainWindow *self = wxConstCast(this, wxListMainWindow);
2400
2401 wxClientDC dc( self );
2402 dc.SetFont( GetFont() );
2403
2404 wxCoord y;
2405 dc.GetTextExtent(_T("H"), NULL, &y);
2406
2407 if ( m_small_image_list && m_small_image_list->GetImageCount() )
2408 {
2409 int iw = 0, ih = 0;
2410 m_small_image_list->GetSize(0, iw, ih);
2411 y = wxMax(y, ih);
2412 }
2413
2414 y += EXTRA_HEIGHT;
2415 self->m_lineHeight = y + LINE_SPACING;
2416 }
2417
2418 return m_lineHeight;
2419 }
2420
2421 wxCoord wxListMainWindow::GetLineY(size_t line) const
2422 {
2423 wxASSERT_MSG( InReportView(), _T("only works in report mode") );
2424
2425 return LINE_SPACING + line * GetLineHeight();
2426 }
2427
2428 wxRect wxListMainWindow::GetLineRect(size_t line) const
2429 {
2430 if ( !InReportView() )
2431 return GetLine(line)->m_gi->m_rectAll;
2432
2433 wxRect rect;
2434 rect.x = HEADER_OFFSET_X;
2435 rect.y = GetLineY(line);
2436 rect.width = GetHeaderWidth();
2437 rect.height = GetLineHeight();
2438
2439 return rect;
2440 }
2441
2442 wxRect wxListMainWindow::GetLineLabelRect(size_t line) const
2443 {
2444 if ( !InReportView() )
2445 return GetLine(line)->m_gi->m_rectLabel;
2446
2447 int image_x = 0;
2448 wxListLineData *data = GetLine(line);
2449 wxListItemDataList::compatibility_iterator node = data->m_items.GetFirst();
2450 if (node)
2451 {
2452 wxListItemData *item = node->GetData();
2453 if ( item->HasImage() )
2454 {
2455 int ix, iy;
2456 GetImageSize( item->GetImage(), ix, iy );
2457 image_x = 3 + ix + IMAGE_MARGIN_IN_REPORT_MODE;
2458 }
2459 }
2460
2461 wxRect rect;
2462 rect.x = image_x + HEADER_OFFSET_X;
2463 rect.y = GetLineY(line);
2464 rect.width = GetColumnWidth(0) - image_x;
2465 rect.height = GetLineHeight();
2466
2467 return rect;
2468 }
2469
2470 wxRect wxListMainWindow::GetLineIconRect(size_t line) const
2471 {
2472 if ( !InReportView() )
2473 return GetLine(line)->m_gi->m_rectIcon;
2474
2475 wxListLineData *ld = GetLine(line);
2476 wxASSERT_MSG( ld->HasImage(), _T("should have an image") );
2477
2478 wxRect rect;
2479 rect.x = HEADER_OFFSET_X;
2480 rect.y = GetLineY(line);
2481 GetImageSize(ld->GetImage(), rect.width, rect.height);
2482
2483 return rect;
2484 }
2485
2486 wxRect wxListMainWindow::GetLineHighlightRect(size_t line) const
2487 {
2488 return InReportView() ? GetLineRect(line)
2489 : GetLine(line)->m_gi->m_rectHighlight;
2490 }
2491
2492 long wxListMainWindow::HitTestLine(size_t line, int x, int y) const
2493 {
2494 wxASSERT_MSG( line < GetItemCount(), _T("invalid line in HitTestLine") );
2495
2496 wxListLineData *ld = GetLine(line);
2497
2498 if ( ld->HasImage() && GetLineIconRect(line).Contains(x, y) )
2499 return wxLIST_HITTEST_ONITEMICON;
2500
2501 // VS: Testing for "ld->HasText() || InReportView()" instead of
2502 // "ld->HasText()" is needed to make empty lines in report view
2503 // possible
2504 if ( ld->HasText() || InReportView() )
2505 {
2506 wxRect rect = InReportView() ? GetLineRect(line)
2507 : GetLineLabelRect(line);
2508
2509 if ( rect.Contains(x, y) )
2510 return wxLIST_HITTEST_ONITEMLABEL;
2511 }
2512
2513 return 0;
2514 }
2515
2516 // ----------------------------------------------------------------------------
2517 // highlight (selection) handling
2518 // ----------------------------------------------------------------------------
2519
2520 bool wxListMainWindow::IsHighlighted(size_t line) const
2521 {
2522 if ( IsVirtual() )
2523 {
2524 return m_selStore.IsSelected(line);
2525 }
2526 else // !virtual
2527 {
2528 wxListLineData *ld = GetLine(line);
2529 wxCHECK_MSG( ld, false, _T("invalid index in IsHighlighted") );
2530
2531 return ld->IsHighlighted();
2532 }
2533 }
2534
2535 void wxListMainWindow::HighlightLines( size_t lineFrom,
2536 size_t lineTo,
2537 bool highlight )
2538 {
2539 if ( IsVirtual() )
2540 {
2541 wxArrayInt linesChanged;
2542 if ( !m_selStore.SelectRange(lineFrom, lineTo, highlight,
2543 &linesChanged) )
2544 {
2545 // meny items changed state, refresh everything
2546 RefreshLines(lineFrom, lineTo);
2547 }
2548 else // only a few items changed state, refresh only them
2549 {
2550 size_t count = linesChanged.GetCount();
2551 for ( size_t n = 0; n < count; n++ )
2552 {
2553 RefreshLine(linesChanged[n]);
2554 }
2555 }
2556 }
2557 else // iterate over all items in non report view
2558 {
2559 for ( size_t line = lineFrom; line <= lineTo; line++ )
2560 {
2561 if ( HighlightLine(line, highlight) )
2562 RefreshLine(line);
2563 }
2564 }
2565 }
2566
2567 bool wxListMainWindow::HighlightLine( size_t line, bool highlight )
2568 {
2569 bool changed;
2570
2571 if ( IsVirtual() )
2572 {
2573 changed = m_selStore.SelectItem(line, highlight);
2574 }
2575 else // !virtual
2576 {
2577 wxListLineData *ld = GetLine(line);
2578 wxCHECK_MSG( ld, false, _T("invalid index in HighlightLine") );
2579
2580 changed = ld->Highlight(highlight);
2581 }
2582
2583 if ( changed )
2584 {
2585 SendNotify( line, highlight ? wxEVT_COMMAND_LIST_ITEM_SELECTED
2586 : wxEVT_COMMAND_LIST_ITEM_DESELECTED );
2587 }
2588
2589 return changed;
2590 }
2591
2592 void wxListMainWindow::RefreshLine( size_t line )
2593 {
2594 if ( InReportView() )
2595 {
2596 size_t visibleFrom, visibleTo;
2597 GetVisibleLinesRange(&visibleFrom, &visibleTo);
2598
2599 if ( line < visibleFrom || line > visibleTo )
2600 return;
2601 }
2602
2603 wxRect rect = GetLineRect(line);
2604
2605 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
2606 RefreshRect( rect );
2607 }
2608
2609 void wxListMainWindow::RefreshLines( size_t lineFrom, size_t lineTo )
2610 {
2611 // we suppose that they are ordered by caller
2612 wxASSERT_MSG( lineFrom <= lineTo, _T("indices in disorder") );
2613
2614 wxASSERT_MSG( lineTo < GetItemCount(), _T("invalid line range") );
2615
2616 if ( InReportView() )
2617 {
2618 size_t visibleFrom, visibleTo;
2619 GetVisibleLinesRange(&visibleFrom, &visibleTo);
2620
2621 if ( lineFrom < visibleFrom )
2622 lineFrom = visibleFrom;
2623 if ( lineTo > visibleTo )
2624 lineTo = visibleTo;
2625
2626 wxRect rect;
2627 rect.x = 0;
2628 rect.y = GetLineY(lineFrom);
2629 rect.width = GetClientSize().x;
2630 rect.height = GetLineY(lineTo) - rect.y + GetLineHeight();
2631
2632 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
2633 RefreshRect( rect );
2634 }
2635 else // !report
2636 {
2637 // TODO: this should be optimized...
2638 for ( size_t line = lineFrom; line <= lineTo; line++ )
2639 {
2640 RefreshLine(line);
2641 }
2642 }
2643 }
2644
2645 void wxListMainWindow::RefreshAfter( size_t lineFrom )
2646 {
2647 if ( InReportView() )
2648 {
2649 size_t visibleFrom, visibleTo;
2650 GetVisibleLinesRange(&visibleFrom, &visibleTo);
2651
2652 if ( lineFrom < visibleFrom )
2653 lineFrom = visibleFrom;
2654 else if ( lineFrom > visibleTo )
2655 return;
2656
2657 wxRect rect;
2658 rect.x = 0;
2659 rect.y = GetLineY(lineFrom);
2660 CalcScrolledPosition( rect.x, rect.y, &rect.x, &rect.y );
2661
2662 wxSize size = GetClientSize();
2663 rect.width = size.x;
2664
2665 // refresh till the bottom of the window
2666 rect.height = size.y - rect.y;
2667
2668 RefreshRect( rect );
2669 }
2670 else // !report
2671 {
2672 // TODO: how to do it more efficiently?
2673 m_dirty = true;
2674 }
2675 }
2676
2677 void wxListMainWindow::RefreshSelected()
2678 {
2679 if ( IsEmpty() )
2680 return;
2681
2682 size_t from, to;
2683 if ( InReportView() )
2684 {
2685 GetVisibleLinesRange(&from, &to);
2686 }
2687 else // !virtual
2688 {
2689 from = 0;
2690 to = GetItemCount() - 1;
2691 }
2692
2693 if ( HasCurrent() && m_current >= from && m_current <= to )
2694 RefreshLine(m_current);
2695
2696 for ( size_t line = from; line <= to; line++ )
2697 {
2698 // NB: the test works as expected even if m_current == -1
2699 if ( line != m_current && IsHighlighted(line) )
2700 RefreshLine(line);
2701 }
2702 }
2703
2704 void wxListMainWindow::OnPaint( wxPaintEvent &WXUNUSED(event) )
2705 {
2706 // Note: a wxPaintDC must be constructed even if no drawing is
2707 // done (a Windows requirement).
2708 wxPaintDC dc( this );
2709
2710 if ( IsEmpty() || IsFrozen() )
2711 {
2712 // nothing to draw or not the moment to draw it
2713 return;
2714 }
2715
2716 if ( m_dirty )
2717 {
2718 // delay the repainting until we calculate all the items positions
2719 return;
2720 }
2721
2722 PrepareDC( dc );
2723
2724 int dev_x, dev_y;
2725 CalcScrolledPosition( 0, 0, &dev_x, &dev_y );
2726
2727 dc.SetFont( GetFont() );
2728
2729 if ( InReportView() )
2730 {
2731 int lineHeight = GetLineHeight();
2732
2733 size_t visibleFrom, visibleTo;
2734 GetVisibleLinesRange(&visibleFrom, &visibleTo);
2735
2736 wxRect rectLine;
2737 int xOrig = dc.LogicalToDeviceX( 0 );
2738 int yOrig = dc.LogicalToDeviceY( 0 );
2739
2740 // tell the caller cache to cache the data
2741 if ( IsVirtual() )
2742 {
2743 wxListEvent evCache(wxEVT_COMMAND_LIST_CACHE_HINT,
2744 GetParent()->GetId());
2745 evCache.SetEventObject( GetParent() );
2746 evCache.m_oldItemIndex = visibleFrom;
2747 evCache.m_itemIndex = visibleTo;
2748 GetParent()->GetEventHandler()->ProcessEvent( evCache );
2749 }
2750
2751 for ( size_t line = visibleFrom; line <= visibleTo; line++ )
2752 {
2753 rectLine = GetLineRect(line);
2754
2755
2756 if ( !IsExposed(rectLine.x + xOrig, rectLine.y + yOrig,
2757 rectLine.width, rectLine.height) )
2758 {
2759 // don't redraw unaffected lines to avoid flicker
2760 continue;
2761 }
2762
2763 GetLine(line)->DrawInReportMode( &dc,
2764 rectLine,
2765 GetLineHighlightRect(line),
2766 IsHighlighted(line) );
2767 }
2768
2769 if ( HasFlag(wxLC_HRULES) )
2770 {
2771 wxPen pen(GetRuleColour(), 1, wxSOLID);
2772 wxSize clientSize = GetClientSize();
2773
2774 size_t i = visibleFrom;
2775 if (i == 0) i = 1; // Don't draw the first one
2776 for ( ; i <= visibleTo; i++ )
2777 {
2778 dc.SetPen(pen);
2779 dc.SetBrush( *wxTRANSPARENT_BRUSH );
2780 dc.DrawLine(0 - dev_x, i * lineHeight,
2781 clientSize.x - dev_x, i * lineHeight);
2782 }
2783
2784 // Draw last horizontal rule
2785 if ( visibleTo == GetItemCount() - 1 )
2786 {
2787 dc.SetPen( pen );
2788 dc.SetBrush( *wxTRANSPARENT_BRUSH );
2789 dc.DrawLine(0 - dev_x, (m_lineTo + 1) * lineHeight,
2790 clientSize.x - dev_x , (m_lineTo + 1) * lineHeight );
2791 }
2792 }
2793
2794 // Draw vertical rules if required
2795 if ( HasFlag(wxLC_VRULES) && !IsEmpty() )
2796 {
2797 wxPen pen(GetRuleColour(), 1, wxSOLID);
2798 wxRect firstItemRect, lastItemRect;
2799
2800 GetItemRect(visibleFrom, firstItemRect);
2801 GetItemRect(visibleTo, lastItemRect);
2802 int x = firstItemRect.GetX();
2803 dc.SetPen(pen);
2804 dc.SetBrush(* wxTRANSPARENT_BRUSH);
2805
2806 for (int col = 0; col < GetColumnCount(); col++)
2807 {
2808 int colWidth = GetColumnWidth(col);
2809 x += colWidth;
2810 int x_pos = x - dev_x;
2811 if (col < GetColumnCount()-1) x_pos -= 2;
2812 dc.DrawLine(x_pos, firstItemRect.GetY() - 1 - dev_y,
2813 x_pos, lastItemRect.GetBottom() + 1 - dev_y);
2814 }
2815 }
2816 }
2817 else // !report
2818 {
2819 size_t count = GetItemCount();
2820 for ( size_t i = 0; i < count; i++ )
2821 {
2822 GetLine(i)->Draw( &dc );
2823 }
2824 }
2825
2826 #ifndef __WXMAC__
2827 // Don't draw rect outline under Mac at all.
2828 if ( HasCurrent() )
2829 {
2830 if ( m_hasFocus )
2831 {
2832 wxRect rect( GetLineHighlightRect( m_current ) );
2833 #ifndef __WXGTK20__
2834 dc.SetPen( *wxBLACK_PEN );
2835 dc.SetBrush( *wxTRANSPARENT_BRUSH );
2836 dc.DrawRectangle( rect );
2837 #else
2838 wxRendererNative::Get().DrawItemSelectionRect( this, dc, rect, wxCONTROL_CURRENT|wxCONTROL_FOCUSED );
2839
2840 #endif
2841 }
2842 }
2843 #endif
2844 }
2845
2846 void wxListMainWindow::HighlightAll( bool on )
2847 {
2848 if ( IsSingleSel() )
2849 {
2850 wxASSERT_MSG( !on, _T("can't do this in a single selection control") );
2851
2852 // we just have one item to turn off
2853 if ( HasCurrent() && IsHighlighted(m_current) )
2854 {
2855 HighlightLine(m_current, false);
2856 RefreshLine(m_current);
2857 }
2858 }
2859 else // multi selection
2860 {
2861 if ( !IsEmpty() )
2862 HighlightLines(0, GetItemCount() - 1, on);
2863 }
2864 }
2865
2866 void wxListMainWindow::SendNotify( size_t line,
2867 wxEventType command,
2868 const wxPoint& point )
2869 {
2870 wxListEvent le( command, GetParent()->GetId() );
2871 le.SetEventObject( GetParent() );
2872
2873 le.m_itemIndex = line;
2874
2875 // set only for events which have position
2876 if ( point != wxDefaultPosition )
2877 le.m_pointDrag = point;
2878
2879 // don't try to get the line info for virtual list controls: the main
2880 // program has it anyhow and if we did it would result in accessing all
2881 // the lines, even those which are not visible now and this is precisely
2882 // what we're trying to avoid
2883 if ( !IsVirtual() )
2884 {
2885 if ( line != (size_t)-1 )
2886 {
2887 GetLine(line)->GetItem( 0, le.m_item );
2888 }
2889 //else: this happens for wxEVT_COMMAND_LIST_ITEM_FOCUSED event
2890 }
2891 //else: there may be no more such item
2892
2893 GetParent()->GetEventHandler()->ProcessEvent( le );
2894 }
2895
2896 void wxListMainWindow::ChangeCurrent(size_t current)
2897 {
2898 m_current = current;
2899
2900 // as the current item changed, we shouldn't start editing it when the
2901 // "slow click" timer expires as the click happened on another item
2902 if ( m_renameTimer->IsRunning() )
2903 m_renameTimer->Stop();
2904
2905 SendNotify(current, wxEVT_COMMAND_LIST_ITEM_FOCUSED);
2906 }
2907
2908 wxTextCtrl *wxListMainWindow::EditLabel(long item, wxClassInfo* textControlClass)
2909 {
2910 wxCHECK_MSG( (item >= 0) && ((size_t)item < GetItemCount()), NULL,
2911 wxT("wrong index in wxGenericListCtrl::EditLabel()") );
2912
2913 wxASSERT_MSG( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)),
2914 wxT("EditLabel() needs a text control") );
2915
2916 size_t itemEdit = (size_t)item;
2917
2918 wxListEvent le( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT, GetParent()->GetId() );
2919 le.SetEventObject( GetParent() );
2920 le.m_itemIndex = item;
2921 wxListLineData *data = GetLine(itemEdit);
2922 wxCHECK_MSG( data, NULL, _T("invalid index in EditLabel()") );
2923 data->GetItem( 0, le.m_item );
2924
2925 if ( GetParent()->GetEventHandler()->ProcessEvent( le ) && !le.IsAllowed() )
2926 {
2927 // vetoed by user code
2928 return NULL;
2929 }
2930
2931 // We have to call this here because the label in question might just have
2932 // been added and no screen update taken place.
2933 if ( m_dirty )
2934 {
2935 wxSafeYield();
2936
2937 // Pending events dispatched by wxSafeYield might have changed the item
2938 // count
2939 if ( (size_t)item >= GetItemCount() )
2940 return NULL;
2941 }
2942
2943 wxTextCtrl * const text = (wxTextCtrl *)textControlClass->CreateObject();
2944 m_textctrlWrapper = new wxListTextCtrlWrapper(this, text, item);
2945 return m_textctrlWrapper->GetText();
2946 }
2947
2948 void wxListMainWindow::OnRenameTimer()
2949 {
2950 wxCHECK_RET( HasCurrent(), wxT("unexpected rename timer") );
2951
2952 EditLabel( m_current );
2953 }
2954
2955 bool wxListMainWindow::OnRenameAccept(size_t itemEdit, const wxString& value)
2956 {
2957 wxListEvent le( wxEVT_COMMAND_LIST_END_LABEL_EDIT, GetParent()->GetId() );
2958 le.SetEventObject( GetParent() );
2959 le.m_itemIndex = itemEdit;
2960
2961 wxListLineData *data = GetLine(itemEdit);
2962
2963 wxCHECK_MSG( data, false, _T("invalid index in OnRenameAccept()") );
2964
2965 data->GetItem( 0, le.m_item );
2966 le.m_item.m_text = value;
2967 return !GetParent()->GetEventHandler()->ProcessEvent( le ) ||
2968 le.IsAllowed();
2969 }
2970
2971 void wxListMainWindow::OnRenameCancelled(size_t itemEdit)
2972 {
2973 // let owner know that the edit was cancelled
2974 wxListEvent le( wxEVT_COMMAND_LIST_END_LABEL_EDIT, GetParent()->GetId() );
2975
2976 le.SetEditCanceled(true);
2977
2978 le.SetEventObject( GetParent() );
2979 le.m_itemIndex = itemEdit;
2980
2981 wxListLineData *data = GetLine(itemEdit);
2982 wxCHECK_RET( data, _T("invalid index in OnRenameCancelled()") );
2983
2984 data->GetItem( 0, le.m_item );
2985 GetEventHandler()->ProcessEvent( le );
2986 }
2987
2988 void wxListMainWindow::OnMouse( wxMouseEvent &event )
2989 {
2990
2991 #ifdef __WXMAC__
2992 // On wxMac we can't depend on the EVT_KILL_FOCUS event to properly
2993 // shutdown the edit control when the mouse is clicked elsewhere on the
2994 // listctrl because the order of events is different (or something like
2995 // that), so explicitly end the edit if it is active.
2996 if ( event.LeftDown() && m_textctrlWrapper )
2997 m_textctrlWrapper->EndEdit( false );
2998 #endif // __WXMAC__
2999
3000 if ( event.LeftDown() )
3001 SetFocusIgnoringChildren();
3002
3003 event.SetEventObject( GetParent() );
3004 if ( GetParent()->GetEventHandler()->ProcessEvent( event) )
3005 return;
3006
3007 if (event.GetEventType() == wxEVT_MOUSEWHEEL)
3008 {
3009 // let the base handle mouse wheel events.
3010 event.Skip();
3011 return;
3012 }
3013
3014 if ( !HasCurrent() || IsEmpty() )
3015 {
3016 if (event.RightDown())
3017 {
3018 SendNotify( (size_t)-1, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK, event.GetPosition() );
3019
3020 wxContextMenuEvent evtCtx(
3021 wxEVT_CONTEXT_MENU,
3022 GetParent()->GetId(),
3023 ClientToScreen(event.GetPosition()));
3024 evtCtx.SetEventObject(GetParent());
3025 GetParent()->GetEventHandler()->ProcessEvent(evtCtx);
3026 }
3027 return;
3028 }
3029
3030 if (m_dirty)
3031 return;
3032
3033 if ( !(event.Dragging() || event.ButtonDown() || event.LeftUp() ||
3034 event.ButtonDClick()) )
3035 return;
3036
3037 int x = event.GetX();
3038 int y = event.GetY();
3039 CalcUnscrolledPosition( x, y, &x, &y );
3040
3041 // where did we hit it (if we did)?
3042 long hitResult = 0;
3043
3044 size_t count = GetItemCount(),
3045 current;
3046
3047 if ( InReportView() )
3048 {
3049 current = y / GetLineHeight();
3050 if ( current < count )
3051 hitResult = HitTestLine(current, x, y);
3052 }
3053 else // !report
3054 {
3055 // TODO: optimize it too! this is less simple than for report view but
3056 // enumerating all items is still not a way to do it!!
3057 for ( current = 0; current < count; current++ )
3058 {
3059 hitResult = HitTestLine(current, x, y);
3060 if ( hitResult )
3061 break;
3062 }
3063 }
3064
3065 if (event.Dragging())
3066 {
3067 if (m_dragCount == 0)
3068 {
3069 // we have to report the raw, physical coords as we want to be
3070 // able to call HitTest(event.m_pointDrag) from the user code to
3071 // get the item being dragged
3072 m_dragStart = event.GetPosition();
3073 }
3074
3075 m_dragCount++;
3076
3077 if (m_dragCount != 3)
3078 return;
3079
3080 int command = event.RightIsDown() ? wxEVT_COMMAND_LIST_BEGIN_RDRAG
3081 : wxEVT_COMMAND_LIST_BEGIN_DRAG;
3082
3083 wxListEvent le( command, GetParent()->GetId() );
3084 le.SetEventObject( GetParent() );
3085 le.m_itemIndex = m_lineLastClicked;
3086 le.m_pointDrag = m_dragStart;
3087 GetParent()->GetEventHandler()->ProcessEvent( le );
3088
3089 return;
3090 }
3091 else
3092 {
3093 m_dragCount = 0;
3094 }
3095
3096 if ( !hitResult )
3097 {
3098 // outside of any item
3099 if (event.RightDown())
3100 {
3101 SendNotify( (size_t) -1, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK, event.GetPosition() );
3102
3103 wxContextMenuEvent evtCtx(
3104 wxEVT_CONTEXT_MENU,
3105 GetParent()->GetId(),
3106 ClientToScreen(event.GetPosition()));
3107 evtCtx.SetEventObject(GetParent());
3108 GetParent()->GetEventHandler()->ProcessEvent(evtCtx);
3109 }
3110 else
3111 {
3112 // reset the selection and bail out
3113 HighlightAll(false);
3114 }
3115
3116 return;
3117 }
3118
3119 bool forceClick = false;
3120 if (event.ButtonDClick())
3121 {
3122 if ( m_renameTimer->IsRunning() )
3123 m_renameTimer->Stop();
3124
3125 m_lastOnSame = false;
3126
3127 if ( current == m_lineLastClicked )
3128 {
3129 SendNotify( current, wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
3130
3131 return;
3132 }
3133 else
3134 {
3135 // The first click was on another item, so don't interpret this as
3136 // a double click, but as a simple click instead
3137 forceClick = true;
3138 }
3139 }
3140
3141 if (event.LeftUp())
3142 {
3143 if (m_lineSelectSingleOnUp != (size_t)-1)
3144 {
3145 // select single line
3146 HighlightAll( false );
3147 ReverseHighlight(m_lineSelectSingleOnUp);
3148 }
3149
3150 if (m_lastOnSame)
3151 {
3152 if ((current == m_current) &&
3153 (hitResult == wxLIST_HITTEST_ONITEMLABEL) &&
3154 HasFlag(wxLC_EDIT_LABELS) )
3155 {
3156 if ( !InReportView() ||
3157 GetLineLabelRect(current).Contains(x, y) )
3158 {
3159 int dclick = wxSystemSettings::GetMetric(wxSYS_DCLICK_MSEC);
3160 m_renameTimer->Start(dclick > 0 ? dclick : 250, true);
3161 }
3162 }
3163 }
3164
3165 m_lastOnSame = false;
3166 m_lineSelectSingleOnUp = (size_t)-1;
3167 }
3168 else
3169 {
3170 // This is necessary, because after a DnD operation in
3171 // from and to ourself, the up event is swallowed by the
3172 // DnD code. So on next non-up event (which means here and
3173 // now) m_lineSelectSingleOnUp should be reset.
3174 m_lineSelectSingleOnUp = (size_t)-1;
3175 }
3176 if (event.RightDown())
3177 {
3178 m_lineBeforeLastClicked = m_lineLastClicked;
3179 m_lineLastClicked = current;
3180
3181 // If the item is already selected, do not update the selection.
3182 // Multi-selections should not be cleared if a selected item is clicked.
3183 if (!IsHighlighted(current))
3184 {
3185 HighlightAll(false);
3186 ChangeCurrent(current);
3187 ReverseHighlight(m_current);
3188 }
3189
3190 SendNotify( current, wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK, event.GetPosition() );
3191
3192 // Allow generation of context menu event
3193 event.Skip();
3194 }
3195 else if (event.MiddleDown())
3196 {
3197 SendNotify( current, wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK );
3198 }
3199 else if ( event.LeftDown() || forceClick )
3200 {
3201 m_lineBeforeLastClicked = m_lineLastClicked;
3202 m_lineLastClicked = current;
3203
3204 size_t oldCurrent = m_current;
3205 bool oldWasSelected = IsHighlighted(m_current);
3206
3207 bool cmdModifierDown = event.CmdDown();
3208 if ( IsSingleSel() || !(cmdModifierDown || event.ShiftDown()) )
3209 {
3210 if ( IsSingleSel() || !IsHighlighted(current) )
3211 {
3212 HighlightAll( false );
3213
3214 ChangeCurrent(current);
3215
3216 ReverseHighlight(m_current);
3217 }
3218 else // multi sel & current is highlighted & no mod keys
3219 {
3220 m_lineSelectSingleOnUp = current;
3221 ChangeCurrent(current); // change focus
3222 }
3223 }
3224 else // multi sel & either ctrl or shift is down
3225 {
3226 if (cmdModifierDown)
3227 {
3228 ChangeCurrent(current);
3229
3230 ReverseHighlight(m_current);
3231 }
3232 else if (event.ShiftDown())
3233 {
3234 ChangeCurrent(current);
3235
3236 size_t lineFrom = oldCurrent,
3237 lineTo = current;
3238
3239 if ( lineTo < lineFrom )
3240 {
3241 lineTo = lineFrom;
3242 lineFrom = m_current;
3243 }
3244
3245 HighlightLines(lineFrom, lineTo);
3246 }
3247 else // !ctrl, !shift
3248 {
3249 // test in the enclosing if should make it impossible
3250 wxFAIL_MSG( _T("how did we get here?") );
3251 }
3252 }
3253
3254 if (m_current != oldCurrent)
3255 RefreshLine( oldCurrent );
3256
3257 // forceClick is only set if the previous click was on another item
3258 m_lastOnSame = !forceClick && (m_current == oldCurrent) && oldWasSelected;
3259 }
3260 }
3261
3262 void wxListMainWindow::MoveToItem(size_t item)
3263 {
3264 if ( item == (size_t)-1 )
3265 return;
3266
3267 wxRect rect = GetLineRect(item);
3268
3269 int client_w, client_h;
3270 GetClientSize( &client_w, &client_h );
3271
3272 const int hLine = GetLineHeight();
3273
3274 int view_x = SCROLL_UNIT_X * GetScrollPos( wxHORIZONTAL );
3275 int view_y = hLine * GetScrollPos( wxVERTICAL );
3276
3277 if ( InReportView() )
3278 {
3279 // the next we need the range of lines shown it might be different,
3280 // so recalculate it
3281 ResetVisibleLinesRange();
3282
3283 if (rect.y < view_y)
3284 Scroll( -1, rect.y / hLine );
3285 if (rect.y + rect.height + 5 > view_y + client_h)
3286 Scroll( -1, (rect.y + rect.height - client_h + hLine) / hLine );
3287
3288 #ifdef __WXMAC__
3289 // At least on Mac the visible lines value will get reset inside of
3290 // Scroll *before* it actually scrolls the window because of the
3291 // Update() that happens there, so it will still have the wrong value.
3292 // So let's reset it again and wait for it to be recalculated in the
3293 // next paint event. I would expect this problem to show up in wxGTK
3294 // too but couldn't duplicate it there. Perhaps the order of events
3295 // is different... --Robin
3296 ResetVisibleLinesRange();
3297 #endif
3298 }
3299 else // !report
3300 {
3301 int sx = -1,
3302 sy = -1;
3303
3304 if (rect.x-view_x < 5)
3305 sx = (rect.x - 5) / SCROLL_UNIT_X;
3306 if (rect.x + rect.width - 5 > view_x + client_w)
3307 sx = (rect.x + rect.width - client_w + SCROLL_UNIT_X) / SCROLL_UNIT_X;
3308
3309 if (rect.y-view_y < 5)
3310 sy = (rect.y - 5) / hLine;
3311 if (rect.y + rect.height - 5 > view_y + client_h)
3312 sy = (rect.y + rect.height - client_h + hLine) / hLine;
3313
3314 Scroll(sx, sy);
3315 }
3316 }
3317
3318 bool wxListMainWindow::ScrollList(int WXUNUSED(dx), int dy)
3319 {
3320 if ( !InReportView() )
3321 {
3322 // TODO: this should work in all views but is not implemented now
3323 return false;
3324 }
3325
3326 size_t top, bottom;
3327 GetVisibleLinesRange(&top, &bottom);
3328
3329 if ( bottom == (size_t)-1 )
3330 return 0;
3331
3332 ResetVisibleLinesRange();
3333
3334 int hLine = GetLineHeight();
3335
3336 Scroll(-1, top + dy / hLine);
3337
3338 #ifdef __WXMAC__
3339 // see comment in MoveToItem() for why we do this
3340 ResetVisibleLinesRange();
3341 #endif
3342
3343 return true;
3344 }
3345
3346 // ----------------------------------------------------------------------------
3347 // keyboard handling
3348 // ----------------------------------------------------------------------------
3349
3350 void wxListMainWindow::OnArrowChar(size_t newCurrent, const wxKeyEvent& event)
3351 {
3352 wxCHECK_RET( newCurrent < (size_t)GetItemCount(),
3353 _T("invalid item index in OnArrowChar()") );
3354
3355 size_t oldCurrent = m_current;
3356
3357 // in single selection we just ignore Shift as we can't select several
3358 // items anyhow
3359 if ( event.ShiftDown() && !IsSingleSel() )
3360 {
3361 ChangeCurrent(newCurrent);
3362
3363 // refresh the old focus to remove it
3364 RefreshLine( oldCurrent );
3365
3366 // select all the items between the old and the new one
3367 if ( oldCurrent > newCurrent )
3368 {
3369 newCurrent = oldCurrent;
3370 oldCurrent = m_current;
3371 }
3372
3373 HighlightLines(oldCurrent, newCurrent);
3374 }
3375 else // !shift
3376 {
3377 // all previously selected items are unselected unless ctrl is held
3378 // in a multiselection control
3379 if ( !event.ControlDown() || IsSingleSel() )
3380 HighlightAll(false);
3381
3382 ChangeCurrent(newCurrent);
3383
3384 // refresh the old focus to remove it
3385 RefreshLine( oldCurrent );
3386
3387 // in single selection mode we must always have a selected item
3388 if ( !event.ControlDown() || IsSingleSel() )
3389 HighlightLine( m_current, true );
3390 }
3391
3392 RefreshLine( m_current );
3393
3394 MoveToFocus();
3395 }
3396
3397 void wxListMainWindow::OnKeyDown( wxKeyEvent &event )
3398 {
3399 wxWindow *parent = GetParent();
3400
3401 // propagate the key event upwards
3402 wxKeyEvent ke( wxEVT_KEY_DOWN );
3403 ke.m_shiftDown = event.m_shiftDown;
3404 ke.m_controlDown = event.m_controlDown;
3405 ke.m_altDown = event.m_altDown;
3406 ke.m_metaDown = event.m_metaDown;
3407 ke.m_keyCode = event.m_keyCode;
3408 ke.m_x = event.m_x;
3409 ke.m_y = event.m_y;
3410 ke.SetEventObject( parent );
3411 if (parent->GetEventHandler()->ProcessEvent( ke )) return;
3412
3413 event.Skip();
3414 }
3415
3416 void wxListMainWindow::OnKeyUp( wxKeyEvent &event )
3417 {
3418 wxWindow *parent = GetParent();
3419
3420 // propagate the key event upwards
3421 wxKeyEvent ke( wxEVT_KEY_UP );
3422 ke.m_shiftDown = event.m_shiftDown;
3423 ke.m_controlDown = event.m_controlDown;
3424 ke.m_altDown = event.m_altDown;
3425 ke.m_metaDown = event.m_metaDown;
3426 ke.m_keyCode = event.m_keyCode;
3427 ke.m_x = event.m_x;
3428 ke.m_y = event.m_y;
3429 ke.SetEventObject( parent );
3430 if (parent->GetEventHandler()->ProcessEvent( ke )) return;
3431
3432 event.Skip();
3433 }
3434
3435 void wxListMainWindow::OnChar( wxKeyEvent &event )
3436 {
3437 wxWindow *parent = GetParent();
3438
3439 // send a list_key event up
3440 if ( HasCurrent() )
3441 {
3442 wxListEvent le( wxEVT_COMMAND_LIST_KEY_DOWN, GetParent()->GetId() );
3443 le.m_itemIndex = m_current;
3444 GetLine(m_current)->GetItem( 0, le.m_item );
3445 le.m_code = event.GetKeyCode();
3446 le.SetEventObject( parent );
3447 parent->GetEventHandler()->ProcessEvent( le );
3448 }
3449
3450 // propagate the char event upwards
3451 wxKeyEvent ke( wxEVT_CHAR );
3452 ke.m_shiftDown = event.m_shiftDown;
3453 ke.m_controlDown = event.m_controlDown;
3454 ke.m_altDown = event.m_altDown;
3455 ke.m_metaDown = event.m_metaDown;
3456 ke.m_keyCode = event.m_keyCode;
3457 ke.m_x = event.m_x;
3458 ke.m_y = event.m_y;
3459 ke.SetEventObject( parent );
3460 if (parent->GetEventHandler()->ProcessEvent( ke )) return;
3461
3462 if ( HandleAsNavigationKey(event) )
3463 return;
3464
3465 // no item -> nothing to do
3466 if (!HasCurrent())
3467 {
3468 event.Skip();
3469 return;
3470 }
3471
3472 // don't use m_linesPerPage directly as it might not be computed yet
3473 const int pageSize = GetCountPerPage();
3474 wxCHECK_RET( pageSize, _T("should have non zero page size") );
3475
3476 if (GetLayoutDirection() == wxLayout_RightToLeft)
3477 {
3478 if (event.GetKeyCode() == WXK_RIGHT)
3479 event.m_keyCode = WXK_LEFT;
3480 else if (event.GetKeyCode() == WXK_LEFT)
3481 event.m_keyCode = WXK_RIGHT;
3482 }
3483
3484 switch ( event.GetKeyCode() )
3485 {
3486 case WXK_UP:
3487 if ( m_current > 0 )
3488 OnArrowChar( m_current - 1, event );
3489 break;
3490
3491 case WXK_DOWN:
3492 if ( m_current < (size_t)GetItemCount() - 1 )
3493 OnArrowChar( m_current + 1, event );
3494 break;
3495
3496 case WXK_END:
3497 if (!IsEmpty())
3498 OnArrowChar( GetItemCount() - 1, event );
3499 break;
3500
3501 case WXK_HOME:
3502 if (!IsEmpty())
3503 OnArrowChar( 0, event );
3504 break;
3505
3506 case WXK_PAGEUP:
3507 {
3508 int steps = InReportView() ? pageSize - 1
3509 : m_current % pageSize;
3510
3511 int index = m_current - steps;
3512 if (index < 0)
3513 index = 0;
3514
3515 OnArrowChar( index, event );
3516 }
3517 break;
3518
3519 case WXK_PAGEDOWN:
3520 {
3521 int steps = InReportView()
3522 ? pageSize - 1
3523 : pageSize - (m_current % pageSize) - 1;
3524
3525 size_t index = m_current + steps;
3526 size_t count = GetItemCount();
3527 if ( index >= count )
3528 index = count - 1;
3529
3530 OnArrowChar( index, event );
3531 }
3532 break;
3533
3534 case WXK_LEFT:
3535 if ( !InReportView() )
3536 {
3537 int index = m_current - pageSize;
3538 if (index < 0)
3539 index = 0;
3540
3541 OnArrowChar( index, event );
3542 }
3543 break;
3544
3545 case WXK_RIGHT:
3546 if ( !InReportView() )
3547 {
3548 size_t index = m_current + pageSize;
3549
3550 size_t count = GetItemCount();
3551 if ( index >= count )
3552 index = count - 1;
3553
3554 OnArrowChar( index, event );
3555 }
3556 break;
3557
3558 case WXK_SPACE:
3559 if ( IsSingleSel() )
3560 {
3561 if ( event.ControlDown() )
3562 {
3563 ReverseHighlight(m_current);
3564 }
3565 else // normal space press
3566 {
3567 SendNotify( m_current, wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
3568 }
3569 }
3570 else // multiple selection
3571 {
3572 ReverseHighlight(m_current);
3573 }
3574 break;
3575
3576 case WXK_RETURN:
3577 case WXK_EXECUTE:
3578 SendNotify( m_current, wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
3579 break;
3580
3581 default:
3582 event.Skip();
3583 }
3584 }
3585
3586 // ----------------------------------------------------------------------------
3587 // focus handling
3588 // ----------------------------------------------------------------------------
3589
3590 void wxListMainWindow::OnSetFocus( wxFocusEvent &WXUNUSED(event) )
3591 {
3592 if ( GetParent() )
3593 {
3594 wxFocusEvent event( wxEVT_SET_FOCUS, GetParent()->GetId() );
3595 event.SetEventObject( GetParent() );
3596 if ( GetParent()->GetEventHandler()->ProcessEvent( event) )
3597 return;
3598 }
3599
3600 // wxGTK sends us EVT_SET_FOCUS events even if we had never got
3601 // EVT_KILL_FOCUS before which means that we finish by redrawing the items
3602 // which are already drawn correctly resulting in horrible flicker - avoid
3603 // it
3604 if ( !m_hasFocus )
3605 {
3606 m_hasFocus = true;
3607
3608 RefreshSelected();
3609 }
3610 }
3611
3612 void wxListMainWindow::OnKillFocus( wxFocusEvent &WXUNUSED(event) )
3613 {
3614 if ( GetParent() )
3615 {
3616 wxFocusEvent event( wxEVT_KILL_FOCUS, GetParent()->GetId() );
3617 event.SetEventObject( GetParent() );
3618 if ( GetParent()->GetEventHandler()->ProcessEvent( event) )
3619 return;
3620 }
3621
3622 m_hasFocus = false;
3623 RefreshSelected();
3624 }
3625
3626 void wxListMainWindow::DrawImage( int index, wxDC *dc, int x, int y )
3627 {
3628 if ( HasFlag(wxLC_ICON) && (m_normal_image_list))
3629 {
3630 m_normal_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
3631 }
3632 else if ( HasFlag(wxLC_SMALL_ICON) && (m_small_image_list))
3633 {
3634 m_small_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
3635 }
3636 else if ( HasFlag(wxLC_LIST) && (m_small_image_list))
3637 {
3638 m_small_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
3639 }
3640 else if ( InReportView() && (m_small_image_list))
3641 {
3642 m_small_image_list->Draw( index, *dc, x, y, wxIMAGELIST_DRAW_TRANSPARENT );
3643 }
3644 }
3645
3646 void wxListMainWindow::GetImageSize( int index, int &width, int &height ) const
3647 {
3648 if ( HasFlag(wxLC_ICON) && m_normal_image_list )
3649 {
3650 m_normal_image_list->GetSize( index, width, height );
3651 }
3652 else if ( HasFlag(wxLC_SMALL_ICON) && m_small_image_list )
3653 {
3654 m_small_image_list->GetSize( index, width, height );
3655 }
3656 else if ( HasFlag(wxLC_LIST) && m_small_image_list )
3657 {
3658 m_small_image_list->GetSize( index, width, height );
3659 }
3660 else if ( InReportView() && m_small_image_list )
3661 {
3662 m_small_image_list->GetSize( index, width, height );
3663 }
3664 else
3665 {
3666 width =
3667 height = 0;
3668 }
3669 }
3670
3671 int wxListMainWindow::GetTextLength( const wxString &s ) const
3672 {
3673 wxClientDC dc( wxConstCast(this, wxListMainWindow) );
3674 dc.SetFont( GetFont() );
3675
3676 wxCoord lw;
3677 dc.GetTextExtent( s, &lw, NULL );
3678
3679 return lw + AUTOSIZE_COL_MARGIN;
3680 }
3681
3682 void wxListMainWindow::SetImageList( wxImageList *imageList, int which )
3683 {
3684 m_dirty = true;
3685
3686 // calc the spacing from the icon size
3687 int width = 0, height = 0;
3688
3689 if ((imageList) && (imageList->GetImageCount()) )
3690 imageList->GetSize(0, width, height);
3691
3692 if (which == wxIMAGE_LIST_NORMAL)
3693 {
3694 m_normal_image_list = imageList;
3695 m_normal_spacing = width + 8;
3696 }
3697
3698 if (which == wxIMAGE_LIST_SMALL)
3699 {
3700 m_small_image_list = imageList;
3701 m_small_spacing = width + 14;
3702 m_lineHeight = 0; // ensure that the line height will be recalc'd
3703 }
3704 }
3705
3706 void wxListMainWindow::SetItemSpacing( int spacing, bool isSmall )
3707 {
3708 m_dirty = true;
3709 if (isSmall)
3710 m_small_spacing = spacing;
3711 else
3712 m_normal_spacing = spacing;
3713 }
3714
3715 int wxListMainWindow::GetItemSpacing( bool isSmall )
3716 {
3717 return isSmall ? m_small_spacing : m_normal_spacing;
3718 }
3719
3720 // ----------------------------------------------------------------------------
3721 // columns
3722 // ----------------------------------------------------------------------------
3723
3724 void wxListMainWindow::SetColumn( int col, wxListItem &item )
3725 {
3726 wxListHeaderDataList::compatibility_iterator node = m_columns.Item( col );
3727
3728 wxCHECK_RET( node, _T("invalid column index in SetColumn") );
3729
3730 if ( item.m_width == wxLIST_AUTOSIZE_USEHEADER )
3731 item.m_width = GetTextLength( item.m_text );
3732
3733 wxListHeaderData *column = node->GetData();
3734 column->SetItem( item );
3735
3736 wxListHeaderWindow *headerWin = GetListCtrl()->m_headerWin;
3737 if ( headerWin )
3738 headerWin->m_dirty = true;
3739
3740 m_dirty = true;
3741
3742 // invalidate it as it has to be recalculated
3743 m_headerWidth = 0;
3744 }
3745
3746 void wxListMainWindow::SetColumnWidth( int col, int width )
3747 {
3748 wxCHECK_RET( col >= 0 && col < GetColumnCount(),
3749 _T("invalid column index") );
3750
3751 wxCHECK_RET( InReportView(),
3752 _T("SetColumnWidth() can only be called in report mode.") );
3753
3754 m_dirty = true;
3755 wxListHeaderWindow *headerWin = GetListCtrl()->m_headerWin;
3756 if ( headerWin )
3757 headerWin->m_dirty = true;
3758
3759 wxListHeaderDataList::compatibility_iterator node = m_columns.Item( col );
3760 wxCHECK_RET( node, _T("no column?") );
3761
3762 wxListHeaderData *column = node->GetData();
3763
3764 size_t count = GetItemCount();
3765
3766 if (width == wxLIST_AUTOSIZE_USEHEADER)
3767 {
3768 width = GetTextLength(column->GetText());
3769 width += 2*EXTRA_WIDTH;
3770
3771 // check for column header's image availability
3772 const int image = column->GetImage();
3773 if ( image != -1 )
3774 {
3775 if ( m_small_image_list )
3776 {
3777 int ix = 0, iy = 0;
3778 m_small_image_list->GetSize(image, ix, iy);
3779 width += ix + HEADER_IMAGE_MARGIN_IN_REPORT_MODE;
3780 }
3781 }
3782 }
3783 else if ( width == wxLIST_AUTOSIZE )
3784 {
3785 if ( IsVirtual() )
3786 {
3787 // TODO: determine the max width somehow...
3788 width = WIDTH_COL_DEFAULT;
3789 }
3790 else // !virtual
3791 {
3792 wxClientDC dc(this);
3793 dc.SetFont( GetFont() );
3794
3795 int max = AUTOSIZE_COL_MARGIN;
3796
3797 // if the cached column width isn't valid then recalculate it
3798 if (m_aColWidths.Item(col)->bNeedsUpdate)
3799 {
3800 for (size_t i = 0; i < count; i++)
3801 {
3802 wxListLineData *line = GetLine( i );
3803 wxListItemDataList::compatibility_iterator n = line->m_items.Item( col );
3804
3805 wxCHECK_RET( n, _T("no subitem?") );
3806
3807 wxListItemData *itemData = n->GetData();
3808 wxListItem item;
3809
3810 itemData->GetItem(item);
3811 int itemWidth = GetItemWidthWithImage(&item);
3812 if (itemWidth > max)
3813 max = itemWidth;
3814 }
3815
3816 m_aColWidths.Item(col)->bNeedsUpdate = false;
3817 m_aColWidths.Item(col)->nMaxWidth = max;
3818 }
3819
3820 max = m_aColWidths.Item(col)->nMaxWidth;
3821 width = max + AUTOSIZE_COL_MARGIN;
3822 }
3823 }
3824
3825 column->SetWidth( width );
3826
3827 // invalidate it as it has to be recalculated
3828 m_headerWidth = 0;
3829 }
3830
3831 int wxListMainWindow::GetHeaderWidth() const
3832 {
3833 if ( !m_headerWidth )
3834 {
3835 wxListMainWindow *self = wxConstCast(this, wxListMainWindow);
3836
3837 size_t count = GetColumnCount();
3838 for ( size_t col = 0; col < count; col++ )
3839 {
3840 self->m_headerWidth += GetColumnWidth(col);
3841 }
3842 }
3843
3844 return m_headerWidth;
3845 }
3846
3847 void wxListMainWindow::GetColumn( int col, wxListItem &item ) const
3848 {
3849 wxListHeaderDataList::compatibility_iterator node = m_columns.Item( col );
3850 wxCHECK_RET( node, _T("invalid column index in GetColumn") );
3851
3852 wxListHeaderData *column = node->GetData();
3853 column->GetItem( item );
3854 }
3855
3856 int wxListMainWindow::GetColumnWidth( int col ) const
3857 {
3858 wxListHeaderDataList::compatibility_iterator node = m_columns.Item( col );
3859 wxCHECK_MSG( node, 0, _T("invalid column index") );
3860
3861 wxListHeaderData *column = node->GetData();
3862 return column->GetWidth();
3863 }
3864
3865 // ----------------------------------------------------------------------------
3866 // item state
3867 // ----------------------------------------------------------------------------
3868
3869 void wxListMainWindow::SetItem( wxListItem &item )
3870 {
3871 long id = item.m_itemId;
3872 wxCHECK_RET( id >= 0 && (size_t)id < GetItemCount(),
3873 _T("invalid item index in SetItem") );
3874
3875 if ( !IsVirtual() )
3876 {
3877 wxListLineData *line = GetLine((size_t)id);
3878 line->SetItem( item.m_col, item );
3879
3880 // Set item state if user wants
3881 if ( item.m_mask & wxLIST_MASK_STATE )
3882 SetItemState( item.m_itemId, item.m_state, item.m_state );
3883
3884 if (InReportView())
3885 {
3886 // update the Max Width Cache if needed
3887 int width = GetItemWidthWithImage(&item);
3888
3889 if (width > m_aColWidths.Item(item.m_col)->nMaxWidth)
3890 m_aColWidths.Item(item.m_col)->nMaxWidth = width;
3891 }
3892 }
3893
3894 // update the item on screen
3895 wxRect rectItem;
3896 GetItemRect(id, rectItem);
3897 RefreshRect(rectItem);
3898 }
3899
3900 void wxListMainWindow::SetItemStateAll(long state, long stateMask)
3901 {
3902 if ( IsEmpty() )
3903 return;
3904
3905 // first deal with selection
3906 if ( stateMask & wxLIST_STATE_SELECTED )
3907 {
3908 // set/clear select state
3909 if ( IsVirtual() )
3910 {
3911 // optimized version for virtual listctrl.
3912 m_selStore.SelectRange(0, GetItemCount() - 1, state == wxLIST_STATE_SELECTED);
3913 Refresh();
3914 }
3915 else if ( state & wxLIST_STATE_SELECTED )
3916 {
3917 const long count = GetItemCount();
3918 for( long i = 0; i < count; i++ )
3919 {
3920 SetItemState( i, wxLIST_STATE_SELECTED, wxLIST_STATE_SELECTED );
3921 }
3922
3923 }
3924 else
3925 {
3926 // clear for non virtual (somewhat optimized by using GetNextItem())
3927 long i = -1;
3928 while ( (i = GetNextItem(i, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED)) != -1 )
3929 {
3930 SetItemState( i, 0, wxLIST_STATE_SELECTED );
3931 }
3932 }
3933 }
3934
3935 if ( HasCurrent() && (state == 0) && (stateMask & wxLIST_STATE_FOCUSED) )
3936 {
3937 // unfocus all: only one item can be focussed, so clearing focus for
3938 // all items is simply clearing focus of the focussed item.
3939 SetItemState(m_current, state, stateMask);
3940 }
3941 //(setting focus to all items makes no sense, so it is not handled here.)
3942 }
3943
3944 void wxListMainWindow::SetItemState( long litem, long state, long stateMask )
3945 {
3946 if ( litem == -1 )
3947 {
3948 SetItemStateAll(state, stateMask);
3949 return;
3950 }
3951
3952 wxCHECK_RET( litem >= 0 && (size_t)litem < GetItemCount(),
3953 _T("invalid list ctrl item index in SetItem") );
3954
3955 size_t oldCurrent = m_current;
3956 size_t item = (size_t)litem; // safe because of the check above
3957
3958 // do we need to change the focus?
3959 if ( stateMask & wxLIST_STATE_FOCUSED )
3960 {
3961 if ( state & wxLIST_STATE_FOCUSED )
3962 {
3963 // don't do anything if this item is already focused
3964 if ( item != m_current )
3965 {
3966 ChangeCurrent(item);
3967
3968 if ( oldCurrent != (size_t)-1 )
3969 {
3970 if ( IsSingleSel() )
3971 {
3972 HighlightLine(oldCurrent, false);
3973 }
3974
3975 RefreshLine(oldCurrent);
3976 }
3977
3978 RefreshLine( m_current );
3979 }
3980 }
3981 else // unfocus
3982 {
3983 // don't do anything if this item is not focused
3984 if ( item == m_current )
3985 {
3986 ResetCurrent();
3987
3988 if ( IsSingleSel() )
3989 {
3990 // we must unselect the old current item as well or we
3991 // might end up with more than one selected item in a
3992 // single selection control
3993 HighlightLine(oldCurrent, false);
3994 }
3995
3996 RefreshLine( oldCurrent );
3997 }
3998 }
3999 }
4000
4001 // do we need to change the selection state?
4002 if ( stateMask & wxLIST_STATE_SELECTED )
4003 {
4004 bool on = (state & wxLIST_STATE_SELECTED) != 0;
4005
4006 if ( IsSingleSel() )
4007 {
4008 if ( on )
4009 {
4010 // selecting the item also makes it the focused one in the
4011 // single sel mode
4012 if ( m_current != item )
4013 {
4014 ChangeCurrent(item);
4015
4016 if ( oldCurrent != (size_t)-1 )
4017 {
4018 HighlightLine( oldCurrent, false );
4019 RefreshLine( oldCurrent );
4020 }
4021 }
4022 }
4023 else // off
4024 {
4025 // only the current item may be selected anyhow
4026 if ( item != m_current )
4027 return;
4028 }
4029 }
4030
4031 if ( HighlightLine(item, on) )
4032 {
4033 RefreshLine(item);
4034 }
4035 }
4036 }
4037
4038 int wxListMainWindow::GetItemState( long item, long stateMask ) const
4039 {
4040 wxCHECK_MSG( item >= 0 && (size_t)item < GetItemCount(), 0,
4041 _T("invalid list ctrl item index in GetItemState()") );
4042
4043 int ret = wxLIST_STATE_DONTCARE;
4044
4045 if ( stateMask & wxLIST_STATE_FOCUSED )
4046 {
4047 if ( (size_t)item == m_current )
4048 ret |= wxLIST_STATE_FOCUSED;
4049 }
4050
4051 if ( stateMask & wxLIST_STATE_SELECTED )
4052 {
4053 if ( IsHighlighted(item) )
4054 ret |= wxLIST_STATE_SELECTED;
4055 }
4056
4057 return ret;
4058 }
4059
4060 void wxListMainWindow::GetItem( wxListItem &item ) const
4061 {
4062 wxCHECK_RET( item.m_itemId >= 0 && (size_t)item.m_itemId < GetItemCount(),
4063 _T("invalid item index in GetItem") );
4064
4065 wxListLineData *line = GetLine((size_t)item.m_itemId);
4066 line->GetItem( item.m_col, item );
4067
4068 // Get item state if user wants it
4069 if ( item.m_mask & wxLIST_MASK_STATE )
4070 item.m_state = GetItemState( item.m_itemId, wxLIST_STATE_SELECTED |
4071 wxLIST_STATE_FOCUSED );
4072 }
4073
4074 // ----------------------------------------------------------------------------
4075 // item count
4076 // ----------------------------------------------------------------------------
4077
4078 size_t wxListMainWindow::GetItemCount() const
4079 {
4080 return IsVirtual() ? m_countVirt : m_lines.GetCount();
4081 }
4082
4083 void wxListMainWindow::SetItemCount(long count)
4084 {
4085 m_selStore.SetItemCount(count);
4086 m_countVirt = count;
4087
4088 ResetVisibleLinesRange();
4089
4090 // scrollbars must be reset
4091 m_dirty = true;
4092 }
4093
4094 int wxListMainWindow::GetSelectedItemCount() const
4095 {
4096 // deal with the quick case first
4097 if ( IsSingleSel() )
4098 return HasCurrent() ? IsHighlighted(m_current) : false;
4099
4100 // virtual controls remmebers all its selections itself
4101 if ( IsVirtual() )
4102 return m_selStore.GetSelectedCount();
4103
4104 // TODO: we probably should maintain the number of items selected even for
4105 // non virtual controls as enumerating all lines is really slow...
4106 size_t countSel = 0;
4107 size_t count = GetItemCount();
4108 for ( size_t line = 0; line < count; line++ )
4109 {
4110 if ( GetLine(line)->IsHighlighted() )
4111 countSel++;
4112 }
4113
4114 return countSel;
4115 }
4116
4117 // ----------------------------------------------------------------------------
4118 // item position/size
4119 // ----------------------------------------------------------------------------
4120
4121 wxRect wxListMainWindow::GetViewRect() const
4122 {
4123 wxASSERT_MSG( !HasFlag(wxLC_REPORT | wxLC_LIST),
4124 _T("wxListCtrl::GetViewRect() only works in icon mode") );
4125
4126 // we need to find the longest/tallest label
4127 wxCoord xMax = 0, yMax = 0;
4128 const int count = GetItemCount();
4129 if ( count )
4130 {
4131 for ( int i = 0; i < count; i++ )
4132 {
4133 wxRect r;
4134 GetItemRect(i, r);
4135
4136 wxCoord x = r.GetRight(),
4137 y = r.GetBottom();
4138
4139 if ( x > xMax )
4140 xMax = x;
4141 if ( y > yMax )
4142 yMax = y;
4143 }
4144 }
4145
4146 // some fudge needed to make it look prettier
4147 xMax += 2 * EXTRA_BORDER_X;
4148 yMax += 2 * EXTRA_BORDER_Y;
4149
4150 // account for the scrollbars if necessary
4151 const wxSize sizeAll = GetClientSize();
4152 if ( xMax > sizeAll.x )
4153 yMax += wxSystemSettings::GetMetric(wxSYS_HSCROLL_Y);
4154 if ( yMax > sizeAll.y )
4155 xMax += wxSystemSettings::GetMetric(wxSYS_VSCROLL_X);
4156
4157 return wxRect(0, 0, xMax, yMax);
4158 }
4159
4160 void wxListMainWindow::GetItemRect( long index, wxRect &rect ) const
4161 {
4162 wxCHECK_RET( index >= 0 && (size_t)index < GetItemCount(),
4163 _T("invalid index in GetItemRect") );
4164
4165 // ensure that we're laid out, otherwise we could return nonsense
4166 if ( m_dirty )
4167 {
4168 wxConstCast(this, wxListMainWindow)->
4169 RecalculatePositions(true /* no refresh */);
4170 }
4171
4172 rect = GetLineRect((size_t)index);
4173
4174 CalcScrolledPosition(rect.x, rect.y, &rect.x, &rect.y);
4175 }
4176
4177 bool wxListMainWindow::GetItemPosition(long item, wxPoint& pos) const
4178 {
4179 wxRect rect;
4180 GetItemRect(item, rect);
4181
4182 pos.x = rect.x;
4183 pos.y = rect.y;
4184
4185 return true;
4186 }
4187
4188 // ----------------------------------------------------------------------------
4189 // geometry calculation
4190 // ----------------------------------------------------------------------------
4191
4192 void wxListMainWindow::RecalculatePositions(bool noRefresh)
4193 {
4194 const int lineHeight = GetLineHeight();
4195
4196 wxClientDC dc( this );
4197 dc.SetFont( GetFont() );
4198
4199 const size_t count = GetItemCount();
4200
4201 int iconSpacing;
4202 if ( HasFlag(wxLC_ICON) )
4203 iconSpacing = m_normal_spacing;
4204 else if ( HasFlag(wxLC_SMALL_ICON) )
4205 iconSpacing = m_small_spacing;
4206 else
4207 iconSpacing = 0;
4208
4209 // Note that we do not call GetClientSize() here but
4210 // GetSize() and subtract the border size for sunken
4211 // borders manually. This is technically incorrect,
4212 // but we need to know the client area's size WITHOUT
4213 // scrollbars here. Since we don't know if there are
4214 // any scrollbars, we use GetSize() instead. Another
4215 // solution would be to call SetScrollbars() here to
4216 // remove the scrollbars and call GetClientSize() then,
4217 // but this might result in flicker and - worse - will
4218 // reset the scrollbars to 0 which is not good at all
4219 // if you resize a dialog/window, but don't want to
4220 // reset the window scrolling. RR.
4221 // Furthermore, we actually do NOT subtract the border
4222 // width as 2 pixels is just the extra space which we
4223 // need around the actual content in the window. Other-
4224 // wise the text would e.g. touch the upper border. RR.
4225 int clientWidth,
4226 clientHeight;
4227 GetSize( &clientWidth, &clientHeight );
4228
4229 if ( InReportView() )
4230 {
4231 // all lines have the same height and we scroll one line per step
4232 int entireHeight = count * lineHeight + LINE_SPACING;
4233
4234 m_linesPerPage = clientHeight / lineHeight;
4235
4236 ResetVisibleLinesRange();
4237
4238 SetScrollbars( SCROLL_UNIT_X, lineHeight,
4239 GetHeaderWidth() / SCROLL_UNIT_X,
4240 (entireHeight + lineHeight - 1) / lineHeight,
4241 GetScrollPos(wxHORIZONTAL),
4242 GetScrollPos(wxVERTICAL),
4243 true );
4244 }
4245 else // !report
4246 {
4247 // we have 3 different layout strategies: either layout all items
4248 // horizontally/vertically (wxLC_ALIGN_XXX styles explicitly given) or
4249 // to arrange them in top to bottom, left to right (don't ask me why
4250 // not the other way round...) order
4251 if ( HasFlag(wxLC_ALIGN_LEFT | wxLC_ALIGN_TOP) )
4252 {
4253 int x = EXTRA_BORDER_X;
4254 int y = EXTRA_BORDER_Y;
4255
4256 wxCoord widthMax = 0;
4257
4258 size_t i;
4259 for ( i = 0; i < count; i++ )
4260 {
4261 wxListLineData *line = GetLine(i);
4262 line->CalculateSize( &dc, iconSpacing );
4263 line->SetPosition( x, y, iconSpacing );
4264
4265 wxSize sizeLine = GetLineSize(i);
4266
4267 if ( HasFlag(wxLC_ALIGN_TOP) )
4268 {
4269 if ( sizeLine.x > widthMax )
4270 widthMax = sizeLine.x;
4271
4272 y += sizeLine.y;
4273 }
4274 else // wxLC_ALIGN_LEFT
4275 {
4276 x += sizeLine.x + MARGIN_BETWEEN_ROWS;
4277 }
4278 }
4279
4280 if ( HasFlag(wxLC_ALIGN_TOP) )
4281 {
4282 // traverse the items again and tweak their sizes so that they are
4283 // all the same in a row
4284 for ( i = 0; i < count; i++ )
4285 {
4286 wxListLineData *line = GetLine(i);
4287 line->m_gi->ExtendWidth(widthMax);
4288 }
4289 }
4290
4291 SetScrollbars
4292 (
4293 SCROLL_UNIT_X,
4294 lineHeight,
4295 (x + SCROLL_UNIT_X) / SCROLL_UNIT_X,
4296 (y + lineHeight) / lineHeight,
4297 GetScrollPos( wxHORIZONTAL ),
4298 GetScrollPos( wxVERTICAL ),
4299 true
4300 );
4301 }
4302 else // "flowed" arrangement, the most complicated case
4303 {
4304 // at first we try without any scrollbars, if the items don't fit into
4305 // the window, we recalculate after subtracting the space taken by the
4306 // scrollbar
4307
4308 int entireWidth = 0;
4309
4310 for (int tries = 0; tries < 2; tries++)
4311 {
4312 entireWidth = 2 * EXTRA_BORDER_X;
4313
4314 if (tries == 1)
4315 {
4316 // Now we have decided that the items do not fit into the
4317 // client area, so we need a scrollbar
4318 entireWidth += SCROLL_UNIT_X;
4319 }
4320
4321 int x = EXTRA_BORDER_X;
4322 int y = EXTRA_BORDER_Y;
4323 int maxWidthInThisRow = 0;
4324
4325 m_linesPerPage = 0;
4326 int currentlyVisibleLines = 0;
4327
4328 for (size_t i = 0; i < count; i++)
4329 {
4330 currentlyVisibleLines++;
4331 wxListLineData *line = GetLine( i );
4332 line->CalculateSize( &dc, iconSpacing );
4333 line->SetPosition( x, y, iconSpacing );
4334
4335 wxSize sizeLine = GetLineSize( i );
4336
4337 if ( maxWidthInThisRow < sizeLine.x )
4338 maxWidthInThisRow = sizeLine.x;
4339
4340 y += sizeLine.y;
4341 if (currentlyVisibleLines > m_linesPerPage)
4342 m_linesPerPage = currentlyVisibleLines;
4343
4344 if ( y + sizeLine.y >= clientHeight )
4345 {
4346 currentlyVisibleLines = 0;
4347 y = EXTRA_BORDER_Y;
4348 maxWidthInThisRow += MARGIN_BETWEEN_ROWS;
4349 x += maxWidthInThisRow;
4350 entireWidth += maxWidthInThisRow;
4351 maxWidthInThisRow = 0;
4352 }
4353
4354 // We have reached the last item.
4355 if ( i == count - 1 )
4356 entireWidth += maxWidthInThisRow;
4357
4358 if ( (tries == 0) &&
4359 (entireWidth + SCROLL_UNIT_X > clientWidth) )
4360 {
4361 clientHeight -= wxSystemSettings::
4362 GetMetric(wxSYS_HSCROLL_Y);
4363 m_linesPerPage = 0;
4364 break;
4365 }
4366
4367 if ( i == count - 1 )
4368 tries = 1; // Everything fits, no second try required.
4369 }
4370 }
4371
4372 SetScrollbars
4373 (
4374 SCROLL_UNIT_X,
4375 lineHeight,
4376 (entireWidth + SCROLL_UNIT_X) / SCROLL_UNIT_X,
4377 0,
4378 GetScrollPos( wxHORIZONTAL ),
4379 0,
4380 true
4381 );
4382 }
4383 }
4384
4385 if ( !noRefresh )
4386 {
4387 // FIXME: why should we call it from here?
4388 UpdateCurrent();
4389
4390 RefreshAll();
4391 }
4392 }
4393
4394 void wxListMainWindow::RefreshAll()
4395 {
4396 m_dirty = false;
4397 Refresh();
4398
4399 wxListHeaderWindow *headerWin = GetListCtrl()->m_headerWin;
4400 if ( headerWin && headerWin->m_dirty )
4401 {
4402 headerWin->m_dirty = false;
4403 headerWin->Refresh();
4404 }
4405 }
4406
4407 void wxListMainWindow::UpdateCurrent()
4408 {
4409 if ( !HasCurrent() && !IsEmpty() )
4410 ChangeCurrent(0);
4411 }
4412
4413 long wxListMainWindow::GetNextItem( long item,
4414 int WXUNUSED(geometry),
4415 int state ) const
4416 {
4417 long ret = item,
4418 max = GetItemCount();
4419 wxCHECK_MSG( (ret == -1) || (ret < max), -1,
4420 _T("invalid listctrl index in GetNextItem()") );
4421
4422 // notice that we start with the next item (or the first one if item == -1)
4423 // and this is intentional to allow writing a simple loop to iterate over
4424 // all selected items
4425 ret++;
4426 if ( ret == max )
4427 // this is not an error because the index was OK initially,
4428 // just no such item
4429 return -1;
4430
4431 if ( !state )
4432 // any will do
4433 return (size_t)ret;
4434
4435 size_t count = GetItemCount();
4436 for ( size_t line = (size_t)ret; line < count; line++ )
4437 {
4438 if ( (state & wxLIST_STATE_FOCUSED) && (line == m_current) )
4439 return line;
4440
4441 if ( (state & wxLIST_STATE_SELECTED) && IsHighlighted(line) )
4442 return line;
4443 }
4444
4445 return -1;
4446 }
4447
4448 // ----------------------------------------------------------------------------
4449 // deleting stuff
4450 // ----------------------------------------------------------------------------
4451
4452 void wxListMainWindow::DeleteItem( long lindex )
4453 {
4454 size_t count = GetItemCount();
4455
4456 wxCHECK_RET( (lindex >= 0) && ((size_t)lindex < count),
4457 _T("invalid item index in DeleteItem") );
4458
4459 size_t index = (size_t)lindex;
4460
4461 // we don't need to adjust the index for the previous items
4462 if ( HasCurrent() && m_current >= index )
4463 {
4464 // if the current item is being deleted, we want the next one to
4465 // become selected - unless there is no next one - so don't adjust
4466 // m_current in this case
4467 if ( m_current != index || m_current == count - 1 )
4468 m_current--;
4469 }
4470
4471 if ( InReportView() )
4472 {
4473 // mark the Column Max Width cache as dirty if the items in the line
4474 // we're deleting contain the Max Column Width
4475 wxListLineData * const line = GetLine(index);
4476 wxListItemDataList::compatibility_iterator n;
4477 wxListItemData *itemData;
4478 wxListItem item;
4479 int itemWidth;
4480
4481 for (size_t i = 0; i < m_columns.GetCount(); i++)
4482 {
4483 n = line->m_items.Item( i );
4484 itemData = n->GetData();
4485 itemData->GetItem(item);
4486
4487 itemWidth = GetItemWidthWithImage(&item);
4488
4489 if (itemWidth >= m_aColWidths.Item(i)->nMaxWidth)
4490 m_aColWidths.Item(i)->bNeedsUpdate = true;
4491 }
4492
4493 ResetVisibleLinesRange();
4494 }
4495
4496 SendNotify( index, wxEVT_COMMAND_LIST_DELETE_ITEM, wxDefaultPosition );
4497
4498 if ( IsVirtual() )
4499 {
4500 m_countVirt--;
4501 m_selStore.OnItemDelete(index);
4502 }
4503 else
4504 {
4505 m_lines.RemoveAt( index );
4506 }
4507
4508 // we need to refresh the (vert) scrollbar as the number of items changed
4509 m_dirty = true;
4510
4511 RefreshAfter(index);
4512 }
4513
4514 void wxListMainWindow::DeleteColumn( int col )
4515 {
4516 wxListHeaderDataList::compatibility_iterator node = m_columns.Item( col );
4517
4518 wxCHECK_RET( node, wxT("invalid column index in DeleteColumn()") );
4519
4520 m_dirty = true;
4521 delete node->GetData();
4522 m_columns.Erase( node );
4523
4524 if ( !IsVirtual() )
4525 {
4526 // update all the items
4527 for ( size_t i = 0; i < m_lines.GetCount(); i++ )
4528 {
4529 wxListLineData * const line = GetLine(i);
4530 wxListItemDataList::compatibility_iterator n = line->m_items.Item( col );
4531 delete n->GetData();
4532 line->m_items.Erase(n);
4533 }
4534 }
4535
4536 if ( InReportView() ) // we only cache max widths when in Report View
4537 {
4538 delete m_aColWidths.Item(col);
4539 m_aColWidths.RemoveAt(col);
4540 }
4541
4542 // invalidate it as it has to be recalculated
4543 m_headerWidth = 0;
4544 }
4545
4546 void wxListMainWindow::DoDeleteAllItems()
4547 {
4548 if ( IsEmpty() )
4549 // nothing to do - in particular, don't send the event
4550 return;
4551
4552 ResetCurrent();
4553
4554 // to make the deletion of all items faster, we don't send the
4555 // notifications for each item deletion in this case but only one event
4556 // for all of them: this is compatible with wxMSW and documented in
4557 // DeleteAllItems() description
4558
4559 wxListEvent event( wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS, GetParent()->GetId() );
4560 event.SetEventObject( GetParent() );
4561 GetParent()->GetEventHandler()->ProcessEvent( event );
4562
4563 if ( IsVirtual() )
4564 {
4565 m_countVirt = 0;
4566 m_selStore.Clear();
4567 }
4568
4569 if ( InReportView() )
4570 {
4571 ResetVisibleLinesRange();
4572 for (size_t i = 0; i < m_aColWidths.GetCount(); i++)
4573 {
4574 m_aColWidths.Item(i)->bNeedsUpdate = true;
4575 }
4576 }
4577
4578 m_lines.Clear();
4579 }
4580
4581 void wxListMainWindow::DeleteAllItems()
4582 {
4583 DoDeleteAllItems();
4584
4585 RecalculatePositions();
4586 }
4587
4588 void wxListMainWindow::DeleteEverything()
4589 {
4590 WX_CLEAR_LIST(wxListHeaderDataList, m_columns);
4591 WX_CLEAR_ARRAY(m_aColWidths);
4592
4593 DeleteAllItems();
4594 }
4595
4596 // ----------------------------------------------------------------------------
4597 // scanning for an item
4598 // ----------------------------------------------------------------------------
4599
4600 void wxListMainWindow::EnsureVisible( long index )
4601 {
4602 wxCHECK_RET( index >= 0 && (size_t)index < GetItemCount(),
4603 _T("invalid index in EnsureVisible") );
4604
4605 // We have to call this here because the label in question might just have
4606 // been added and its position is not known yet
4607 if ( m_dirty )
4608 RecalculatePositions(true /* no refresh */);
4609
4610 MoveToItem((size_t)index);
4611 }
4612
4613 long wxListMainWindow::FindItem(long start, const wxString& str, bool partial )
4614 {
4615 if (str.empty())
4616 return wxNOT_FOUND;
4617
4618 long pos = start;
4619 wxString str_upper = str.Upper();
4620 if (pos < 0)
4621 pos = 0;
4622
4623 size_t count = GetItemCount();
4624 for ( size_t i = (size_t)pos; i < count; i++ )
4625 {
4626 wxListLineData *line = GetLine(i);
4627 wxString line_upper = line->GetText(0).Upper();
4628 if (!partial)
4629 {
4630 if (line_upper == str_upper )
4631 return i;
4632 }
4633 else
4634 {
4635 if (line_upper.find(str_upper) == 0)
4636 return i;
4637 }
4638 }
4639
4640 return wxNOT_FOUND;
4641 }
4642
4643 long wxListMainWindow::FindItem(long start, wxUIntPtr data)
4644 {
4645 long pos = start;
4646 if (pos < 0)
4647 pos = 0;
4648
4649 size_t count = GetItemCount();
4650 for (size_t i = (size_t)pos; i < count; i++)
4651 {
4652 wxListLineData *line = GetLine(i);
4653 wxListItem item;
4654 line->GetItem( 0, item );
4655 if (item.m_data == data)
4656 return i;
4657 }
4658
4659 return wxNOT_FOUND;
4660 }
4661
4662 long wxListMainWindow::FindItem( const wxPoint& pt )
4663 {
4664 size_t topItem;
4665 GetVisibleLinesRange( &topItem, NULL );
4666
4667 wxPoint p;
4668 GetItemPosition( GetItemCount() - 1, p );
4669 if ( p.y == 0 )
4670 return topItem;
4671
4672 long id = (long)floor( pt.y * double(GetItemCount() - topItem - 1) / p.y + topItem );
4673 if ( id >= 0 && id < (long)GetItemCount() )
4674 return id;
4675
4676 return wxNOT_FOUND;
4677 }
4678
4679 long wxListMainWindow::HitTest( int x, int y, int &flags ) const
4680 {
4681 CalcUnscrolledPosition( x, y, &x, &y );
4682
4683 size_t count = GetItemCount();
4684
4685 if ( InReportView() )
4686 {
4687 size_t current = y / GetLineHeight();
4688 if ( current < count )
4689 {
4690 flags = HitTestLine(current, x, y);
4691 if ( flags )
4692 return current;
4693 }
4694 }
4695 else // !report
4696 {
4697 // TODO: optimize it too! this is less simple than for report view but
4698 // enumerating all items is still not a way to do it!!
4699 for ( size_t current = 0; current < count; current++ )
4700 {
4701 flags = HitTestLine(current, x, y);
4702 if ( flags )
4703 return current;
4704 }
4705 }
4706
4707 return wxNOT_FOUND;
4708 }
4709
4710 // ----------------------------------------------------------------------------
4711 // adding stuff
4712 // ----------------------------------------------------------------------------
4713
4714 void wxListMainWindow::InsertItem( wxListItem &item )
4715 {
4716 wxASSERT_MSG( !IsVirtual(), _T("can't be used with virtual control") );
4717
4718 int count = GetItemCount();
4719 wxCHECK_RET( item.m_itemId >= 0, _T("invalid item index") );
4720
4721 if (item.m_itemId > count)
4722 item.m_itemId = count;
4723
4724 size_t id = item.m_itemId;
4725
4726 m_dirty = true;
4727
4728 if ( InReportView() )
4729 {
4730 ResetVisibleLinesRange();
4731
4732 // calculate the width of the item and adjust the max column width
4733 wxColWidthInfo *pWidthInfo = m_aColWidths.Item(item.GetColumn());
4734 int width = GetItemWidthWithImage(&item);
4735 item.SetWidth(width);
4736 if (width > pWidthInfo->nMaxWidth)
4737 pWidthInfo->nMaxWidth = width;
4738 }
4739
4740 wxListLineData *line = new wxListLineData(this);
4741
4742 line->SetItem( item.m_col, item );
4743
4744 m_lines.Insert( line, id );
4745
4746 m_dirty = true;
4747
4748 // If an item is selected at or below the point of insertion, we need to
4749 // increment the member variables because the current row's index has gone
4750 // up by one
4751 if ( HasCurrent() && m_current >= id )
4752 m_current++;
4753
4754 SendNotify(id, wxEVT_COMMAND_LIST_INSERT_ITEM);
4755
4756 RefreshLines(id, GetItemCount() - 1);
4757 }
4758
4759 void wxListMainWindow::InsertColumn( long col, wxListItem &item )
4760 {
4761 m_dirty = true;
4762 if ( InReportView() )
4763 {
4764 if (item.m_width == wxLIST_AUTOSIZE_USEHEADER)
4765 item.m_width = GetTextLength( item.m_text );
4766
4767 wxListHeaderData *column = new wxListHeaderData( item );
4768 wxColWidthInfo *colWidthInfo = new wxColWidthInfo();
4769
4770 bool insert = (col >= 0) && ((size_t)col < m_columns.GetCount());
4771 if ( insert )
4772 {
4773 wxListHeaderDataList::compatibility_iterator
4774 node = m_columns.Item( col );
4775 m_columns.Insert( node, column );
4776 m_aColWidths.Insert( colWidthInfo, col );
4777 }
4778 else
4779 {
4780 m_columns.Append( column );
4781 m_aColWidths.Add( colWidthInfo );
4782 }
4783
4784 if ( !IsVirtual() )
4785 {
4786 // update all the items
4787 for ( size_t i = 0; i < m_lines.GetCount(); i++ )
4788 {
4789 wxListLineData * const line = GetLine(i);
4790 wxListItemData * const data = new wxListItemData(this);
4791 if ( insert )
4792 line->m_items.Insert(col, data);
4793 else
4794 line->m_items.Append(data);
4795 }
4796 }
4797
4798 // invalidate it as it has to be recalculated
4799 m_headerWidth = 0;
4800 }
4801 }
4802
4803 int wxListMainWindow::GetItemWidthWithImage(wxListItem * item)
4804 {
4805 int width = 0;
4806 wxClientDC dc(this);
4807
4808 dc.SetFont( GetFont() );
4809
4810 if (item->GetImage() != -1)
4811 {
4812 int ix, iy;
4813 GetImageSize( item->GetImage(), ix, iy );
4814 width += ix + 5;
4815 }
4816
4817 if (!item->GetText().empty())
4818 {
4819 wxCoord w;
4820 dc.GetTextExtent( item->GetText(), &w, NULL );
4821 width += w;
4822 }
4823
4824 return width;
4825 }
4826
4827 // ----------------------------------------------------------------------------
4828 // sorting
4829 // ----------------------------------------------------------------------------
4830
4831 wxListCtrlCompare list_ctrl_compare_func_2;
4832 long list_ctrl_compare_data;
4833
4834 int LINKAGEMODE list_ctrl_compare_func_1( wxListLineData **arg1, wxListLineData **arg2 )
4835 {
4836 wxListLineData *line1 = *arg1;
4837 wxListLineData *line2 = *arg2;
4838 wxListItem item;
4839 line1->GetItem( 0, item );
4840 wxUIntPtr data1 = item.m_data;
4841 line2->GetItem( 0, item );
4842 wxUIntPtr data2 = item.m_data;
4843 return list_ctrl_compare_func_2( data1, data2, list_ctrl_compare_data );
4844 }
4845
4846 void wxListMainWindow::SortItems( wxListCtrlCompare fn, long data )
4847 {
4848 // selections won't make sense any more after sorting the items so reset
4849 // them
4850 HighlightAll(false);
4851 ResetCurrent();
4852
4853 list_ctrl_compare_func_2 = fn;
4854 list_ctrl_compare_data = data;
4855 m_lines.Sort( list_ctrl_compare_func_1 );
4856 m_dirty = true;
4857 }
4858
4859 // ----------------------------------------------------------------------------
4860 // scrolling
4861 // ----------------------------------------------------------------------------
4862
4863 void wxListMainWindow::OnScroll(wxScrollWinEvent& event)
4864 {
4865 // FIXME
4866 #if ( defined(__WXGTK__) || defined(__WXMAC__) ) && !defined(__WXUNIVERSAL__)
4867 wxScrolledWindow::OnScroll(event);
4868 #else
4869 HandleOnScroll( event );
4870 #endif
4871
4872 // update our idea of which lines are shown when we redraw the window the
4873 // next time
4874 ResetVisibleLinesRange();
4875
4876 if ( event.GetOrientation() == wxHORIZONTAL && HasHeader() )
4877 {
4878 wxGenericListCtrl* lc = GetListCtrl();
4879 wxCHECK_RET( lc, _T("no listctrl window?") );
4880
4881 lc->m_headerWin->Refresh();
4882 lc->m_headerWin->Update();
4883 }
4884 }
4885
4886 int wxListMainWindow::GetCountPerPage() const
4887 {
4888 if ( !m_linesPerPage )
4889 {
4890 wxConstCast(this, wxListMainWindow)->
4891 m_linesPerPage = GetClientSize().y / GetLineHeight();
4892 }
4893
4894 return m_linesPerPage;
4895 }
4896
4897 void wxListMainWindow::GetVisibleLinesRange(size_t *from, size_t *to)
4898 {
4899 wxASSERT_MSG( InReportView(), _T("this is for report mode only") );
4900
4901 if ( m_lineFrom == (size_t)-1 )
4902 {
4903 size_t count = GetItemCount();
4904 if ( count )
4905 {
4906 m_lineFrom = GetScrollPos(wxVERTICAL);
4907
4908 // this may happen if SetScrollbars() hadn't been called yet
4909 if ( m_lineFrom >= count )
4910 m_lineFrom = count - 1;
4911
4912 // we redraw one extra line but this is needed to make the redrawing
4913 // logic work when there is a fractional number of lines on screen
4914 m_lineTo = m_lineFrom + m_linesPerPage;
4915 if ( m_lineTo >= count )
4916 m_lineTo = count - 1;
4917 }
4918 else // empty control
4919 {
4920 m_lineFrom = 0;
4921 m_lineTo = (size_t)-1;
4922 }
4923 }
4924
4925 wxASSERT_MSG( IsEmpty() ||
4926 (m_lineFrom <= m_lineTo && m_lineTo < GetItemCount()),
4927 _T("GetVisibleLinesRange() returns incorrect result") );
4928
4929 if ( from )
4930 *from = m_lineFrom;
4931 if ( to )
4932 *to = m_lineTo;
4933 }
4934
4935 // -------------------------------------------------------------------------------------
4936 // wxGenericListCtrl
4937 // -------------------------------------------------------------------------------------
4938
4939 IMPLEMENT_DYNAMIC_CLASS(wxGenericListCtrl, wxControl)
4940
4941 BEGIN_EVENT_TABLE(wxGenericListCtrl,wxControl)
4942 EVT_SIZE(wxGenericListCtrl::OnSize)
4943 END_EVENT_TABLE()
4944
4945 wxGenericListCtrl::wxGenericListCtrl()
4946 {
4947 m_imageListNormal = (wxImageList *) NULL;
4948 m_imageListSmall = (wxImageList *) NULL;
4949 m_imageListState = (wxImageList *) NULL;
4950
4951 m_ownsImageListNormal =
4952 m_ownsImageListSmall =
4953 m_ownsImageListState = false;
4954
4955 m_mainWin = (wxListMainWindow*) NULL;
4956 m_headerWin = (wxListHeaderWindow*) NULL;
4957 m_headerHeight = 0;
4958 }
4959
4960 wxGenericListCtrl::~wxGenericListCtrl()
4961 {
4962 if (m_ownsImageListNormal)
4963 delete m_imageListNormal;
4964 if (m_ownsImageListSmall)
4965 delete m_imageListSmall;
4966 if (m_ownsImageListState)
4967 delete m_imageListState;
4968 }
4969
4970 void wxGenericListCtrl::CalculateAndSetHeaderHeight()
4971 {
4972 if ( m_headerWin )
4973 {
4974 #ifdef __WXMAC__
4975 SInt32 h;
4976 GetThemeMetric( kThemeMetricListHeaderHeight, &h );
4977 #else
4978 // we use 'g' to get the descent, too
4979 int w, h, d;
4980 m_headerWin->GetTextExtent(wxT("Hg"), &w, &h, &d);
4981 h += d + 2 * HEADER_OFFSET_Y + EXTRA_HEIGHT;
4982 #endif
4983
4984 // only update if changed
4985 if ( h != m_headerHeight )
4986 {
4987 m_headerHeight = h;
4988
4989 if ( HasHeader() )
4990 ResizeReportView(true);
4991 else //why is this needed if it doesn't have a header?
4992 m_headerWin->SetSize(m_headerWin->GetSize().x, m_headerHeight);
4993 }
4994 }
4995 }
4996
4997 void wxGenericListCtrl::CreateHeaderWindow()
4998 {
4999 m_headerWin = new wxListHeaderWindow
5000 (
5001 this, wxID_ANY, m_mainWin,
5002 wxPoint(0,0),
5003 wxSize(GetClientSize().x, m_headerHeight),
5004 wxTAB_TRAVERSAL
5005 );
5006 CalculateAndSetHeaderHeight();
5007 }
5008
5009 bool wxGenericListCtrl::Create(wxWindow *parent,
5010 wxWindowID id,
5011 const wxPoint &pos,
5012 const wxSize &size,
5013 long style,
5014 const wxValidator &validator,
5015 const wxString &name)
5016 {
5017 m_imageListNormal =
5018 m_imageListSmall =
5019 m_imageListState = (wxImageList *) NULL;
5020 m_ownsImageListNormal =
5021 m_ownsImageListSmall =
5022 m_ownsImageListState = false;
5023
5024 m_mainWin = (wxListMainWindow*) NULL;
5025 m_headerWin = (wxListHeaderWindow*) NULL;
5026
5027 m_headerHeight = 0;
5028
5029 if ( !(style & wxLC_MASK_TYPE) )
5030 {
5031 style = style | wxLC_LIST;
5032 }
5033
5034 if ( !wxControl::Create( parent, id, pos, size, style, validator, name ) )
5035 return false;
5036
5037 // this window itself shouldn't get the focus, only m_mainWin should
5038 SetCanFocus(false);
5039
5040 // don't create the inner window with the border
5041 style &= ~wxBORDER_MASK;
5042
5043 m_mainWin = new wxListMainWindow( this, wxID_ANY, wxPoint(0, 0), size, style );
5044
5045 #ifdef __WXMAC__
5046 // Human Interface Guidelines ask us for a special font in this case
5047 if ( GetWindowVariant() == wxWINDOW_VARIANT_NORMAL )
5048 {
5049 wxFont font;
5050 font.MacCreateFromThemeFont( kThemeViewsFont );
5051 SetFont( font );
5052 }
5053 #endif
5054
5055 if ( InReportView() )
5056 {
5057 CreateHeaderWindow();
5058
5059 #ifdef __WXMAC__
5060 if (m_headerWin)
5061 {
5062 wxFont font;
5063 font.MacCreateFromThemeFont( kThemeSmallSystemFont );
5064 m_headerWin->SetFont( font );
5065 CalculateAndSetHeaderHeight();
5066 }
5067 #endif
5068
5069 if ( HasFlag(wxLC_NO_HEADER) )
5070 // VZ: why do we create it at all then?
5071 m_headerWin->Show( false );
5072 }
5073
5074 SetInitialSize(size);
5075
5076 return true;
5077 }
5078
5079 void wxGenericListCtrl::SetSingleStyle( long style, bool add )
5080 {
5081 wxASSERT_MSG( !(style & wxLC_VIRTUAL),
5082 _T("wxLC_VIRTUAL can't be [un]set") );
5083
5084 long flag = GetWindowStyle();
5085
5086 if (add)
5087 {
5088 if (style & wxLC_MASK_TYPE)
5089 flag &= ~(wxLC_MASK_TYPE | wxLC_VIRTUAL);
5090 if (style & wxLC_MASK_ALIGN)
5091 flag &= ~wxLC_MASK_ALIGN;
5092 if (style & wxLC_MASK_SORT)
5093 flag &= ~wxLC_MASK_SORT;
5094 }
5095
5096 if (add)
5097 flag |= style;
5098 else
5099 flag &= ~style;
5100
5101 SetWindowStyleFlag( flag );
5102 }
5103
5104 void wxGenericListCtrl::SetWindowStyleFlag( long flag )
5105 {
5106 if (m_mainWin)
5107 {
5108 m_mainWin->DeleteEverything();
5109
5110 // has the header visibility changed?
5111 bool hasHeader = HasHeader();
5112 bool willHaveHeader = (flag & wxLC_REPORT) && !(flag & wxLC_NO_HEADER);
5113
5114 if ( hasHeader != willHaveHeader )
5115 {
5116 // toggle it
5117 if ( hasHeader )
5118 {
5119 if ( m_headerWin )
5120 {
5121 // don't delete, just hide, as we can reuse it later
5122 m_headerWin->Show(false);
5123 }
5124 //else: nothing to do
5125 }
5126 else // must show header
5127 {
5128 if (!m_headerWin)
5129 {
5130 CreateHeaderWindow();
5131 }
5132 else // already have it, just show
5133 {
5134 m_headerWin->Show( true );
5135 }
5136 }
5137
5138 ResizeReportView(willHaveHeader);
5139 }
5140 }
5141
5142 wxWindow::SetWindowStyleFlag( flag );
5143 }
5144
5145 bool wxGenericListCtrl::GetColumn(int col, wxListItem &item) const
5146 {
5147 m_mainWin->GetColumn( col, item );
5148 return true;
5149 }
5150
5151 bool wxGenericListCtrl::SetColumn( int col, wxListItem& item )
5152 {
5153 m_mainWin->SetColumn( col, item );
5154 return true;
5155 }
5156
5157 int wxGenericListCtrl::GetColumnWidth( int col ) const
5158 {
5159 return m_mainWin->GetColumnWidth( col );
5160 }
5161
5162 bool wxGenericListCtrl::SetColumnWidth( int col, int width )
5163 {
5164 m_mainWin->SetColumnWidth( col, width );
5165 return true;
5166 }
5167
5168 int wxGenericListCtrl::GetCountPerPage() const
5169 {
5170 return m_mainWin->GetCountPerPage(); // different from Windows ?
5171 }
5172
5173 bool wxGenericListCtrl::GetItem( wxListItem &info ) const
5174 {
5175 m_mainWin->GetItem( info );
5176 return true;
5177 }
5178
5179 bool wxGenericListCtrl::SetItem( wxListItem &info )
5180 {
5181 m_mainWin->SetItem( info );
5182 return true;
5183 }
5184
5185 long wxGenericListCtrl::SetItem( long index, int col, const wxString& label, int imageId )
5186 {
5187 wxListItem info;
5188 info.m_text = label;
5189 info.m_mask = wxLIST_MASK_TEXT;
5190 info.m_itemId = index;
5191 info.m_col = col;
5192 if ( imageId > -1 )
5193 {
5194 info.m_image = imageId;
5195 info.m_mask |= wxLIST_MASK_IMAGE;
5196 }
5197
5198 m_mainWin->SetItem(info);
5199 return true;
5200 }
5201
5202 int wxGenericListCtrl::GetItemState( long item, long stateMask ) const
5203 {
5204 return m_mainWin->GetItemState( item, stateMask );
5205 }
5206
5207 bool wxGenericListCtrl::SetItemState( long item, long state, long stateMask )
5208 {
5209 m_mainWin->SetItemState( item, state, stateMask );
5210 return true;
5211 }
5212
5213 bool
5214 wxGenericListCtrl::SetItemImage( long item, int image, int WXUNUSED(selImage) )
5215 {
5216 return SetItemColumnImage(item, 0, image);
5217 }
5218
5219 bool
5220 wxGenericListCtrl::SetItemColumnImage( long item, long column, int image )
5221 {
5222 wxListItem info;
5223 info.m_image = image;
5224 info.m_mask = wxLIST_MASK_IMAGE;
5225 info.m_itemId = item;
5226 info.m_col = column;
5227 m_mainWin->SetItem( info );
5228 return true;
5229 }
5230
5231 wxString wxGenericListCtrl::GetItemText( long item ) const
5232 {
5233 return m_mainWin->GetItemText(item);
5234 }
5235
5236 void wxGenericListCtrl::SetItemText( long item, const wxString& str )
5237 {
5238 m_mainWin->SetItemText(item, str);
5239 }
5240
5241 wxUIntPtr wxGenericListCtrl::GetItemData( long item ) const
5242 {
5243 wxListItem info;
5244 info.m_mask = wxLIST_MASK_DATA;
5245 info.m_itemId = item;
5246 m_mainWin->GetItem( info );
5247 return info.m_data;
5248 }
5249
5250 bool wxGenericListCtrl::SetItemPtrData( long item, wxUIntPtr data )
5251 {
5252 wxListItem info;
5253 info.m_mask = wxLIST_MASK_DATA;
5254 info.m_itemId = item;
5255 info.m_data = data;
5256 m_mainWin->SetItem( info );
5257 return true;
5258 }
5259
5260 wxRect wxGenericListCtrl::GetViewRect() const
5261 {
5262 return m_mainWin->GetViewRect();
5263 }
5264
5265 bool wxGenericListCtrl::GetItemRect( long item, wxRect &rect, int WXUNUSED(code) ) const
5266 {
5267 m_mainWin->GetItemRect( item, rect );
5268 if ( m_mainWin->HasHeader() )
5269 rect.y += m_headerHeight + 1;
5270 return true;
5271 }
5272
5273 bool wxGenericListCtrl::GetItemPosition( long item, wxPoint& pos ) const
5274 {
5275 m_mainWin->GetItemPosition( item, pos );
5276 return true;
5277 }
5278
5279 bool wxGenericListCtrl::SetItemPosition( long WXUNUSED(item), const wxPoint& WXUNUSED(pos) )
5280 {
5281 return 0;
5282 }
5283
5284 int wxGenericListCtrl::GetItemCount() const
5285 {
5286 return m_mainWin->GetItemCount();
5287 }
5288
5289 int wxGenericListCtrl::GetColumnCount() const
5290 {
5291 return m_mainWin->GetColumnCount();
5292 }
5293
5294 void wxGenericListCtrl::SetItemSpacing( int spacing, bool isSmall )
5295 {
5296 m_mainWin->SetItemSpacing( spacing, isSmall );
5297 }
5298
5299 wxSize wxGenericListCtrl::GetItemSpacing() const
5300 {
5301 const int spacing = m_mainWin->GetItemSpacing(HasFlag(wxLC_SMALL_ICON));
5302
5303 return wxSize(spacing, spacing);
5304 }
5305
5306 #if WXWIN_COMPATIBILITY_2_6
5307 int wxGenericListCtrl::GetItemSpacing( bool isSmall ) const
5308 {
5309 return m_mainWin->GetItemSpacing( isSmall );
5310 }
5311 #endif // WXWIN_COMPATIBILITY_2_6
5312
5313 void wxGenericListCtrl::SetItemTextColour( long item, const wxColour &col )
5314 {
5315 wxListItem info;
5316 info.m_itemId = item;
5317 info.SetTextColour( col );
5318 m_mainWin->SetItem( info );
5319 }
5320
5321 wxColour wxGenericListCtrl::GetItemTextColour( long item ) const
5322 {
5323 wxListItem info;
5324 info.m_itemId = item;
5325 m_mainWin->GetItem( info );
5326 return info.GetTextColour();
5327 }
5328
5329 void wxGenericListCtrl::SetItemBackgroundColour( long item, const wxColour &col )
5330 {
5331 wxListItem info;
5332 info.m_itemId = item;
5333 info.SetBackgroundColour( col );
5334 m_mainWin->SetItem( info );
5335 }
5336
5337 wxColour wxGenericListCtrl::GetItemBackgroundColour( long item ) const
5338 {
5339 wxListItem info;
5340 info.m_itemId = item;
5341 m_mainWin->GetItem( info );
5342 return info.GetBackgroundColour();
5343 }
5344
5345 int wxGenericListCtrl::GetScrollPos( int orient ) const
5346 {
5347 return m_mainWin->GetScrollPos( orient );
5348 }
5349
5350 void wxGenericListCtrl::SetScrollPos( int orient, int pos, bool refresh )
5351 {
5352 m_mainWin->SetScrollPos( orient, pos, refresh );
5353 }
5354
5355 void wxGenericListCtrl::SetItemFont( long item, const wxFont &f )
5356 {
5357 wxListItem info;
5358 info.m_itemId = item;
5359 info.SetFont( f );
5360 m_mainWin->SetItem( info );
5361 }
5362
5363 wxFont wxGenericListCtrl::GetItemFont( long item ) const
5364 {
5365 wxListItem info;
5366 info.m_itemId = item;
5367 m_mainWin->GetItem( info );
5368 return info.GetFont();
5369 }
5370
5371 int wxGenericListCtrl::GetSelectedItemCount() const
5372 {
5373 return m_mainWin->GetSelectedItemCount();
5374 }
5375
5376 wxColour wxGenericListCtrl::GetTextColour() const
5377 {
5378 return GetForegroundColour();
5379 }
5380
5381 void wxGenericListCtrl::SetTextColour(const wxColour& col)
5382 {
5383 SetForegroundColour(col);
5384 }
5385
5386 long wxGenericListCtrl::GetTopItem() const
5387 {
5388 size_t top;
5389 m_mainWin->GetVisibleLinesRange(&top, NULL);
5390 return (long)top;
5391 }
5392
5393 long wxGenericListCtrl::GetNextItem( long item, int geom, int state ) const
5394 {
5395 return m_mainWin->GetNextItem( item, geom, state );
5396 }
5397
5398 wxImageList *wxGenericListCtrl::GetImageList(int which) const
5399 {
5400 if (which == wxIMAGE_LIST_NORMAL)
5401 return m_imageListNormal;
5402 else if (which == wxIMAGE_LIST_SMALL)
5403 return m_imageListSmall;
5404 else if (which == wxIMAGE_LIST_STATE)
5405 return m_imageListState;
5406
5407 return (wxImageList *) NULL;
5408 }
5409
5410 void wxGenericListCtrl::SetImageList( wxImageList *imageList, int which )
5411 {
5412 if ( which == wxIMAGE_LIST_NORMAL )
5413 {
5414 if (m_ownsImageListNormal)
5415 delete m_imageListNormal;
5416 m_imageListNormal = imageList;
5417 m_ownsImageListNormal = false;
5418 }
5419 else if ( which == wxIMAGE_LIST_SMALL )
5420 {
5421 if (m_ownsImageListSmall)
5422 delete m_imageListSmall;
5423 m_imageListSmall = imageList;
5424 m_ownsImageListSmall = false;
5425 }
5426 else if ( which == wxIMAGE_LIST_STATE )
5427 {
5428 if (m_ownsImageListState)
5429 delete m_imageListState;
5430 m_imageListState = imageList;
5431 m_ownsImageListState = false;
5432 }
5433
5434 m_mainWin->SetImageList( imageList, which );
5435 }
5436
5437 void wxGenericListCtrl::AssignImageList(wxImageList *imageList, int which)
5438 {
5439 SetImageList(imageList, which);
5440 if ( which == wxIMAGE_LIST_NORMAL )
5441 m_ownsImageListNormal = true;
5442 else if ( which == wxIMAGE_LIST_SMALL )
5443 m_ownsImageListSmall = true;
5444 else if ( which == wxIMAGE_LIST_STATE )
5445 m_ownsImageListState = true;
5446 }
5447
5448 bool wxGenericListCtrl::Arrange( int WXUNUSED(flag) )
5449 {
5450 return 0;
5451 }
5452
5453 bool wxGenericListCtrl::DeleteItem( long item )
5454 {
5455 m_mainWin->DeleteItem( item );
5456 return true;
5457 }
5458
5459 bool wxGenericListCtrl::DeleteAllItems()
5460 {
5461 m_mainWin->DeleteAllItems();
5462 return true;
5463 }
5464
5465 bool wxGenericListCtrl::DeleteAllColumns()
5466 {
5467 size_t count = m_mainWin->m_columns.GetCount();
5468 for ( size_t n = 0; n < count; n++ )
5469 DeleteColumn( 0 );
5470 return true;
5471 }
5472
5473 void wxGenericListCtrl::ClearAll()
5474 {
5475 m_mainWin->DeleteEverything();
5476 }
5477
5478 bool wxGenericListCtrl::DeleteColumn( int col )
5479 {
5480 m_mainWin->DeleteColumn( col );
5481
5482 // if we don't have the header any longer, we need to relayout the window
5483 if ( !GetColumnCount() )
5484 ResizeReportView(false /* no header */);
5485 return true;
5486 }
5487
5488 wxTextCtrl *wxGenericListCtrl::EditLabel(long item,
5489 wxClassInfo* textControlClass)
5490 {
5491 return m_mainWin->EditLabel( item, textControlClass );
5492 }
5493
5494 wxTextCtrl *wxGenericListCtrl::GetEditControl() const
5495 {
5496 return m_mainWin->GetEditControl();
5497 }
5498
5499 bool wxGenericListCtrl::EnsureVisible( long item )
5500 {
5501 m_mainWin->EnsureVisible( item );
5502 return true;
5503 }
5504
5505 long wxGenericListCtrl::FindItem( long start, const wxString& str, bool partial )
5506 {
5507 return m_mainWin->FindItem( start, str, partial );
5508 }
5509
5510 long wxGenericListCtrl::FindItem( long start, wxUIntPtr data )
5511 {
5512 return m_mainWin->FindItem( start, data );
5513 }
5514
5515 long wxGenericListCtrl::FindItem( long WXUNUSED(start), const wxPoint& pt,
5516 int WXUNUSED(direction))
5517 {
5518 return m_mainWin->FindItem( pt );
5519 }
5520
5521 // TODO: sub item hit testing
5522 long wxGenericListCtrl::HitTest(const wxPoint& point, int& flags, long *) const
5523 {
5524 return m_mainWin->HitTest( (int)point.x, (int)point.y, flags );
5525 }
5526
5527 long wxGenericListCtrl::InsertItem( wxListItem& info )
5528 {
5529 m_mainWin->InsertItem( info );
5530 return info.m_itemId;
5531 }
5532
5533 long wxGenericListCtrl::InsertItem( long index, const wxString &label )
5534 {
5535 wxListItem info;
5536 info.m_text = label;
5537 info.m_mask = wxLIST_MASK_TEXT;
5538 info.m_itemId = index;
5539 return InsertItem( info );
5540 }
5541
5542 long wxGenericListCtrl::InsertItem( long index, int imageIndex )
5543 {
5544 wxListItem info;
5545 info.m_mask = wxLIST_MASK_IMAGE;
5546 info.m_image = imageIndex;
5547 info.m_itemId = index;
5548 return InsertItem( info );
5549 }
5550
5551 long wxGenericListCtrl::InsertItem( long index, const wxString &label, int imageIndex )
5552 {
5553 wxListItem info;
5554 info.m_text = label;
5555 info.m_image = imageIndex;
5556 info.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_IMAGE;
5557 info.m_itemId = index;
5558 return InsertItem( info );
5559 }
5560
5561 long wxGenericListCtrl::InsertColumn( long col, wxListItem &item )
5562 {
5563 wxCHECK_MSG( m_headerWin, -1, _T("can't add column in non report mode") );
5564
5565 m_mainWin->InsertColumn( col, item );
5566
5567 // if we hadn't had a header before but have one now
5568 // then we need to relayout the window
5569 if ( GetColumnCount() == 1 && m_mainWin->HasHeader() )
5570 ResizeReportView(true /* have header */);
5571
5572 m_headerWin->Refresh();
5573
5574 return 0;
5575 }
5576
5577 long wxGenericListCtrl::InsertColumn( long col, const wxString &heading,
5578 int format, int width )
5579 {
5580 wxListItem item;
5581 item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT;
5582 item.m_text = heading;
5583 if (width >= -2)
5584 {
5585 item.m_mask |= wxLIST_MASK_WIDTH;
5586 item.m_width = width;
5587 }
5588
5589 item.m_format = format;
5590
5591 return InsertColumn( col, item );
5592 }
5593
5594 bool wxGenericListCtrl::ScrollList( int dx, int dy )
5595 {
5596 return m_mainWin->ScrollList(dx, dy);
5597 }
5598
5599 // Sort items.
5600 // fn is a function which takes 3 long arguments: item1, item2, data.
5601 // item1 is the long data associated with a first item (NOT the index).
5602 // item2 is the long data associated with a second item (NOT the index).
5603 // data is the same value as passed to SortItems.
5604 // The return value is a negative number if the first item should precede the second
5605 // item, a positive number of the second item should precede the first,
5606 // or zero if the two items are equivalent.
5607 // data is arbitrary data to be passed to the sort function.
5608
5609 bool wxGenericListCtrl::SortItems( wxListCtrlCompare fn, long data )
5610 {
5611 m_mainWin->SortItems( fn, data );
5612 return true;
5613 }
5614
5615 // ----------------------------------------------------------------------------
5616 // event handlers
5617 // ----------------------------------------------------------------------------
5618
5619 void wxGenericListCtrl::OnSize(wxSizeEvent& WXUNUSED(event))
5620 {
5621 if ( !m_mainWin )
5622 return;
5623
5624 ResizeReportView(m_mainWin->HasHeader());
5625 m_mainWin->RecalculatePositions();
5626 }
5627
5628 void wxGenericListCtrl::ResizeReportView(bool showHeader)
5629 {
5630 int cw, ch;
5631 GetClientSize( &cw, &ch );
5632
5633 if ( showHeader )
5634 {
5635 m_headerWin->SetSize( 0, 0, cw, m_headerHeight );
5636 if(ch > m_headerHeight)
5637 m_mainWin->SetSize( 0, m_headerHeight + 1,
5638 cw, ch - m_headerHeight - 1 );
5639 else
5640 m_mainWin->SetSize( 0, m_headerHeight + 1,
5641 cw, 0);
5642 }
5643 else // no header window
5644 {
5645 m_mainWin->SetSize( 0, 0, cw, ch );
5646 }
5647 }
5648
5649 void wxGenericListCtrl::OnInternalIdle()
5650 {
5651 wxWindow::OnInternalIdle();
5652
5653 // do it only if needed
5654 if ( !m_mainWin->m_dirty )
5655 return;
5656
5657 m_mainWin->RecalculatePositions();
5658 }
5659
5660 // ----------------------------------------------------------------------------
5661 // font/colours
5662 // ----------------------------------------------------------------------------
5663
5664 bool wxGenericListCtrl::SetBackgroundColour( const wxColour &colour )
5665 {
5666 if (m_mainWin)
5667 {
5668 m_mainWin->SetBackgroundColour( colour );
5669 m_mainWin->m_dirty = true;
5670 }
5671
5672 return true;
5673 }
5674
5675 bool wxGenericListCtrl::SetForegroundColour( const wxColour &colour )
5676 {
5677 if ( !wxWindow::SetForegroundColour( colour ) )
5678 return false;
5679
5680 if (m_mainWin)
5681 {
5682 m_mainWin->SetForegroundColour( colour );
5683 m_mainWin->m_dirty = true;
5684 }
5685
5686 if (m_headerWin)
5687 m_headerWin->SetForegroundColour( colour );
5688
5689 return true;
5690 }
5691
5692 bool wxGenericListCtrl::SetFont( const wxFont &font )
5693 {
5694 if ( !wxWindow::SetFont( font ) )
5695 return false;
5696
5697 if (m_mainWin)
5698 {
5699 m_mainWin->SetFont( font );
5700 m_mainWin->m_dirty = true;
5701 }
5702
5703 if (m_headerWin)
5704 {
5705 m_headerWin->SetFont( font );
5706 CalculateAndSetHeaderHeight();
5707 }
5708
5709 Refresh();
5710
5711 return true;
5712 }
5713
5714 // static
5715 wxVisualAttributes
5716 wxGenericListCtrl::GetClassDefaultAttributes(wxWindowVariant variant)
5717 {
5718 #if _USE_VISATTR
5719 // Use the same color scheme as wxListBox
5720 return wxListBox::GetClassDefaultAttributes(variant);
5721 #else
5722 wxUnusedVar(variant);
5723 wxVisualAttributes attr;
5724 attr.colFg = wxSystemSettings::GetColour(wxSYS_COLOUR_WINDOWTEXT);
5725 attr.colBg = wxSystemSettings::GetColour(wxSYS_COLOUR_LISTBOX);
5726 attr.font = wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT);
5727 return attr;
5728 #endif
5729 }
5730
5731 // ----------------------------------------------------------------------------
5732 // methods forwarded to m_mainWin
5733 // ----------------------------------------------------------------------------
5734
5735 #if wxUSE_DRAG_AND_DROP
5736
5737 void wxGenericListCtrl::SetDropTarget( wxDropTarget *dropTarget )
5738 {
5739 m_mainWin->SetDropTarget( dropTarget );
5740 }
5741
5742 wxDropTarget *wxGenericListCtrl::GetDropTarget() const
5743 {
5744 return m_mainWin->GetDropTarget();
5745 }
5746
5747 #endif
5748
5749 bool wxGenericListCtrl::SetCursor( const wxCursor &cursor )
5750 {
5751 return m_mainWin ? m_mainWin->wxWindow::SetCursor(cursor) : false;
5752 }
5753
5754 wxColour wxGenericListCtrl::GetBackgroundColour() const
5755 {
5756 return m_mainWin ? m_mainWin->GetBackgroundColour() : wxColour();
5757 }
5758
5759 wxColour wxGenericListCtrl::GetForegroundColour() const
5760 {
5761 return m_mainWin ? m_mainWin->GetForegroundColour() : wxColour();
5762 }
5763
5764 bool wxGenericListCtrl::DoPopupMenu( wxMenu *menu, int x, int y )
5765 {
5766 #if wxUSE_MENUS
5767 return m_mainWin->PopupMenu( menu, x, y );
5768 #else
5769 return false;
5770 #endif
5771 }
5772
5773 void wxGenericListCtrl::DoClientToScreen( int *x, int *y ) const
5774 {
5775 m_mainWin->DoClientToScreen(x, y);
5776 }
5777
5778 void wxGenericListCtrl::DoScreenToClient( int *x, int *y ) const
5779 {
5780 m_mainWin->DoScreenToClient(x, y);
5781 }
5782
5783 void wxGenericListCtrl::SetFocus()
5784 {
5785 // The test in window.cpp fails as we are a composite
5786 // window, so it checks against "this", but not m_mainWin.
5787 if ( DoFindFocus() != this )
5788 m_mainWin->SetFocus();
5789 }
5790
5791 wxSize wxGenericListCtrl::DoGetBestSize() const
5792 {
5793 // Something is better than nothing...
5794 // 100x80 is what the MSW version will get from the default
5795 // wxControl::DoGetBestSize
5796 return wxSize(100, 80);
5797 }
5798
5799 // ----------------------------------------------------------------------------
5800 // virtual list control support
5801 // ----------------------------------------------------------------------------
5802
5803 wxString wxGenericListCtrl::OnGetItemText(long WXUNUSED(item), long WXUNUSED(col)) const
5804 {
5805 // this is a pure virtual function, in fact - which is not really pure
5806 // because the controls which are not virtual don't need to implement it
5807 wxFAIL_MSG( _T("wxGenericListCtrl::OnGetItemText not supposed to be called") );
5808
5809 return wxEmptyString;
5810 }
5811
5812 int wxGenericListCtrl::OnGetItemImage(long WXUNUSED(item)) const
5813 {
5814 wxCHECK_MSG(!GetImageList(wxIMAGE_LIST_SMALL),
5815 -1,
5816 wxT("List control has an image list, OnGetItemImage or OnGetItemColumnImage should be overridden."));
5817 return -1;
5818 }
5819
5820 int wxGenericListCtrl::OnGetItemColumnImage(long item, long column) const
5821 {
5822 if (!column)
5823 return OnGetItemImage(item);
5824
5825 return -1;
5826 }
5827
5828 wxListItemAttr *
5829 wxGenericListCtrl::OnGetItemAttr(long WXUNUSED_UNLESS_DEBUG(item)) const
5830 {
5831 wxASSERT_MSG( item >= 0 && item < GetItemCount(),
5832 _T("invalid item index in OnGetItemAttr()") );
5833
5834 // no attributes by default
5835 return NULL;
5836 }
5837
5838 void wxGenericListCtrl::SetItemCount(long count)
5839 {
5840 wxASSERT_MSG( IsVirtual(), _T("this is for virtual controls only") );
5841
5842 m_mainWin->SetItemCount(count);
5843 }
5844
5845 void wxGenericListCtrl::RefreshItem(long item)
5846 {
5847 m_mainWin->RefreshLine(item);
5848 }
5849
5850 void wxGenericListCtrl::RefreshItems(long itemFrom, long itemTo)
5851 {
5852 m_mainWin->RefreshLines(itemFrom, itemTo);
5853 }
5854
5855 // Generic wxListCtrl is more or less a container for two other
5856 // windows which drawings are done upon. These are namely
5857 // 'm_headerWin' and 'm_mainWin'.
5858 // Here we override 'virtual wxWindow::Refresh()' to mimic the
5859 // behaviour wxListCtrl has under wxMSW.
5860 //
5861 void wxGenericListCtrl::Refresh(bool eraseBackground, const wxRect *rect)
5862 {
5863 if (!rect)
5864 {
5865 // The easy case, no rectangle specified.
5866 if (m_headerWin)
5867 m_headerWin->Refresh(eraseBackground);
5868
5869 if (m_mainWin)
5870 m_mainWin->Refresh(eraseBackground);
5871 }
5872 else
5873 {
5874 // Refresh the header window
5875 if (m_headerWin)
5876 {
5877 wxRect rectHeader = m_headerWin->GetRect();
5878 rectHeader.Intersect(*rect);
5879 if (rectHeader.GetWidth() && rectHeader.GetHeight())
5880 {
5881 int x, y;
5882 m_headerWin->GetPosition(&x, &y);
5883 rectHeader.Offset(-x, -y);
5884 m_headerWin->Refresh(eraseBackground, &rectHeader);
5885 }
5886 }
5887
5888 // Refresh the main window
5889 if (m_mainWin)
5890 {
5891 wxRect rectMain = m_mainWin->GetRect();
5892 rectMain.Intersect(*rect);
5893 if (rectMain.GetWidth() && rectMain.GetHeight())
5894 {
5895 int x, y;
5896 m_mainWin->GetPosition(&x, &y);
5897 rectMain.Offset(-x, -y);
5898 m_mainWin->Refresh(eraseBackground, &rectMain);
5899 }
5900 }
5901 }
5902 }
5903
5904 void wxGenericListCtrl::DoFreeze()
5905 {
5906 m_mainWin->Freeze();
5907 }
5908
5909 void wxGenericListCtrl::DoThaw()
5910 {
5911 m_mainWin->Thaw();
5912 }
5913
5914 #endif // wxUSE_LISTCTRL