src/generic/listctrl.cpp

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