include/wx/generic/private/listctrl.h

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        wx/generic/private/listctrl.h
   3 // Purpose:     private definitions of wxListCtrl helpers
   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 #ifndef _WX_GENERIC_LISTCTRL_PRIVATE_H_
  12 #define _WX_GENERIC_LISTCTRL_PRIVATE_H_
  13
  14 #include "wx/defs.h"
  15
  16 #if wxUSE_LISTCTRL
  17
  18 #include "wx/listctrl.h"
  19 #include "wx/selstore.h"
  20 #include "wx/timer.h"
  21 #include "wx/settings.h"
  22
  23 // ============================================================================
  24 // private classes
  25 // ============================================================================
  26
  27 //-----------------------------------------------------------------------------
  28 //  wxColWidthInfo (internal)
  29 //-----------------------------------------------------------------------------
  30
  31 struct wxColWidthInfo
  32 {
  33     int     nMaxWidth;
  34     bool    bNeedsUpdate;   //  only set to true when an item whose
  35                             //  width == nMaxWidth is removed
  36
  37     wxColWidthInfo(int w = 0, bool needsUpdate = false)
  38     {
  39         nMaxWidth = w;
  40         bNeedsUpdate = needsUpdate;
  41     }
  42 };
  43
  44 WX_DEFINE_ARRAY_PTR(wxColWidthInfo *, ColWidthArray);
  45
  46 //-----------------------------------------------------------------------------
  47 //  wxListItemData (internal)
  48 //-----------------------------------------------------------------------------
  49
  50 class wxListItemData
  51 {
  52 public:
  53     wxListItemData(wxListMainWindow *owner);
  54     ~wxListItemData();
  55
  56     void SetItem( const wxListItem &info );
  57     void SetImage( int image ) { m_image = image; }
  58     void SetData( wxUIntPtr data ) { m_data = data; }
  59     void SetPosition( int x, int y );
  60     void SetSize( int width, int height );
  61
  62     bool HasText() const { return !m_text.empty(); }
  63     const wxString& GetText() const { return m_text; }
  64     void SetText(const wxString& text) { m_text = text; }
  65
  66     // we can't use empty string for measuring the string width/height, so
  67     // always return something
  68     wxString GetTextForMeasuring() const
  69     {
  70         wxString s = GetText();
  71         if ( s.empty() )
  72             s = wxT('H');
  73
  74         return s;
  75     }
  76
  77     bool IsHit( int x, int y ) const;
  78
  79     int GetX() const;
  80     int GetY() const;
  81     int GetWidth() const;
  82     int GetHeight() const;
  83
  84     int GetImage() const { return m_image; }
  85     bool HasImage() const { return GetImage() != -1; }
  86
  87     void GetItem( wxListItem &info ) const;
  88
  89     void SetAttr(wxListItemAttr *attr) { m_attr = attr; }
  90     wxListItemAttr *GetAttr() const { return m_attr; }
  91
  92 public:
  93     // the item image or -1
  94     int m_image;
  95
  96     // user data associated with the item
  97     wxUIntPtr m_data;
  98
  99     // the item coordinates are not used in report mode; instead this pointer is
 100     // NULL and the owner window is used to retrieve the item position and size
 101     wxRect *m_rect;
 102
 103     // the list ctrl we are in
 104     wxListMainWindow *m_owner;
 105
 106     // custom attributes or NULL
 107     wxListItemAttr *m_attr;
 108
 109 protected:
 110     // common part of all ctors
 111     void Init();
 112
 113     wxString m_text;
 114 };
 115
 116 //-----------------------------------------------------------------------------
 117 //  wxListHeaderData (internal)
 118 //-----------------------------------------------------------------------------
 119
 120 class wxListHeaderData : public wxObject
 121 {
 122 public:
 123     wxListHeaderData();
 124     wxListHeaderData( const wxListItem &info );
 125     void SetItem( const wxListItem &item );
 126     void SetPosition( int x, int y );
 127     void SetWidth( int w );
 128     void SetState( int state );
 129     void SetFormat( int format );
 130     void SetHeight( int h );
 131     bool HasImage() const;
 132
 133     bool HasText() const { return !m_text.empty(); }
 134     const wxString& GetText() const { return m_text; }
 135     void SetText(const wxString& text) { m_text = text; }
 136
 137     void GetItem( wxListItem &item );
 138
 139     bool IsHit( int x, int y ) const;
 140     int GetImage() const;
 141     int GetWidth() const;
 142     int GetFormat() const;
 143     int GetState() const;
 144
 145 protected:
 146     long      m_mask;
 147     int       m_image;
 148     wxString  m_text;
 149     int       m_format;
 150     int       m_width;
 151     int       m_xpos,
 152               m_ypos;
 153     int       m_height;
 154     int       m_state;
 155
 156 private:
 157     void Init();
 158 };
 159
 160 //-----------------------------------------------------------------------------
 161 //  wxListLineData (internal)
 162 //-----------------------------------------------------------------------------
 163
 164 WX_DECLARE_LIST(wxListItemData, wxListItemDataList);
 165
 166 class wxListLineData
 167 {
 168 public:
 169     // the list of subitems: only may have more than one item in report mode
 170     wxListItemDataList m_items;
 171
 172     // this is not used in report view
 173     struct GeometryInfo
 174     {
 175         // total item rect
 176         wxRect m_rectAll;
 177
 178         // label only
 179         wxRect m_rectLabel;
 180
 181         // icon only
 182         wxRect m_rectIcon;
 183
 184         // the part to be highlighted
 185         wxRect m_rectHighlight;
 186
 187         // extend all our rects to be centered inside the one of given width
 188         void ExtendWidth(wxCoord w)
 189         {
 190             wxASSERT_MSG( m_rectAll.width <= w,
 191                             wxT("width can only be increased") );
 192
 193             m_rectAll.width = w;
 194             m_rectLabel.x = m_rectAll.x + (w - m_rectLabel.width) / 2;
 195             m_rectIcon.x = m_rectAll.x + (w - m_rectIcon.width) / 2;
 196             m_rectHighlight.x = m_rectAll.x + (w - m_rectHighlight.width) / 2;
 197         }
 198     }
 199     *m_gi;
 200
 201     // is this item selected? [NB: not used in virtual mode]
 202     bool m_highlighted;
 203
 204     // back pointer to the list ctrl
 205     wxListMainWindow *m_owner;
 206
 207 public:
 208     wxListLineData(wxListMainWindow *owner);
 209
 210     ~wxListLineData()
 211     {
 212         WX_CLEAR_LIST(wxListItemDataList, m_items);
 213         delete m_gi;
 214     }
 215
 216     // called by the owner when it toggles report view
 217     void SetReportView(bool inReportView)
 218     {
 219         // we only need m_gi when we're not in report view so update as needed
 220         if ( inReportView )
 221         {
 222             delete m_gi;
 223             m_gi = NULL;
 224         }
 225         else
 226         {
 227             m_gi = new GeometryInfo;
 228         }
 229     }
 230
 231     // are we in report mode?
 232     inline bool InReportView() const;
 233
 234     // are we in virtual report mode?
 235     inline bool IsVirtual() const;
 236
 237     // these 2 methods shouldn't be called for report view controls, in that
 238     // case we determine our position/size ourselves
 239
 240     // calculate the size of the line
 241     void CalculateSize( wxDC *dc, int spacing );
 242
 243     // remember the position this line appears at
 244     void SetPosition( int x, int y, int spacing );
 245
 246     // wxListCtrl API
 247
 248     void SetImage( int image ) { SetImage(0, image); }
 249     int GetImage() const { return GetImage(0); }
 250     void SetImage( int index, int image );
 251     int GetImage( int index ) const;
 252
 253     bool HasImage() const { return GetImage() != -1; }
 254     bool HasText() const { return !GetText(0).empty(); }
 255
 256     void SetItem( int index, const wxListItem &info );
 257     void GetItem( int index, wxListItem &info );
 258
 259     wxString GetText(int index) const;
 260     void SetText( int index, const wxString& s );
 261
 262     wxListItemAttr *GetAttr() const;
 263     void SetAttr(wxListItemAttr *attr);
 264
 265     // return true if the highlighting really changed
 266     bool Highlight( bool on );
 267
 268     void ReverseHighlight();
 269
 270     bool IsHighlighted() const
 271     {
 272         wxASSERT_MSG( !IsVirtual(), wxT("unexpected call to IsHighlighted") );
 273
 274         return m_highlighted;
 275     }
 276
 277     // draw the line on the given DC in icon/list mode
 278     void Draw( wxDC *dc, bool current );
 279
 280     // the same in report mode: it needs more parameters as we don't store
 281     // everything in the item in report mode
 282     void DrawInReportMode( wxDC *dc,
 283                            const wxRect& rect,
 284                            const wxRect& rectHL,
 285                            bool highlighted,
 286                            bool current );
 287
 288 private:
 289     // set the line to contain num items (only can be > 1 in report mode)
 290     void InitItems( int num );
 291
 292     // get the mode (i.e. style)  of the list control
 293     inline int GetMode() const;
 294
 295     // Apply this item attributes to the given DC: set the text font and colour
 296     // and also erase the background appropriately.
 297     void ApplyAttributes(wxDC *dc,
 298                          const wxRect& rectHL,
 299                          bool highlighted,
 300                          bool current);
 301
 302     // draw the text on the DC with the correct justification; also add an
 303     // ellipsis if the text is too large to fit in the current width
 304     void DrawTextFormatted(wxDC *dc,
 305                            const wxString &text,
 306                            int col,
 307                            int x,
 308                            int yMid,    // this is middle, not top, of the text
 309                            int width);
 310 };
 311
 312 WX_DECLARE_OBJARRAY(wxListLineData, wxListLineDataArray);
 313
 314 //-----------------------------------------------------------------------------
 315 //  wxListHeaderWindow (internal)
 316 //-----------------------------------------------------------------------------
 317
 318 class wxListHeaderWindow : public wxWindow
 319 {
 320 protected:
 321     wxListMainWindow  *m_owner;
 322     const wxCursor    *m_currentCursor;
 323     wxCursor          *m_resizeCursor;
 324     bool               m_isDragging;
 325
 326     // column being resized or -1
 327     int m_column;
 328
 329     // divider line position in logical (unscrolled) coords
 330     int m_currentX;
 331
 332     // minimal position beyond which the divider line
 333     // can't be dragged in logical coords
 334     int m_minX;
 335
 336 public:
 337     wxListHeaderWindow();
 338
 339     // We provide only Create(), not the ctor, because we need to create the
 340     // C++ object before creating the window, see the explanations in
 341     // CreateOrDestroyHeaderWindowAsNeeded()
 342     bool Create( wxWindow *win,
 343                  wxWindowID id,
 344                  wxListMainWindow *owner,
 345                  const wxPoint &pos = wxDefaultPosition,
 346                  const wxSize &size = wxDefaultSize,
 347                  long style = 0,
 348                  const wxString &name = wxT("wxlistctrlcolumntitles") );
 349
 350     virtual ~wxListHeaderWindow();
 351
 352     // We never need focus as we don't have any keyboard interface.
 353     virtual bool AcceptsFocus() const { return false; }
 354
 355     void DrawCurrent();
 356     void AdjustDC( wxDC& dc );
 357
 358     void OnPaint( wxPaintEvent &event );
 359     void OnMouse( wxMouseEvent &event );
 360
 361     // needs refresh
 362     bool m_dirty;
 363
 364     // Update main window's column later
 365     bool m_sendSetColumnWidth;
 366     int m_colToSend;
 367     int m_widthToSend;
 368
 369     virtual void OnInternalIdle();
 370
 371 private:
 372     // common part of all ctors
 373     void Init();
 374
 375     // generate and process the list event of the given type, return true if
 376     // it wasn't vetoed, i.e. if we should proceed
 377     bool SendListEvent(wxEventType type, const wxPoint& pos);
 378
 379     DECLARE_EVENT_TABLE()
 380 };
 381
 382 //-----------------------------------------------------------------------------
 383 // wxListRenameTimer (internal)
 384 //-----------------------------------------------------------------------------
 385
 386 class wxListRenameTimer: public wxTimer
 387 {
 388 private:
 389     wxListMainWindow *m_owner;
 390
 391 public:
 392     wxListRenameTimer( wxListMainWindow *owner );
 393     void Notify();
 394 };
 395
 396 //-----------------------------------------------------------------------------
 397 // wxListFindTimer (internal)
 398 //-----------------------------------------------------------------------------
 399
 400 class wxListFindTimer: public wxTimer
 401 {
 402 public:
 403     // reset the current prefix after half a second of inactivity
 404     enum { DELAY = 500 };
 405
 406     wxListFindTimer( wxListMainWindow *owner )
 407         : m_owner(owner)
 408     {
 409     }
 410
 411     virtual void Notify();
 412
 413 private:
 414     wxListMainWindow *m_owner;
 415 };
 416
 417 //-----------------------------------------------------------------------------
 418 // wxListTextCtrlWrapper: wraps a wxTextCtrl to make it work for inline editing
 419 //-----------------------------------------------------------------------------
 420
 421 class wxListTextCtrlWrapper : public wxEvtHandler
 422 {
 423 public:
 424     // NB: text must be a valid object but not Create()d yet
 425     wxListTextCtrlWrapper(wxListMainWindow *owner,
 426                           wxTextCtrl *text,
 427                           size_t itemEdit);
 428
 429     wxTextCtrl *GetText() const { return m_text; }
 430
 431     // Check if the given key event should stop editing and return true if it
 432     // does or false otherwise.
 433     bool CheckForEndEditKey(const wxKeyEvent& event);
 434
 435     // Different reasons for calling EndEdit():
 436     //
 437     // It was called because:
 438     enum EndReason
 439     {
 440         End_Accept,     // user has accepted the changes.
 441         End_Discard,    // user has cancelled editing.
 442         End_Destroy     // the entire control is being destroyed.
 443     };
 444
 445     void EndEdit(EndReason reason);
 446
 447 protected:
 448     void OnChar( wxKeyEvent &event );
 449     void OnKeyUp( wxKeyEvent &event );
 450     void OnKillFocus( wxFocusEvent &event );
 451
 452     bool AcceptChanges();
 453     void Finish( bool setfocus );
 454
 455 private:
 456     wxListMainWindow   *m_owner;
 457     wxTextCtrl         *m_text;
 458     wxString            m_startValue;
 459     size_t              m_itemEdited;
 460     bool                m_aboutToFinish;
 461
 462     DECLARE_EVENT_TABLE()
 463 };
 464
 465 //-----------------------------------------------------------------------------
 466 //  wxListMainWindow (internal)
 467 //-----------------------------------------------------------------------------
 468
 469 WX_DECLARE_LIST(wxListHeaderData, wxListHeaderDataList);
 470
 471 class wxListMainWindow : public wxWindow
 472 {
 473 public:
 474     wxListMainWindow();
 475     wxListMainWindow( wxWindow *parent,
 476                       wxWindowID id,
 477                       const wxPoint& pos,
 478                       const wxSize& size );
 479
 480     virtual ~wxListMainWindow();
 481
 482     // called by the main control when its mode changes
 483     void SetReportView(bool inReportView);
 484
 485     // helper to simplify testing for wxLC_XXX flags
 486     bool HasFlag(int flag) const { return m_parent->HasFlag(flag); }
 487
 488     // return true if this is a virtual list control
 489     bool IsVirtual() const { return HasFlag(wxLC_VIRTUAL); }
 490
 491     // return true if the control is in report mode
 492     bool InReportView() const { return HasFlag(wxLC_REPORT); }
 493
 494     // return true if we are in single selection mode, false if multi sel
 495     bool IsSingleSel() const { return HasFlag(wxLC_SINGLE_SEL); }
 496
 497     // do we have a header window?
 498     bool HasHeader() const
 499         { return InReportView() && !HasFlag(wxLC_NO_HEADER); }
 500
 501     void HighlightAll( bool on );
 502
 503     // all these functions only do something if the line is currently visible
 504
 505     // change the line "selected" state, return true if it really changed
 506     bool HighlightLine( size_t line, bool highlight = true);
 507
 508     // as HighlightLine() but do it for the range of lines: this is incredibly
 509     // more efficient for virtual list controls!
 510     //
 511     // NB: unlike HighlightLine() this one does refresh the lines on screen
 512     void HighlightLines( size_t lineFrom, size_t lineTo, bool on = true );
 513
 514     // toggle the line state and refresh it
 515     void ReverseHighlight( size_t line )
 516         { HighlightLine(line, !IsHighlighted(line)); RefreshLine(line); }
 517
 518     // return true if the line is highlighted
 519     bool IsHighlighted(size_t line) const;
 520
 521     // refresh one or several lines at once
 522     void RefreshLine( size_t line );
 523     void RefreshLines( size_t lineFrom, size_t lineTo );
 524
 525     // refresh all selected items
 526     void RefreshSelected();
 527
 528     // refresh all lines below the given one: the difference with
 529     // RefreshLines() is that the index here might not be a valid one (happens
 530     // when the last line is deleted)
 531     void RefreshAfter( size_t lineFrom );
 532
 533     // the methods which are forwarded to wxListLineData itself in list/icon
 534     // modes but are here because the lines don't store their positions in the
 535     // report mode
 536
 537     // get the bound rect for the entire line
 538     wxRect GetLineRect(size_t line) const;
 539
 540     // get the bound rect of the label
 541     wxRect GetLineLabelRect(size_t line) const;
 542
 543     // get the bound rect of the items icon (only may be called if we do have
 544     // an icon!)
 545     wxRect GetLineIconRect(size_t line) const;
 546
 547     // get the rect to be highlighted when the item has focus
 548     wxRect GetLineHighlightRect(size_t line) const;
 549
 550     // get the size of the total line rect
 551     wxSize GetLineSize(size_t line) const
 552         { return GetLineRect(line).GetSize(); }
 553
 554     // return the hit code for the corresponding position (in this line)
 555     long HitTestLine(size_t line, int x, int y) const;
 556
 557     // bring the selected item into view, scrolling to it if necessary
 558     void MoveToItem(size_t item);
 559
 560     bool ScrollList( int WXUNUSED(dx), int dy );
 561
 562     // bring the current item into view
 563     void MoveToFocus() { MoveToItem(m_current); }
 564
 565     // start editing the label of the given item
 566     wxTextCtrl *EditLabel(long item,
 567                           wxClassInfo* textControlClass = wxCLASSINFO(wxTextCtrl));
 568     wxTextCtrl *GetEditControl() const
 569     {
 570         return m_textctrlWrapper ? m_textctrlWrapper->GetText() : NULL;
 571     }
 572
 573     void ResetTextControl(wxTextCtrl *text)
 574     {
 575         delete text;
 576         m_textctrlWrapper = NULL;
 577     }
 578
 579     void OnRenameTimer();
 580     bool OnRenameAccept(size_t itemEdit, const wxString& value);
 581     void OnRenameCancelled(size_t itemEdit);
 582
 583     void OnFindTimer();
 584     // set whether or not to ring the find bell
 585     // (does nothing on MSW - bell is always rung)
 586     void EnableBellOnNoMatch( bool on );
 587
 588     void OnMouse( wxMouseEvent &event );
 589
 590     // called to switch the selection from the current item to newCurrent,
 591     void OnArrowChar( size_t newCurrent, const wxKeyEvent& event );
 592
 593     void OnCharHook( wxKeyEvent &event );
 594     void OnChar( wxKeyEvent &event );
 595     void OnKeyDown( wxKeyEvent &event );
 596     void OnKeyUp( wxKeyEvent &event );
 597     void OnSetFocus( wxFocusEvent &event );
 598     void OnKillFocus( wxFocusEvent &event );
 599     void OnScroll( wxScrollWinEvent& event );
 600
 601     void OnPaint( wxPaintEvent &event );
 602
 603     void OnChildFocus(wxChildFocusEvent& event);
 604
 605     void DrawImage( int index, wxDC *dc, int x, int y );
 606     void GetImageSize( int index, int &width, int &height ) const;
 607
 608     void SetImageList( wxImageList *imageList, int which );
 609     void SetItemSpacing( int spacing, bool isSmall = false );
 610     int GetItemSpacing( bool isSmall = false );
 611
 612     void SetColumn( int col, const wxListItem &item );
 613     void SetColumnWidth( int col, int width );
 614     void GetColumn( int col, wxListItem &item ) const;
 615     int GetColumnWidth( int col ) const;
 616     int GetColumnCount() const { return m_columns.GetCount(); }
 617
 618     // returns the sum of the heights of all columns
 619     int GetHeaderWidth() const;
 620
 621     int GetCountPerPage() const;
 622
 623     void SetItem( wxListItem &item );
 624     void GetItem( wxListItem &item ) const;
 625     void SetItemState( long item, long state, long stateMask );
 626     void SetItemStateAll( long state, long stateMask );
 627     int GetItemState( long item, long stateMask ) const;
 628     bool GetItemRect( long item, wxRect &rect ) const
 629     {
 630         return GetSubItemRect(item, wxLIST_GETSUBITEMRECT_WHOLEITEM, rect);
 631     }
 632     bool GetSubItemRect( long item, long subItem, wxRect& rect ) const;
 633     wxRect GetViewRect() const;
 634     bool GetItemPosition( long item, wxPoint& pos ) const;
 635     int GetSelectedItemCount() const;
 636
 637     wxString GetItemText(long item, int col = 0) const
 638     {
 639         wxListItem info;
 640         info.m_mask = wxLIST_MASK_TEXT;
 641         info.m_itemId = item;
 642         info.m_col = col;
 643         GetItem( info );
 644         return info.m_text;
 645     }
 646
 647     void SetItemText(long item, const wxString& value)
 648     {
 649         wxListItem info;
 650         info.m_mask = wxLIST_MASK_TEXT;
 651         info.m_itemId = item;
 652         info.m_text = value;
 653         SetItem( info );
 654     }
 655
 656     wxImageList* GetSmallImageList() const
 657         { return m_small_image_list; }
 658
 659     // set the scrollbars and update the positions of the items
 660     void RecalculatePositions(bool noRefresh = false);
 661
 662     // refresh the window and the header
 663     void RefreshAll();
 664
 665     long GetNextItem( long item, int geometry, int state ) const;
 666     void DeleteItem( long index );
 667     void DeleteAllItems();
 668     void DeleteColumn( int col );
 669     void DeleteEverything();
 670     void EnsureVisible( long index );
 671     long FindItem( long start, const wxString& str, bool partial = false );
 672     long FindItem( long start, wxUIntPtr data);
 673     long FindItem( const wxPoint& pt );
 674     long HitTest( int x, int y, int &flags ) const;
 675     void InsertItem( wxListItem &item );
 676     long InsertColumn( long col, const wxListItem &item );
 677     int GetItemWidthWithImage(wxListItem * item);
 678     void SortItems( wxListCtrlCompare fn, wxIntPtr data );
 679
 680     size_t GetItemCount() const;
 681     bool IsEmpty() const { return GetItemCount() == 0; }
 682     void SetItemCount(long count);
 683
 684     // change the current (== focused) item, send a notification event
 685     void ChangeCurrent(size_t current);
 686     void ResetCurrent() { ChangeCurrent((size_t)-1); }
 687     bool HasCurrent() const { return m_current != (size_t)-1; }
 688
 689     // send out a wxListEvent
 690     void SendNotify( size_t line,
 691                      wxEventType command,
 692                      const wxPoint& point = wxDefaultPosition );
 693
 694     // override base class virtual to reset m_lineHeight when the font changes
 695     virtual bool SetFont(const wxFont& font)
 696     {
 697         if ( !wxWindow::SetFont(font) )
 698             return false;
 699
 700         m_lineHeight = 0;
 701
 702         return true;
 703     }
 704
 705     // these are for wxListLineData usage only
 706
 707     // get the backpointer to the list ctrl
 708     wxGenericListCtrl *GetListCtrl() const
 709     {
 710         return wxStaticCast(GetParent(), wxGenericListCtrl);
 711     }
 712
 713     // get the height of all lines (assuming they all do have the same height)
 714     wxCoord GetLineHeight() const;
 715
 716     // get the y position of the given line (only for report view)
 717     wxCoord GetLineY(size_t line) const;
 718
 719     // get the brush to use for the item highlighting
 720     wxBrush *GetHighlightBrush() const
 721     {
 722         return m_hasFocus ? m_highlightBrush : m_highlightUnfocusedBrush;
 723     }
 724
 725     bool HasFocus() const
 726     {
 727         return m_hasFocus;
 728     }
 729
 730 protected:
 731     // the array of all line objects for a non virtual list control (for the
 732     // virtual list control we only ever use m_lines[0])
 733     wxListLineDataArray  m_lines;
 734
 735     // the list of column objects
 736     wxListHeaderDataList m_columns;
 737
 738     // currently focused item or -1
 739     size_t               m_current;
 740
 741     // the number of lines per page
 742     int                  m_linesPerPage;
 743
 744     // this flag is set when something which should result in the window
 745     // redrawing happens (i.e. an item was added or deleted, or its appearance
 746     // changed) and OnPaint() doesn't redraw the window while it is set which
 747     // allows to minimize the number of repaintings when a lot of items are
 748     // being added. The real repainting occurs only after the next OnIdle()
 749     // call
 750     bool                 m_dirty;
 751
 752     wxColour            *m_highlightColour;
 753     wxImageList         *m_small_image_list;
 754     wxImageList         *m_normal_image_list;
 755     int                  m_small_spacing;
 756     int                  m_normal_spacing;
 757     bool                 m_hasFocus;
 758
 759     bool                 m_lastOnSame;
 760     wxTimer             *m_renameTimer;
 761
 762     // incremental search data
 763     wxString             m_findPrefix;
 764     wxTimer             *m_findTimer;
 765     // This flag is set to 0 if the bell is disabled, 1 if it is enabled and -1
 766     // if it is globally enabled but has been temporarily disabled because we
 767     // had already beeped for this particular search.
 768     int                  m_findBell;
 769
 770     bool                 m_isCreated;
 771     int                  m_dragCount;
 772     wxPoint              m_dragStart;
 773     ColWidthArray        m_aColWidths;
 774
 775     // for double click logic
 776     size_t m_lineLastClicked,
 777            m_lineBeforeLastClicked,
 778            m_lineSelectSingleOnUp;
 779
 780 protected:
 781     wxWindow *GetMainWindowOfCompositeControl() { return GetParent(); }
 782
 783     // the total count of items in a virtual list control
 784     size_t m_countVirt;
 785
 786     // the object maintaining the items selection state, only used in virtual
 787     // controls
 788     wxSelectionStore m_selStore;
 789
 790     // common part of all ctors
 791     void Init();
 792
 793     // get the line data for the given index
 794     wxListLineData *GetLine(size_t n) const
 795     {
 796         wxASSERT_MSG( n != (size_t)-1, wxT("invalid line index") );
 797
 798         if ( IsVirtual() )
 799         {
 800             wxConstCast(this, wxListMainWindow)->CacheLineData(n);
 801             n = 0;
 802         }
 803
 804         return &m_lines[n];
 805     }
 806
 807     // get a dummy line which can be used for geometry calculations and such:
 808     // you must use GetLine() if you want to really draw the line
 809     wxListLineData *GetDummyLine() const;
 810
 811     // cache the line data of the n-th line in m_lines[0]
 812     void CacheLineData(size_t line);
 813
 814     // get the range of visible lines
 815     void GetVisibleLinesRange(size_t *from, size_t *to);
 816
 817     // force us to recalculate the range of visible lines
 818     void ResetVisibleLinesRange() { m_lineFrom = (size_t)-1; }
 819
 820     // find the first item starting with the given prefix after the given item
 821     size_t PrefixFindItem(size_t item, const wxString& prefix) const;
 822
 823     // get the colour to be used for drawing the rules
 824     wxColour GetRuleColour() const
 825     {
 826         return wxSystemSettings::GetColour(wxSYS_COLOUR_3DLIGHT);
 827     }
 828
 829 private:
 830     // initialize the current item if needed
 831     void UpdateCurrent();
 832
 833     // delete all items but don't refresh: called from dtor
 834     void DoDeleteAllItems();
 835
 836     // Compute the minimal width needed to fully display the column header.
 837     int ComputeMinHeaderWidth(const wxListHeaderData* header) const;
 838
 839
 840     // the height of one line using the current font
 841     wxCoord m_lineHeight;
 842
 843     // the total header width or 0 if not calculated yet
 844     wxCoord m_headerWidth;
 845
 846     // the first and last lines being shown on screen right now (inclusive),
 847     // both may be -1 if they must be calculated so never access them directly:
 848     // use GetVisibleLinesRange() above instead
 849     size_t m_lineFrom,
 850            m_lineTo;
 851
 852     // the brushes to use for item highlighting when we do/don't have focus
 853     wxBrush *m_highlightBrush,
 854             *m_highlightUnfocusedBrush;
 855
 856     // wrapper around the text control currently used for in place editing or
 857     // NULL if no item is being edited
 858     wxListTextCtrlWrapper *m_textctrlWrapper;
 859
 860
 861     DECLARE_EVENT_TABLE()
 862
 863     friend class wxGenericListCtrl;
 864 };
 865
 866 #endif // wxUSE_LISTCTRL
 867 #endif // _WX_GENERIC_LISTCTRL_PRIVATE_H_