src/osx/carbon/listctrl_mac.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/osx/listctrl_mac.cpp
   3 // Purpose:     wxListCtrl
   4 // Author:      Julian Smart
   5 // Modified by: Agron Selimaj
   6 // Created:     04/01/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 // ============================================================================
  13 // declarations
  14 // ============================================================================
  15
  16 // ----------------------------------------------------------------------------
  17 // headers
  18 // ----------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_LISTCTRL
  28
  29 #include "wx/listctrl.h"
  30
  31 #ifndef WX_PRECOMP
  32     #include "wx/intl.h"
  33     #include "wx/settings.h"
  34 #endif
  35
  36 #include "wx/osx/uma.h"
  37
  38 #include "wx/imaglist.h"
  39 #include "wx/sysopt.h"
  40 #include "wx/timer.h"
  41
  42 #include "wx/hashmap.h"
  43
  44 #if wxUSE_EXTENDED_RTTI
  45 WX_DEFINE_FLAGS( wxListCtrlStyle )
  46
  47 wxBEGIN_FLAGS( wxListCtrlStyle )
  48     // new style border flags, we put them first to
  49     // use them for streaming out
  50     wxFLAGS_MEMBER(wxBORDER_SIMPLE)
  51     wxFLAGS_MEMBER(wxBORDER_SUNKEN)
  52     wxFLAGS_MEMBER(wxBORDER_DOUBLE)
  53     wxFLAGS_MEMBER(wxBORDER_RAISED)
  54     wxFLAGS_MEMBER(wxBORDER_STATIC)
  55     wxFLAGS_MEMBER(wxBORDER_NONE)
  56
  57     // old style border flags
  58     wxFLAGS_MEMBER(wxSIMPLE_BORDER)
  59     wxFLAGS_MEMBER(wxSUNKEN_BORDER)
  60     wxFLAGS_MEMBER(wxDOUBLE_BORDER)
  61     wxFLAGS_MEMBER(wxRAISED_BORDER)
  62     wxFLAGS_MEMBER(wxSTATIC_BORDER)
  63     wxFLAGS_MEMBER(wxBORDER)
  64
  65     // standard window styles
  66     wxFLAGS_MEMBER(wxTAB_TRAVERSAL)
  67     wxFLAGS_MEMBER(wxCLIP_CHILDREN)
  68     wxFLAGS_MEMBER(wxTRANSPARENT_WINDOW)
  69     wxFLAGS_MEMBER(wxWANTS_CHARS)
  70     wxFLAGS_MEMBER(wxFULL_REPAINT_ON_RESIZE)
  71     wxFLAGS_MEMBER(wxALWAYS_SHOW_SB )
  72     wxFLAGS_MEMBER(wxVSCROLL)
  73     wxFLAGS_MEMBER(wxHSCROLL)
  74
  75     wxFLAGS_MEMBER(wxLC_LIST)
  76     wxFLAGS_MEMBER(wxLC_REPORT)
  77     wxFLAGS_MEMBER(wxLC_ICON)
  78     wxFLAGS_MEMBER(wxLC_SMALL_ICON)
  79     wxFLAGS_MEMBER(wxLC_ALIGN_TOP)
  80     wxFLAGS_MEMBER(wxLC_ALIGN_LEFT)
  81     wxFLAGS_MEMBER(wxLC_AUTOARRANGE)
  82     wxFLAGS_MEMBER(wxLC_USER_TEXT)
  83     wxFLAGS_MEMBER(wxLC_EDIT_LABELS)
  84     wxFLAGS_MEMBER(wxLC_NO_HEADER)
  85     wxFLAGS_MEMBER(wxLC_SINGLE_SEL)
  86     wxFLAGS_MEMBER(wxLC_SORT_ASCENDING)
  87     wxFLAGS_MEMBER(wxLC_SORT_DESCENDING)
  88     wxFLAGS_MEMBER(wxLC_VIRTUAL)
  89
  90 wxEND_FLAGS( wxListCtrlStyle )
  91
  92 IMPLEMENT_DYNAMIC_CLASS_XTI(wxListCtrl, wxControl,"wx/listctrl.h")
  93
  94 wxBEGIN_PROPERTIES_TABLE(wxListCtrl)
  95     wxEVENT_PROPERTY( TextUpdated , wxEVT_COMMAND_TEXT_UPDATED , wxCommandEvent )
  96
  97     wxPROPERTY_FLAGS( WindowStyle , wxListCtrlStyle , long , SetWindowStyleFlag , GetWindowStyleFlag , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) // style
  98 wxEND_PROPERTIES_TABLE()
  99
 100 wxBEGIN_HANDLERS_TABLE(wxListCtrl)
 101 wxEND_HANDLERS_TABLE()
 102
 103 wxCONSTRUCTOR_5( wxListCtrl , wxWindow* , Parent , wxWindowID , Id , wxPoint , Position , wxSize , Size , long , WindowStyle )
 104
 105 /*
 106  TODO : Expose more information of a list's layout etc. via appropriate objects (a la NotebookPageInfo)
 107 */
 108 #else
 109 IMPLEMENT_DYNAMIC_CLASS(wxListCtrl, wxControl)
 110 #endif
 111
 112 IMPLEMENT_DYNAMIC_CLASS(wxListView, wxListCtrl)
 113 IMPLEMENT_DYNAMIC_CLASS(wxListItem, wxObject)
 114
 115 IMPLEMENT_DYNAMIC_CLASS(wxListEvent, wxNotifyEvent)
 116
 117 WX_DECLARE_HASH_MAP( int, wxListItem*, wxIntegerHash, wxIntegerEqual, wxListItemList );
 118
 119 #include "wx/listimpl.cpp"
 120 WX_DEFINE_LIST(wxColumnList)
 121
 122 // so we can check for column clicks
 123 static const EventTypeSpec eventList[] =
 124 {
 125     { kEventClassControl, kEventControlHit },
 126     { kEventClassControl, kEventControlDraw }
 127 };
 128
 129 static pascal OSStatus wxMacListCtrlEventHandler( EventHandlerCallRef handler , EventRef event , void *data )
 130 {
 131     OSStatus result = eventNotHandledErr ;
 132
 133     wxMacCarbonEvent cEvent( event ) ;
 134
 135     ControlRef controlRef ;
 136     cEvent.GetParameter( kEventParamDirectObject , &controlRef ) ;
 137
 138     wxListCtrl *window = (wxListCtrl*) data ;
 139     wxListEvent le( wxEVT_COMMAND_LIST_COL_CLICK, window->GetId() );
 140     le.SetEventObject( window );
 141
 142     switch ( GetEventKind( event ) )
 143     {
 144         // check if the column was clicked on and fire an event if so
 145         case kEventControlHit :
 146             {
 147                 ControlPartCode result = cEvent.GetParameter<ControlPartCode>(kEventParamControlPart, typeControlPartCode) ;
 148                 if (result == kControlButtonPart){
 149                     DataBrowserPropertyID col;
 150                     GetDataBrowserSortProperty(controlRef, &col);
 151
 152                     DataBrowserTableViewColumnIndex column = 0;
 153                     verify_noerr( GetDataBrowserTableViewColumnPosition( controlRef, col, &column ) );
 154
 155                     le.m_col = column;
 156                     // FIXME: we can't use the sort property for virtual listctrls
 157                     // so we need to find a better way to determine which column was clicked...
 158                     if (!window->IsVirtual())
 159                         window->HandleWindowEvent( le );
 160                 }
 161                 result = CallNextEventHandler(handler, event);
 162                 break;
 163             }
 164         case kEventControlDraw:
 165             {
 166                 CGContextRef context = cEvent.GetParameter<CGContextRef>(kEventParamCGContextRef, typeCGContextRef) ;
 167                 window->MacSetDrawingContext(context);
 168                 result = CallNextEventHandler(handler, event);
 169                 window->MacSetDrawingContext(NULL);
 170                 break;
 171             }
 172         default :
 173             break ;
 174     }
 175
 176
 177     return result ;
 178 }
 179
 180 DEFINE_ONE_SHOT_HANDLER_GETTER( wxMacListCtrlEventHandler )
 181
 182 class wxMacListCtrlItem : public wxMacDataItem
 183 {
 184 public:
 185     wxMacListCtrlItem();
 186
 187     virtual void Notification(wxMacDataItemBrowserControl *owner ,
 188         DataBrowserItemNotification message,
 189         DataBrowserItemDataRef itemData ) const;
 190
 191     virtual void SetColumnInfo( unsigned int column, wxListItem* item );
 192     virtual wxListItem* GetColumnInfo( unsigned int column );
 193     virtual bool HasColumnInfo( unsigned int column );
 194
 195     virtual void SetColumnTextValue( unsigned int column, const wxString& text );
 196     virtual wxString GetColumnTextValue( unsigned int column );
 197
 198     virtual int GetColumnImageValue( unsigned int column );
 199     virtual void SetColumnImageValue( unsigned int column, int imageIndex );
 200
 201     virtual ~wxMacListCtrlItem();
 202 protected:
 203     wxListItemList m_rowItems;
 204 };
 205
 206 DataBrowserDrawItemUPP gDataBrowserDrawItemUPP = NULL;
 207 //DataBrowserEditItemUPP gDataBrowserEditItemUPP = NULL;
 208 DataBrowserHitTestUPP gDataBrowserHitTestUPP = NULL;
 209
 210 // TODO: Make a better name!!
 211 class wxMacDataBrowserListCtrlControl : public wxMacDataItemBrowserControl
 212 {
 213 public:
 214     wxMacDataBrowserListCtrlControl( wxWindow *peer, const wxPoint& pos, const wxSize& size, long style );
 215     wxMacDataBrowserListCtrlControl() {}
 216     virtual ~wxMacDataBrowserListCtrlControl();
 217
 218     // create a list item (can be a subclass of wxMacListBoxItem)
 219
 220     virtual void MacInsertItem( unsigned int n, wxListItem* item );
 221     virtual void MacSetColumnInfo( unsigned int row, unsigned int column, wxListItem* item );
 222     virtual void MacGetColumnInfo( unsigned int row, unsigned int column, wxListItem& item );
 223     virtual void UpdateState(wxMacDataItem* dataItem, wxListItem* item);
 224     int GetFlags() { return m_flags; }
 225
 226 protected:
 227     // we need to override to provide specialized handling for virtual wxListCtrls
 228     virtual OSStatus GetSetItemData(DataBrowserItemID itemID,
 229                         DataBrowserPropertyID property,
 230                         DataBrowserItemDataRef itemData,
 231                         Boolean changeValue );
 232
 233     virtual void    ItemNotification(
 234                         DataBrowserItemID itemID,
 235                         DataBrowserItemNotification message,
 236                         DataBrowserItemDataRef itemData);
 237
 238     virtual Boolean CompareItems(DataBrowserItemID itemOneID,
 239                         DataBrowserItemID itemTwoID,
 240                         DataBrowserPropertyID sortProperty);
 241
 242     static pascal void    DataBrowserDrawItemProc(ControlRef browser,
 243                         DataBrowserItemID item,
 244                         DataBrowserPropertyID property,
 245                         DataBrowserItemState itemState,
 246                         const Rect *theRect,
 247                         SInt16 gdDepth,
 248                         Boolean colorDevice);
 249
 250     virtual void        DrawItem(DataBrowserItemID itemID,
 251                             DataBrowserPropertyID property,
 252                             DataBrowserItemState itemState,
 253                             const Rect *itemRect,
 254                             SInt16 gdDepth,
 255                             Boolean colorDevice);
 256
 257     static pascal Boolean  DataBrowserEditTextProc(ControlRef browser,
 258                                     DataBrowserItemID item,
 259                                     DataBrowserPropertyID property,
 260                                     CFStringRef theString,
 261                                     Rect *maxEditTextRect,
 262                                     Boolean *shrinkToFit);
 263
 264     static pascal Boolean  DataBrowserHitTestProc(ControlRef WXUNUSED(browser),
 265                                     DataBrowserItemID WXUNUSED(itemID),
 266                                     DataBrowserPropertyID WXUNUSED(property),
 267                                     const Rect *WXUNUSED(theRect),
 268                                     const Rect *WXUNUSED(mouseRect)) { return true; }
 269
 270     virtual bool        ConfirmEditText(DataBrowserItemID item,
 271                                     DataBrowserPropertyID property,
 272                                     CFStringRef theString,
 273                                     Rect *maxEditTextRect,
 274                                     Boolean *shrinkToFit);
 275
 276
 277
 278     wxClientDataType m_clientDataItemsType;
 279     bool m_isVirtual;
 280     int m_flags;
 281     DECLARE_DYNAMIC_CLASS_NO_COPY(wxMacDataBrowserListCtrlControl)
 282 };
 283
 284 class wxMacListCtrlEventDelegate : public wxEvtHandler
 285 {
 286 public:
 287     wxMacListCtrlEventDelegate( wxListCtrl* list, int id );
 288     virtual bool ProcessEvent( wxEvent& event );
 289
 290 private:
 291     wxListCtrl* m_list;
 292     int         m_id;
 293 };
 294
 295 wxMacListCtrlEventDelegate::wxMacListCtrlEventDelegate( wxListCtrl* list, int id )
 296 {
 297     m_list = list;
 298     m_id = id;
 299 }
 300
 301 bool wxMacListCtrlEventDelegate::ProcessEvent( wxEvent& event )
 302 {
 303     int id = event.GetId();
 304     wxObject* obj = event.GetEventObject();
 305
 306     // even though we use a generic list ctrl underneath, make sure
 307     // we present ourselves as wxListCtrl.
 308     event.SetEventObject( m_list );
 309     event.SetId( m_id );
 310
 311     if ( !event.IsKindOf( CLASSINFO( wxCommandEvent ) ) )
 312     {
 313         if (m_list->GetEventHandler()->ProcessEvent( event ))
 314         {
 315             event.SetId(id);
 316             event.SetEventObject(obj);
 317             return true;
 318         }
 319     }
 320     // Also try with the original id
 321     bool success = wxEvtHandler::ProcessEvent(event);
 322     event.SetId(id);
 323     event.SetEventObject(obj);
 324     if (!success && id != m_id)
 325         success = wxEvtHandler::ProcessEvent(event);
 326     return success;
 327 }
 328
 329 //-----------------------------------------------------------------------------
 330 // wxListCtrlRenameTimer (internal)
 331 //-----------------------------------------------------------------------------
 332
 333 class wxListCtrlRenameTimer: public wxTimer
 334 {
 335 private:
 336     wxListCtrl *m_owner;
 337
 338 public:
 339     wxListCtrlRenameTimer( wxListCtrl *owner );
 340     void Notify();
 341 };
 342
 343 //-----------------------------------------------------------------------------
 344 // wxListCtrlTextCtrlWrapper: wraps a wxTextCtrl to make it work for inline editing
 345 //-----------------------------------------------------------------------------
 346
 347 class wxListCtrlTextCtrlWrapper : public wxEvtHandler
 348 {
 349 public:
 350     // NB: text must be a valid object but not Create()d yet
 351     wxListCtrlTextCtrlWrapper(wxListCtrl *owner,
 352                           wxTextCtrl *text,
 353                           long itemEdit);
 354
 355     wxTextCtrl *GetText() const { return m_text; }
 356
 357     void AcceptChangesAndFinish();
 358
 359 protected:
 360     void OnChar( wxKeyEvent &event );
 361     void OnKeyUp( wxKeyEvent &event );
 362     void OnKillFocus( wxFocusEvent &event );
 363
 364     bool AcceptChanges();
 365     void Finish();
 366
 367 private:
 368     wxListCtrl         *m_owner;
 369     wxTextCtrl         *m_text;
 370     wxString            m_startValue;
 371     long              m_itemEdited;
 372     bool                m_finished;
 373     bool                m_aboutToFinish;
 374
 375     DECLARE_EVENT_TABLE()
 376 };
 377
 378 //-----------------------------------------------------------------------------
 379 // wxListCtrlRenameTimer (internal)
 380 //-----------------------------------------------------------------------------
 381
 382 wxListCtrlRenameTimer::wxListCtrlRenameTimer( wxListCtrl *owner )
 383 {
 384     m_owner = owner;
 385 }
 386
 387 void wxListCtrlRenameTimer::Notify()
 388 {
 389     m_owner->OnRenameTimer();
 390 }
 391
 392 //-----------------------------------------------------------------------------
 393 // wxListCtrlTextCtrlWrapper (internal)
 394 //-----------------------------------------------------------------------------
 395
 396 BEGIN_EVENT_TABLE(wxListCtrlTextCtrlWrapper, wxEvtHandler)
 397     EVT_CHAR           (wxListCtrlTextCtrlWrapper::OnChar)
 398     EVT_KEY_UP         (wxListCtrlTextCtrlWrapper::OnKeyUp)
 399     EVT_KILL_FOCUS     (wxListCtrlTextCtrlWrapper::OnKillFocus)
 400 END_EVENT_TABLE()
 401
 402 wxListCtrlTextCtrlWrapper::wxListCtrlTextCtrlWrapper(wxListCtrl *owner,
 403                                              wxTextCtrl *text,
 404                                              long itemEdit)
 405               : m_startValue(owner->GetItemText(itemEdit)),
 406                 m_itemEdited(itemEdit)
 407 {
 408     m_owner = owner;
 409     m_text = text;
 410     m_finished = false;
 411     m_aboutToFinish = false;
 412
 413     wxRect rectLabel;
 414     int offset = 8;
 415     owner->GetItemRect(itemEdit, rectLabel);
 416
 417     m_text->Create(owner, wxID_ANY, m_startValue,
 418                    wxPoint(rectLabel.x+offset,rectLabel.y),
 419                    wxSize(rectLabel.width-offset,rectLabel.height));
 420     m_text->SetFocus();
 421
 422     m_text->PushEventHandler(this);
 423 }
 424
 425 void wxListCtrlTextCtrlWrapper::Finish()
 426 {
 427     if ( !m_finished )
 428     {
 429         m_finished = true;
 430
 431         m_text->RemoveEventHandler(this);
 432         m_owner->FinishEditing(m_text);
 433
 434         wxPendingDelete.Append( this );
 435     }
 436 }
 437
 438 bool wxListCtrlTextCtrlWrapper::AcceptChanges()
 439 {
 440     const wxString value = m_text->GetValue();
 441
 442     if ( value == m_startValue )
 443         // nothing changed, always accept
 444         return true;
 445
 446     if ( !m_owner->OnRenameAccept(m_itemEdited, value) )
 447         // vetoed by the user
 448         return false;
 449
 450     // accepted, do rename the item
 451     m_owner->SetItemText(m_itemEdited, value);
 452
 453     return true;
 454 }
 455
 456 void wxListCtrlTextCtrlWrapper::AcceptChangesAndFinish()
 457 {
 458     m_aboutToFinish = true;
 459
 460     // Notify the owner about the changes
 461     AcceptChanges();
 462
 463     // Even if vetoed, close the control (consistent with MSW)
 464     Finish();
 465 }
 466
 467 void wxListCtrlTextCtrlWrapper::OnChar( wxKeyEvent &event )
 468 {
 469     switch ( event.m_keyCode )
 470     {
 471         case WXK_RETURN:
 472             AcceptChangesAndFinish();
 473             break;
 474
 475         case WXK_ESCAPE:
 476             m_owner->OnRenameCancelled( m_itemEdited );
 477             Finish();
 478             break;
 479
 480         default:
 481             event.Skip();
 482     }
 483 }
 484
 485 void wxListCtrlTextCtrlWrapper::OnKeyUp( wxKeyEvent &event )
 486 {
 487     if (m_finished)
 488     {
 489         event.Skip();
 490         return;
 491     }
 492
 493     // auto-grow the textctrl:
 494     wxSize parentSize = m_owner->GetSize();
 495     wxPoint myPos = m_text->GetPosition();
 496     wxSize mySize = m_text->GetSize();
 497     int sx, sy;
 498     m_text->GetTextExtent(m_text->GetValue() + wxT("MM"), &sx, &sy);
 499     if (myPos.x + sx > parentSize.x)
 500         sx = parentSize.x - myPos.x;
 501     if (mySize.x > sx)
 502         sx = mySize.x;
 503     m_text->SetSize(sx, wxDefaultCoord);
 504
 505     event.Skip();
 506 }
 507
 508 void wxListCtrlTextCtrlWrapper::OnKillFocus( wxFocusEvent &event )
 509 {
 510     if ( !m_finished && !m_aboutToFinish )
 511     {
 512         if ( !AcceptChanges() )
 513             m_owner->OnRenameCancelled( m_itemEdited );
 514
 515         Finish();
 516     }
 517
 518     // We must let the native text control handle focus
 519     event.Skip();
 520 }
 521
 522 BEGIN_EVENT_TABLE(wxListCtrl, wxControl)
 523     EVT_LEFT_DOWN(wxListCtrl::OnLeftDown)
 524     EVT_LEFT_DCLICK(wxListCtrl::OnDblClick)
 525     EVT_MIDDLE_DOWN(wxListCtrl::OnMiddleDown)
 526     EVT_RIGHT_DOWN(wxListCtrl::OnRightDown)
 527     EVT_CHAR(wxListCtrl::OnChar)
 528 END_EVENT_TABLE()
 529
 530 // ============================================================================
 531 // implementation
 532 // ============================================================================
 533
 534 wxMacDataBrowserListCtrlControl* wxListCtrl::GetListPeer() const
 535 {
 536     return dynamic_cast<wxMacDataBrowserListCtrlControl*> ( GetPeer() );
 537 }
 538
 539 // ----------------------------------------------------------------------------
 540 // wxListCtrl construction
 541 // ----------------------------------------------------------------------------
 542
 543 void wxListCtrl::Init()
 544 {
 545     m_imageListNormal = NULL;
 546     m_imageListSmall = NULL;
 547     m_imageListState = NULL;
 548
 549     // keep track of if we created our own image lists, or if they were assigned
 550     // to us.
 551     m_ownsImageListNormal = m_ownsImageListSmall = m_ownsImageListState = false;
 552     m_colCount = 0;
 553     m_count = 0;
 554     m_textCtrl = NULL;
 555     m_genericImpl = NULL;
 556     m_dbImpl = NULL;
 557     m_compareFunc = NULL;
 558     m_compareFuncData = 0;
 559     m_colsInfo = wxColumnList();
 560     m_textColor = wxNullColour;
 561     m_bgColor = wxNullColour;
 562     m_textctrlWrapper = NULL;
 563     m_current = -1;
 564     m_renameTimer = new wxListCtrlRenameTimer( this );
 565 }
 566
 567 class wxGenericListCtrlHook : public wxGenericListCtrl
 568 {
 569 public:
 570     wxGenericListCtrlHook(wxListCtrl* parent,
 571                           wxWindowID id,
 572                           const wxPoint& pos,
 573                           const wxSize& size,
 574                           long style,
 575                           const wxValidator& validator,
 576                           const wxString& name)
 577         : wxGenericListCtrl(parent, id, pos, size, style, validator, name),
 578           m_nativeListCtrl(parent)
 579     {
 580     }
 581
 582 protected:
 583     virtual wxListItemAttr * OnGetItemAttr(long item) const
 584     {
 585         return m_nativeListCtrl->OnGetItemAttr(item);
 586     }
 587
 588     virtual int OnGetItemImage(long item) const
 589     {
 590         return m_nativeListCtrl->OnGetItemImage(item);
 591     }
 592
 593     virtual int OnGetItemColumnImage(long item, long column) const
 594     {
 595         return m_nativeListCtrl->OnGetItemColumnImage(item, column);
 596     }
 597
 598     virtual wxString OnGetItemText(long item, long column) const
 599     {
 600         return m_nativeListCtrl->OnGetItemText(item, column);
 601     }
 602
 603     wxListCtrl* m_nativeListCtrl;
 604
 605 };
 606
 607 void wxListCtrl::OnLeftDown(wxMouseEvent& event)
 608 {
 609     if ( m_textctrlWrapper )
 610     {
 611         m_current = -1;
 612         m_textctrlWrapper->AcceptChangesAndFinish();
 613     }
 614
 615     int hitResult;
 616     long current = HitTest(event.GetPosition(), hitResult);
 617     if ((current == m_current) &&
 618         (hitResult & wxLIST_HITTEST_ONITEMLABEL) &&
 619         HasFlag(wxLC_EDIT_LABELS) )
 620     {
 621         m_renameTimer->Start( 100, true );
 622     }
 623     else
 624     {
 625         m_current = current;
 626     }
 627     event.Skip();
 628 }
 629
 630 void wxListCtrl::OnDblClick(wxMouseEvent& event)
 631 {
 632     if ( m_renameTimer->IsRunning() )
 633         m_renameTimer->Stop();
 634     event.Skip();
 635 }
 636
 637 #if wxABI_VERSION >= 20801
 638 void wxListCtrl::OnRightDown(wxMouseEvent& event)
 639 {
 640     if (m_dbImpl)
 641         FireMouseEvent(wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK, event.GetPosition());
 642     event.Skip();
 643 }
 644
 645 void wxListCtrl::OnMiddleDown(wxMouseEvent& event)
 646 {
 647     if (m_dbImpl)
 648         FireMouseEvent(wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK, event.GetPosition());
 649     event.Skip();
 650 }
 651
 652 void wxListCtrl::FireMouseEvent(wxEventType eventType, wxPoint position)
 653 {
 654     wxListEvent le( eventType, GetId() );
 655     le.SetEventObject(this);
 656     le.m_pointDrag = position;
 657     le.m_itemIndex = -1;
 658
 659     int flags;
 660     long item = HitTest(position, flags);
 661     if (flags & wxLIST_HITTEST_ONITEM)
 662     {
 663         le.m_itemIndex = item;
 664         le.m_item.m_itemId = item;
 665         GetItem(le.m_item);
 666         HandleWindowEvent(le);
 667     }
 668 }
 669
 670 void wxListCtrl::OnChar(wxKeyEvent& event)
 671 {
 672
 673
 674     if (m_dbImpl)
 675     {
 676         wxListEvent le( wxEVT_COMMAND_LIST_KEY_DOWN, GetId() );
 677         le.SetEventObject(this);
 678         le.m_code = event.GetKeyCode();
 679         le.m_itemIndex = -1;
 680
 681         if (m_current == -1)
 682         {
 683             // if m_current isn't set, check if there's been a selection
 684             // made before continuing
 685             m_current = GetNextItem(-1, wxLIST_NEXT_BELOW, wxLIST_STATE_SELECTED);
 686         }
 687
 688         // We need to determine m_current ourselves when navigation keys
 689         // are used. Note that PAGEUP and PAGEDOWN do not alter the current
 690         // item on native Mac ListCtrl, so we only handle up and down keys.
 691         switch ( event.GetKeyCode() )
 692         {
 693             case WXK_UP:
 694                 if ( m_current > 0 )
 695                     m_current -= 1;
 696                 else
 697                     m_current = 0;
 698
 699                 break;
 700
 701             case WXK_DOWN:
 702                 if ( m_current < GetItemCount() - 1 )
 703                     m_current += 1;
 704                 else
 705                     m_current = GetItemCount() - 1;
 706
 707                 break;
 708         }
 709
 710         if (m_current != -1)
 711         {
 712             le.m_itemIndex = m_current;
 713             le.m_item.m_itemId = m_current;
 714             GetItem(le.m_item);
 715             HandleWindowEvent(le);
 716         }
 717     }
 718     event.Skip();
 719 }
 720 #endif
 721
 722 bool wxListCtrl::Create(wxWindow *parent,
 723                         wxWindowID id,
 724                         const wxPoint& pos,
 725                         const wxSize& size,
 726                         long style,
 727                         const wxValidator& validator,
 728                         const wxString& name)
 729 {
 730
 731     // for now, we'll always use the generic list control for ICON and LIST views,
 732     // because they dynamically change the number of columns on resize.
 733     // Also, allow the user to set it to use the list ctrl as well.
 734     if ( (wxSystemOptions::HasOption( wxMAC_ALWAYS_USE_GENERIC_LISTCTRL )
 735             && (wxSystemOptions::GetOptionInt( wxMAC_ALWAYS_USE_GENERIC_LISTCTRL ) == 1)) ||
 736             (style & wxLC_ICON) || (style & wxLC_SMALL_ICON) || (style & wxLC_LIST) )
 737     {
 738         m_macIsUserPane = true;
 739
 740         long paneStyle = style;
 741         paneStyle &= ~wxSIMPLE_BORDER;
 742         paneStyle &= ~wxDOUBLE_BORDER;
 743         paneStyle &= ~wxSUNKEN_BORDER;
 744         paneStyle &= ~wxRAISED_BORDER;
 745         paneStyle &= ~wxSTATIC_BORDER;
 746         if ( !wxWindow::Create(parent, id, pos, size, paneStyle | wxNO_BORDER, name) )
 747             return false;
 748
 749         // since the generic control is a child, make sure we position it at 0, 0
 750         m_genericImpl = new wxGenericListCtrlHook(this, id, wxPoint(0, 0), size, style, validator, name);
 751         m_genericImpl->PushEventHandler( new wxMacListCtrlEventDelegate( this, GetId() ) );
 752         return true;
 753     }
 754
 755     else
 756     {
 757          m_macIsUserPane = false;
 758         if ( !wxWindow::Create(parent, id, pos, size, style & ~(wxHSCROLL | wxVSCROLL), name) )
 759             return false;
 760         m_dbImpl = new wxMacDataBrowserListCtrlControl( this, pos, size, style );
 761         m_peer = m_dbImpl;
 762
 763         MacPostControlCreate( pos, size );
 764
 765         InstallControlEventHandler( m_peer->GetControlRef() , GetwxMacListCtrlEventHandlerUPP(),
 766             GetEventTypeCount(eventList), eventList, this,
 767             (EventHandlerRef *)&m_macListCtrlEventHandler);
 768     }
 769
 770     return true;
 771 }
 772
 773 wxListCtrl::~wxListCtrl()
 774 {
 775     if (m_genericImpl)
 776     {
 777         m_genericImpl->PopEventHandler(/* deleteHandler = */ true);
 778     }
 779
 780     if (m_ownsImageListNormal)
 781         delete m_imageListNormal;
 782     if (m_ownsImageListSmall)
 783         delete m_imageListSmall;
 784     if (m_ownsImageListState)
 785         delete m_imageListState;
 786
 787     delete m_renameTimer;
 788
 789     WX_CLEAR_LIST(wxColumnList, m_colsInfo);
 790 }
 791
 792 /*static*/
 793 wxVisualAttributes
 794 wxListCtrl::GetClassDefaultAttributes(wxWindowVariant WXUNUSED(variant))
 795 {
 796     wxVisualAttributes attr;
 797
 798     attr.colFg = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
 799     attr.colBg = wxSystemSettings::GetColour( wxSYS_COLOUR_LISTBOX );
 800     attr.font.CreateSystemFont(wxOSX_SYSTEM_FONT_VIEWS);
 801
 802     return attr;
 803 }
 804
 805 // ----------------------------------------------------------------------------
 806 // set/get/change style
 807 // ----------------------------------------------------------------------------
 808
 809 // Add or remove a single window style
 810 void wxListCtrl::SetSingleStyle(long style, bool add)
 811 {
 812     long flag = GetWindowStyleFlag();
 813
 814     // Get rid of conflicting styles
 815     if ( add )
 816     {
 817         if ( style & wxLC_MASK_TYPE)
 818             flag = flag & ~wxLC_MASK_TYPE;
 819         if ( style & wxLC_MASK_ALIGN )
 820             flag = flag & ~wxLC_MASK_ALIGN;
 821         if ( style & wxLC_MASK_SORT )
 822             flag = flag & ~wxLC_MASK_SORT;
 823     }
 824
 825     if ( add )
 826         flag |= style;
 827     else
 828         flag &= ~style;
 829
 830     SetWindowStyleFlag(flag);
 831 }
 832
 833 // Set the whole window style
 834 void wxListCtrl::SetWindowStyleFlag(long flag)
 835 {
 836     if ( flag != m_windowStyle )
 837     {
 838         m_windowStyle = flag;
 839
 840         if (m_genericImpl)
 841         {
 842             m_genericImpl->SetWindowStyleFlag(flag);
 843         }
 844
 845         Refresh();
 846     }
 847 }
 848
 849 void wxListCtrl::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 850 {
 851     wxControl::DoSetSize(x, y, width, height, sizeFlags);
 852
 853     if (m_genericImpl)
 854         m_genericImpl->SetSize(0, 0, width, height, sizeFlags);
 855
 856     // determine if we need a horizontal scrollbar, and add it if so
 857     if (m_dbImpl)
 858     {
 859         int totalWidth = 0;
 860         for (int column = 0; column < GetColumnCount(); column++)
 861         {
 862               totalWidth += m_dbImpl->GetColumnWidth( column );
 863         }
 864
 865         if ( !(m_dbImpl->GetFlags() & wxHSCROLL) )
 866         {
 867             Boolean vertScrollBar;
 868             GetDataBrowserHasScrollBars( m_dbImpl->GetControlRef(), NULL, &vertScrollBar );
 869             if (totalWidth > width)
 870                 SetDataBrowserHasScrollBars( m_dbImpl->GetControlRef(), true, vertScrollBar );
 871             else
 872                 SetDataBrowserHasScrollBars( m_dbImpl->GetControlRef(), false, vertScrollBar );
 873         }
 874     }
 875 }
 876
 877 wxSize wxListCtrl::DoGetBestSize() const
 878 {
 879     return wxWindow::DoGetBestSize();
 880 }
 881
 882 bool wxListCtrl::SetFont(const wxFont& font)
 883 {
 884     bool rv = true;
 885     rv = wxControl::SetFont(font);
 886     if (m_genericImpl)
 887         rv = m_genericImpl->SetFont(font);
 888     return rv;
 889 }
 890
 891 bool wxListCtrl::SetForegroundColour(const wxColour& colour)
 892 {
 893     bool rv = true;
 894     if (m_genericImpl)
 895         rv = m_genericImpl->SetForegroundColour(colour);
 896     if (m_dbImpl)
 897         SetTextColour(colour);
 898     return rv;
 899 }
 900
 901 bool wxListCtrl::SetBackgroundColour(const wxColour& colour)
 902 {
 903     bool rv = true;
 904     if (m_genericImpl)
 905         rv = m_genericImpl->SetBackgroundColour(colour);
 906     if (m_dbImpl)
 907         m_bgColor = colour;
 908     return rv;
 909 }
 910
 911 wxColour wxListCtrl::GetBackgroundColour() const
 912 {
 913     if (m_genericImpl)
 914         return m_genericImpl->GetBackgroundColour();
 915     if (m_dbImpl)
 916         return m_bgColor;
 917
 918     return wxNullColour;
 919 }
 920
 921 void wxListCtrl::Freeze ()
 922 {
 923     if (m_genericImpl)
 924         m_genericImpl->Freeze();
 925     wxControl::Freeze();
 926 }
 927
 928 void wxListCtrl::Thaw ()
 929 {
 930     if (m_genericImpl)
 931         m_genericImpl->Thaw();
 932     wxControl::Thaw();
 933 }
 934
 935 void wxListCtrl::Update ()
 936 {
 937     if (m_genericImpl)
 938         m_genericImpl->Update();
 939     wxControl::Update();
 940 }
 941
 942 // ----------------------------------------------------------------------------
 943 // accessors
 944 // ----------------------------------------------------------------------------
 945
 946 // Gets information about this column
 947 bool wxListCtrl::GetColumn(int col, wxListItem& item) const
 948 {
 949     if (m_genericImpl)
 950         return m_genericImpl->GetColumn(col, item);
 951
 952     bool success = true;
 953
 954     if (m_dbImpl)
 955     {
 956         wxColumnList::compatibility_iterator node = m_colsInfo.Item( col );
 957         wxASSERT_MSG( node, wxT("invalid column index in wxMacListCtrlItem") );
 958         wxListItem* column = node->GetData();
 959
 960         long mask = column->GetMask();
 961         if (mask & wxLIST_MASK_TEXT)
 962             item.SetText(column->GetText());
 963         if (mask & wxLIST_MASK_DATA)
 964             item.SetData(column->GetData());
 965         if (mask & wxLIST_MASK_IMAGE)
 966             item.SetImage(column->GetImage());
 967         if (mask & wxLIST_MASK_STATE)
 968             item.SetState(column->GetState());
 969         if (mask & wxLIST_MASK_FORMAT)
 970             item.SetAlign(column->GetAlign());
 971         if (mask & wxLIST_MASK_WIDTH)
 972             item.SetWidth(column->GetWidth());
 973     }
 974
 975     return success;
 976 }
 977
 978 // Sets information about this column
 979 bool wxListCtrl::SetColumn(int col, wxListItem& item)
 980 {
 981     if (m_genericImpl)
 982         return m_genericImpl->SetColumn(col, item);
 983
 984     if (m_dbImpl)
 985     {
 986         wxASSERT_MSG( col < (int)m_colsInfo.GetCount(), wxT("invalid column index in wxMacListCtrlItem") );
 987
 988         long mask = item.GetMask();
 989         {
 990             wxListItem listItem;
 991             GetColumn( col, listItem );
 992
 993             if (mask & wxLIST_MASK_TEXT)
 994                 listItem.SetText(item.GetText());
 995             if (mask & wxLIST_MASK_DATA)
 996                 listItem.SetData(item.GetData());
 997             if (mask & wxLIST_MASK_IMAGE)
 998                 listItem.SetImage(item.GetImage());
 999             if (mask & wxLIST_MASK_STATE)
1000                 listItem.SetState(item.GetState());
1001             if (mask & wxLIST_MASK_FORMAT)
1002                 listItem.SetAlign(item.GetAlign());
1003             if (mask & wxLIST_MASK_WIDTH)
1004                 listItem.SetWidth(item.GetWidth());
1005         }
1006
1007         // change the appearance in the databrowser.
1008         DataBrowserListViewHeaderDesc columnDesc;
1009         columnDesc.version=kDataBrowserListViewLatestHeaderDesc;
1010
1011         DataBrowserTableViewColumnID id = 0;
1012         verify_noerr( m_dbImpl->GetColumnIDFromIndex( col, &id ) );
1013         verify_noerr( m_dbImpl->GetHeaderDesc( id, &columnDesc ) );
1014
1015         /*
1016         if (item.GetMask() & wxLIST_MASK_TEXT)
1017         {
1018             wxFontEncoding enc;
1019             if ( m_font.Ok() )
1020                 enc = GetFont().GetEncoding();
1021             else
1022                 enc = wxLocale::GetSystemEncoding();
1023             wxCFStringRef cfTitle;
1024             cfTitle.Assign( item.GetText() , enc );
1025             if(columnDesc.titleString)
1026                 CFRelease(columnDesc.titleString);
1027             columnDesc.titleString = cfTitle;
1028         }
1029         */
1030
1031         if (item.GetMask() & wxLIST_MASK_IMAGE && item.GetImage() != -1 )
1032         {
1033             wxImageList* imageList = GetImageList(wxIMAGE_LIST_SMALL);
1034             if (imageList && imageList->GetImageCount() > 0 )
1035             {
1036                 wxBitmap bmp = imageList->GetBitmap( item.GetImage() );
1037                 IconRef icon = bmp.GetIconRef();
1038                 columnDesc.btnContentInfo.u.iconRef = icon;
1039                 columnDesc.btnContentInfo.contentType = kControlContentIconRef;
1040             }
1041         }
1042
1043         verify_noerr( m_dbImpl->SetHeaderDesc( id, &columnDesc ) );
1044
1045     }
1046     return true;
1047 }
1048
1049 int wxListCtrl::GetColumnCount() const
1050 {
1051     if (m_genericImpl)
1052         return m_genericImpl->GetColumnCount();
1053
1054     if (m_dbImpl)
1055     {
1056         UInt32 count;
1057         m_dbImpl->GetColumnCount(&count);
1058         return count;
1059     }
1060
1061     return m_colCount;
1062 }
1063
1064 // Gets the column width
1065 int wxListCtrl::GetColumnWidth(int col) const
1066 {
1067     if (m_genericImpl)
1068         return m_genericImpl->GetColumnWidth(col);
1069
1070     if (m_dbImpl)
1071     {
1072         return m_dbImpl->GetColumnWidth(col);
1073     }
1074
1075     return 0;
1076 }
1077
1078 // Sets the column width
1079 bool wxListCtrl::SetColumnWidth(int col, int width)
1080 {
1081     if (m_genericImpl)
1082         return m_genericImpl->SetColumnWidth(col, width);
1083
1084     if (m_dbImpl)
1085     {
1086         if ( width == wxLIST_AUTOSIZE_USEHEADER )
1087         {
1088             width = 150; // FIXME
1089         }
1090
1091         if (col == -1)
1092         {
1093             for (int column = 0; column < GetColumnCount(); column++)
1094             {
1095                 wxListItem colInfo;
1096                 GetColumn(column, colInfo);
1097
1098                 colInfo.SetWidth(width);
1099                 SetColumn(column, colInfo);
1100
1101                 const int mywidth = (width == wxLIST_AUTOSIZE)
1102                                     ? CalcColumnAutoWidth(column) : width;
1103                 m_dbImpl->SetColumnWidth(column, mywidth);
1104             }
1105         }
1106         else
1107         {
1108             if ( width == wxLIST_AUTOSIZE )
1109                 width = CalcColumnAutoWidth(col);
1110
1111             wxListItem colInfo;
1112             GetColumn(col, colInfo);
1113
1114             colInfo.SetWidth(width);
1115             SetColumn(col, colInfo);
1116             m_dbImpl->SetColumnWidth(col, width);
1117         }
1118         return true;
1119     }
1120
1121     return false;
1122 }
1123
1124 // Gets the number of items that can fit vertically in the
1125 // visible area of the list control (list or report view)
1126 // or the total number of items in the list control (icon
1127 // or small icon view)
1128 int wxListCtrl::GetCountPerPage() const
1129 {
1130     if (m_genericImpl)
1131         return m_genericImpl->GetCountPerPage();
1132
1133     if (m_dbImpl)
1134     {
1135         UInt16 height = 1;
1136         m_dbImpl->GetDefaultRowHeight( &height );
1137         if (height > 0)
1138             return GetClientSize().y / height;
1139     }
1140
1141     return 1;
1142 }
1143
1144 // Gets the edit control for editing labels.
1145 wxTextCtrl* wxListCtrl::GetEditControl() const
1146 {
1147     if (m_genericImpl)
1148         return m_genericImpl->GetEditControl();
1149
1150     return NULL;
1151 }
1152
1153 // Gets information about the item
1154 bool wxListCtrl::GetItem(wxListItem& info) const
1155 {
1156     if (m_genericImpl)
1157         return m_genericImpl->GetItem(info);
1158
1159     if (m_dbImpl)
1160     {
1161         if (!IsVirtual())
1162         {
1163             if (info.m_itemId >= 0 && info.m_itemId < GetItemCount())
1164             {
1165                 m_dbImpl->MacGetColumnInfo(info.m_itemId, info.m_col, info);
1166                 // MacGetColumnInfo returns erroneous information in the state field, so zero it.
1167                 info.SetState(0);
1168                 if (info.GetMask() & wxLIST_MASK_STATE)
1169                 {
1170                     DataBrowserItemID id = (DataBrowserItemID)m_dbImpl->GetItemFromLine(info.m_itemId);
1171                     if (IsDataBrowserItemSelected( m_dbImpl->GetControlRef(), id ))
1172                         info.SetState(info.GetState() | wxLIST_STATE_SELECTED);
1173                 }
1174             }
1175         }
1176         else
1177         {
1178             if (info.m_itemId >= 0 && info.m_itemId < GetItemCount())
1179             {
1180                 info.SetText( OnGetItemText(info.m_itemId, info.m_col) );
1181                 info.SetImage( OnGetItemColumnImage(info.m_itemId, info.m_col) );
1182                 if (info.GetMask() & wxLIST_MASK_STATE)
1183                 {
1184                     if (IsDataBrowserItemSelected( m_dbImpl->GetControlRef(), info.m_itemId+1 ))
1185                         info.SetState(info.GetState() | wxLIST_STATE_SELECTED);
1186                 }
1187
1188                 wxListItemAttr* attrs = OnGetItemAttr( info.m_itemId );
1189                 if (attrs)
1190                 {
1191                     info.SetFont( attrs->GetFont() );
1192                     info.SetBackgroundColour( attrs->GetBackgroundColour() );
1193                     info.SetTextColour( attrs->GetTextColour() );
1194                 }
1195             }
1196         }
1197     }
1198     bool success = true;
1199     return success;
1200 }
1201
1202 // Sets information about the item
1203 bool wxListCtrl::SetItem(wxListItem& info)
1204 {
1205     if (m_genericImpl)
1206         return m_genericImpl->SetItem(info);
1207
1208     if (m_dbImpl)
1209         m_dbImpl->MacSetColumnInfo( info.m_itemId, info.m_col, &info );
1210
1211     return true;
1212 }
1213
1214 long wxListCtrl::SetItem(long index, int col, const wxString& label, int imageId)
1215 {
1216     if (m_genericImpl)
1217         return m_genericImpl->SetItem(index, col, label, imageId);
1218
1219     wxListItem info;
1220     info.m_text = label;
1221     info.m_mask = wxLIST_MASK_TEXT;
1222     info.m_itemId = index;
1223     info.m_col = col;
1224     if ( imageId > -1 )
1225     {
1226         info.m_image = imageId;
1227         info.m_mask |= wxLIST_MASK_IMAGE;
1228     }
1229     return SetItem(info);
1230 }
1231
1232
1233 // Gets the item state
1234 int wxListCtrl::GetItemState(long item, long stateMask) const
1235 {
1236     if (m_genericImpl)
1237         return m_genericImpl->GetItemState(item, stateMask);
1238
1239     if (m_dbImpl)
1240     {
1241         if ( HasFlag(wxLC_VIRTUAL) )
1242         {
1243             if (stateMask == wxLIST_STATE_SELECTED)
1244             {
1245                 if (IsDataBrowserItemSelected( m_dbImpl->GetControlRef(), item+1 ))
1246                     return wxLIST_STATE_SELECTED;
1247                 else
1248                     return 0;
1249             }
1250         }
1251         else
1252         {
1253             wxListItem info;
1254
1255             info.m_mask = wxLIST_MASK_STATE;
1256             info.m_stateMask = stateMask;
1257             info.m_itemId = item;
1258
1259             if (!GetItem(info))
1260                 return 0;
1261
1262             return info.m_state;
1263         }
1264     }
1265
1266     return 0;
1267 }
1268
1269 // Sets the item state
1270 bool wxListCtrl::SetItemState(long item, long state, long stateMask)
1271 {
1272     if (m_genericImpl)
1273         return m_genericImpl->SetItemState(item, state, stateMask);
1274
1275     if (m_dbImpl)
1276     {
1277         DataBrowserSetOption option = kDataBrowserItemsAdd;
1278         if ( (stateMask & wxLIST_STATE_SELECTED) && state == 0 )
1279             option = kDataBrowserItemsRemove;
1280
1281         if (item == -1)
1282         {
1283             if ( HasFlag(wxLC_VIRTUAL) )
1284             {
1285                 wxMacDataItemBrowserSelectionSuppressor suppressor(m_dbImpl);
1286                 m_dbImpl->SetSelectedAllItems(option);
1287             }
1288             else
1289             {
1290                 for(int i = 0; i < GetItemCount();i++)
1291                 {
1292                     wxListItem info;
1293                     info.m_itemId = i;
1294                     info.m_mask = wxLIST_MASK_STATE;
1295                     info.m_stateMask = stateMask;
1296                     info.m_state = state;
1297                     SetItem(info);
1298                 }
1299             }
1300         }
1301         else
1302         {
1303             if ( HasFlag(wxLC_VIRTUAL) )
1304             {
1305                 long itemID = item+1;
1306                 bool isSelected = IsDataBrowserItemSelected(m_dbImpl->GetControlRef(), (DataBrowserItemID)itemID );
1307                 bool isSelectedState = (state == wxLIST_STATE_SELECTED);
1308
1309                 // toggle the selection state if wxListInfo state and actual state don't match.
1310                 if ( (stateMask & wxLIST_STATE_SELECTED) && isSelected != isSelectedState )
1311                 {
1312                 SetDataBrowserSelectedItems(m_dbImpl->GetControlRef(), 1, (DataBrowserItemID*)&itemID, option);
1313             }
1314             }
1315             else
1316             {
1317                 wxListItem info;
1318                 info.m_itemId = item;
1319                 info.m_mask = wxLIST_MASK_STATE;
1320                 info.m_stateMask = stateMask;
1321                 info.m_state = state;
1322                 return SetItem(info);
1323             }
1324         }
1325     }
1326     return true;
1327 }
1328
1329 // Sets the item image
1330 bool wxListCtrl::SetItemImage(long item, int image, int WXUNUSED(selImage))
1331 {
1332     return SetItemColumnImage(item, 0, image);
1333 }
1334
1335 // Sets the item image
1336 bool wxListCtrl::SetItemColumnImage(long item, long column, int image)
1337 {
1338     if (m_genericImpl)
1339         return m_genericImpl->SetItemColumnImage(item, column, image);
1340
1341     wxListItem info;
1342
1343     info.m_mask = wxLIST_MASK_IMAGE;
1344     info.m_image = image;
1345     info.m_itemId = item;
1346     info.m_col = column;
1347
1348     return SetItem(info);
1349 }
1350
1351 // Gets the item text
1352 wxString wxListCtrl::GetItemText(long item) const
1353 {
1354     if (m_genericImpl)
1355         return m_genericImpl->GetItemText(item);
1356
1357     wxListItem info;
1358
1359     info.m_mask = wxLIST_MASK_TEXT;
1360     info.m_itemId = item;
1361
1362     if (!GetItem(info))
1363         return wxEmptyString;
1364     return info.m_text;
1365 }
1366
1367 // Sets the item text
1368 void wxListCtrl::SetItemText(long item, const wxString& str)
1369 {
1370     if (m_genericImpl)
1371         return m_genericImpl->SetItemText(item, str);
1372
1373     wxListItem info;
1374
1375     info.m_mask = wxLIST_MASK_TEXT;
1376     info.m_itemId = item;
1377     info.m_text = str;
1378
1379     SetItem(info);
1380 }
1381
1382 // Gets the item data
1383 long wxListCtrl::GetItemData(long item) const
1384 {
1385     if (m_genericImpl)
1386         return m_genericImpl->GetItemData(item);
1387
1388     wxListItem info;
1389
1390     info.m_mask = wxLIST_MASK_DATA;
1391     info.m_itemId = item;
1392
1393     if (!GetItem(info))
1394         return 0;
1395     return info.m_data;
1396 }
1397
1398 // Sets the item data
1399 bool wxListCtrl::SetItemPtrData(long item, wxUIntPtr data)
1400 {
1401     if (m_genericImpl)
1402         return m_genericImpl->SetItemData(item, data);
1403
1404     wxListItem info;
1405
1406     info.m_mask = wxLIST_MASK_DATA;
1407     info.m_itemId = item;
1408     info.m_data = data;
1409
1410     return SetItem(info);
1411 }
1412
1413 wxRect wxListCtrl::GetViewRect() const
1414 {
1415     wxASSERT_MSG( !HasFlag(wxLC_REPORT | wxLC_LIST),
1416                     wxT("wxListCtrl::GetViewRect() only works in icon mode") );
1417
1418     if (m_genericImpl)
1419         return m_genericImpl->GetViewRect();
1420
1421     wxRect rect;
1422     return rect;
1423 }
1424
1425 bool wxListCtrl::GetSubItemRect( long item, long subItem, wxRect& rect, int code ) const
1426 {
1427     if (m_genericImpl)
1428         return m_genericImpl->GetSubItemRect(item, subItem, rect, code);
1429
1430     // TODO: implement for DataBrowser implementation
1431     return false;
1432 }
1433
1434 // Gets the item rectangle
1435 bool wxListCtrl::GetItemRect(long item, wxRect& rect, int code) const
1436 {
1437     if (m_genericImpl)
1438         return m_genericImpl->GetItemRect(item, rect, code);
1439
1440
1441     if (m_dbImpl)
1442     {
1443         DataBrowserItemID id;
1444
1445         DataBrowserTableViewColumnID col = 0;
1446         verify_noerr( m_dbImpl->GetColumnIDFromIndex( 0, &col ) );
1447
1448         Rect bounds;
1449         DataBrowserPropertyPart part = kDataBrowserPropertyEnclosingPart;
1450         if ( code == wxLIST_RECT_LABEL )
1451             part = kDataBrowserPropertyTextPart;
1452         else if ( code == wxLIST_RECT_ICON )
1453             part = kDataBrowserPropertyIconPart;
1454
1455         if ( !(GetWindowStyleFlag() & wxLC_VIRTUAL) )
1456         {
1457             wxMacDataItem* thisItem = m_dbImpl->GetItemFromLine(item);
1458             id = (DataBrowserItemID) thisItem;
1459         }
1460         else
1461             id = item+1;
1462
1463         GetDataBrowserItemPartBounds( m_dbImpl->GetControlRef(), id, col, part, &bounds );
1464
1465         rect.x = bounds.left;
1466         rect.y = bounds.top;
1467         rect.width = bounds.right - bounds.left; //GetClientSize().x; // we need the width of the whole row, not just the item.
1468         rect.height = bounds.bottom - bounds.top;
1469         //fprintf("id = %d, bounds = %d, %d, %d, %d\n", id, rect.x, rect.y, rect.width, rect.height);
1470     }
1471     return true;
1472 }
1473
1474 // Gets the item position
1475 bool wxListCtrl::GetItemPosition(long item, wxPoint& pos) const
1476 {
1477     if (m_genericImpl)
1478         return m_genericImpl->GetItemPosition(item, pos);
1479
1480     bool success = false;
1481
1482     if (m_dbImpl)
1483     {
1484         wxRect itemRect;
1485         GetItemRect(item, itemRect);
1486         pos = itemRect.GetPosition();
1487         success = true;
1488     }
1489
1490     return success;
1491 }
1492
1493 // Sets the item position.
1494 bool wxListCtrl::SetItemPosition(long item, const wxPoint& pos)
1495 {
1496     if (m_genericImpl)
1497         return m_genericImpl->SetItemPosition(item, pos);
1498
1499     return false;
1500 }
1501
1502 // Gets the number of items in the list control
1503 int wxListCtrl::GetItemCount() const
1504 {
1505     if (m_genericImpl)
1506         return m_genericImpl->GetItemCount();
1507
1508     if (m_dbImpl)
1509         return m_dbImpl->MacGetCount();
1510
1511     return m_count;
1512 }
1513
1514 void wxListCtrl::SetItemSpacing( int spacing, bool isSmall )
1515 {
1516     if (m_genericImpl)
1517         m_genericImpl->SetItemSpacing(spacing, isSmall);
1518 }
1519
1520 wxSize wxListCtrl::GetItemSpacing() const
1521 {
1522     if (m_genericImpl)
1523         return m_genericImpl->GetItemSpacing();
1524
1525     return wxSize(0, 0);
1526 }
1527
1528 void wxListCtrl::SetItemTextColour( long item, const wxColour &col )
1529 {
1530     if (m_genericImpl)
1531     {
1532         m_genericImpl->SetItemTextColour(item, col);
1533         return;
1534     }
1535
1536     wxListItem info;
1537     info.m_itemId = item;
1538     info.SetTextColour( col );
1539     SetItem( info );
1540 }
1541
1542 wxColour wxListCtrl::GetItemTextColour( long item ) const
1543 {
1544     if (m_genericImpl)
1545         return m_genericImpl->GetItemTextColour(item);
1546
1547     if (m_dbImpl)
1548     {
1549         wxListItem info;
1550         if (GetItem(info))
1551             return info.GetTextColour();
1552     }
1553     return wxNullColour;
1554 }
1555
1556 void wxListCtrl::SetItemBackgroundColour( long item, const wxColour &col )
1557 {
1558     if (m_genericImpl)
1559     {
1560         m_genericImpl->SetItemBackgroundColour(item, col);
1561         return;
1562     }
1563
1564     wxListItem info;
1565     info.m_itemId = item;
1566     info.SetBackgroundColour( col );
1567     SetItem( info );
1568 }
1569
1570 wxColour wxListCtrl::GetItemBackgroundColour( long item ) const
1571 {
1572     if (m_genericImpl)
1573         return m_genericImpl->GetItemBackgroundColour(item);
1574
1575     if (m_dbImpl)
1576     {
1577         wxListItem info;
1578         if (GetItem(info))
1579             return info.GetBackgroundColour();
1580     }
1581     return wxNullColour;
1582 }
1583
1584 void wxListCtrl::SetItemFont( long item, const wxFont &f )
1585 {
1586     if (m_genericImpl)
1587     {
1588         m_genericImpl->SetItemFont(item, f);
1589         return;
1590     }
1591
1592     wxListItem info;
1593     info.m_itemId = item;
1594     info.SetFont( f );
1595     SetItem( info );
1596 }
1597
1598 wxFont wxListCtrl::GetItemFont( long item ) const
1599 {
1600     if (m_genericImpl)
1601         return m_genericImpl->GetItemFont(item);
1602
1603     if (m_dbImpl)
1604     {
1605         wxListItem info;
1606         if (GetItem(info))
1607             return info.GetFont();
1608     }
1609
1610     return wxNullFont;
1611 }
1612
1613 // Gets the number of selected items in the list control
1614 int wxListCtrl::GetSelectedItemCount() const
1615 {
1616     if (m_genericImpl)
1617         return m_genericImpl->GetSelectedItemCount();
1618
1619     if (m_dbImpl)
1620         return m_dbImpl->GetSelectedItemCount(NULL, true);
1621
1622     return 0;
1623 }
1624
1625 // Gets the text colour of the listview
1626 wxColour wxListCtrl::GetTextColour() const
1627 {
1628     if (m_genericImpl)
1629         return m_genericImpl->GetTextColour();
1630
1631     // TODO: we need owner drawn list items to customize text color.
1632     if (m_dbImpl)
1633         return m_textColor;
1634
1635     return wxNullColour;
1636 }
1637
1638 // Sets the text colour of the listview
1639 void wxListCtrl::SetTextColour(const wxColour& col)
1640 {
1641     if (m_genericImpl)
1642     {
1643         m_genericImpl->SetTextColour(col);
1644         return;
1645     }
1646
1647     if (m_dbImpl)
1648         m_textColor = col;
1649 }
1650
1651 // Gets the index of the topmost visible item when in
1652 // list or report view
1653 long wxListCtrl::GetTopItem() const
1654 {
1655     if (m_genericImpl)
1656         return m_genericImpl->GetTopItem();
1657
1658     if (m_dbImpl)
1659     {
1660         int flags = 0;
1661         long item = HitTest( wxPoint(1, 1), flags);
1662         if (flags == wxLIST_HITTEST_ONITEM)
1663             return item;
1664     }
1665
1666     return 0;
1667 }
1668
1669 // Searches for an item, starting from 'item'.
1670 // 'geometry' is one of
1671 // wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT.
1672 // 'state' is a state bit flag, one or more of
1673 // wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT.
1674 // item can be -1 to find the first item that matches the
1675 // specified flags.
1676 // Returns the item or -1 if unsuccessful.
1677 long wxListCtrl::GetNextItem(long item, int geom, int state) const
1678 {
1679     if (m_genericImpl)
1680         return m_genericImpl->GetNextItem(item, geom, state);
1681
1682     // TODO: implement all geometry and state options?
1683     if ( m_dbImpl )
1684     {
1685         if ( geom == wxLIST_NEXT_ALL || geom == wxLIST_NEXT_BELOW )
1686         {
1687             long count = m_dbImpl->MacGetCount() ;
1688             for ( long line = item + 1 ; line < count; line++ )
1689             {
1690                 DataBrowserItemID id = line + 1;
1691                 if ( !IsVirtual() )
1692                     id = (DataBrowserItemID)m_dbImpl->GetItemFromLine(line);
1693
1694                 if ( (state & wxLIST_STATE_FOCUSED) && (m_current == line))
1695                     return line;
1696
1697                 if ( (state == wxLIST_STATE_DONTCARE ) )
1698                     return line;
1699
1700                 if ( (state & wxLIST_STATE_SELECTED) && IsDataBrowserItemSelected(m_dbImpl->GetControlRef(), id ) )
1701                     return line;
1702             }
1703         }
1704
1705         if ( geom == wxLIST_NEXT_ABOVE )
1706         {
1707             int item2 = item;
1708             if ( item2 == -1 )
1709                 item2 = m_dbImpl->MacGetCount();
1710
1711             for ( long line = item2 - 1 ; line >= 0; line-- )
1712             {
1713                 DataBrowserItemID id = line + 1;
1714                 if ( !IsVirtual() )
1715                     id = (DataBrowserItemID)m_dbImpl->GetItemFromLine(line);
1716
1717                 if ( (state & wxLIST_STATE_FOCUSED) && (m_current == line))
1718                     return line;
1719
1720                 if ( (state == wxLIST_STATE_DONTCARE ) )
1721                     return line;
1722
1723                 if ( (state & wxLIST_STATE_SELECTED) && IsDataBrowserItemSelected(m_dbImpl->GetControlRef(), id ) )
1724                     return line;
1725             }
1726         }
1727     }
1728
1729     return -1;
1730 }
1731
1732
1733 wxImageList *wxListCtrl::GetImageList(int which) const
1734 {
1735     if (m_genericImpl)
1736         return m_genericImpl->GetImageList(which);
1737
1738     if ( which == wxIMAGE_LIST_NORMAL )
1739     {
1740         return m_imageListNormal;
1741     }
1742     else if ( which == wxIMAGE_LIST_SMALL )
1743     {
1744         return m_imageListSmall;
1745     }
1746     else if ( which == wxIMAGE_LIST_STATE )
1747     {
1748         return m_imageListState;
1749     }
1750     return NULL;
1751 }
1752
1753 void wxListCtrl::SetImageList(wxImageList *imageList, int which)
1754 {
1755     if (m_genericImpl)
1756     {
1757         m_genericImpl->SetImageList(imageList, which);
1758         return;
1759     }
1760
1761     if ( which == wxIMAGE_LIST_NORMAL )
1762     {
1763         if (m_ownsImageListNormal) delete m_imageListNormal;
1764         m_imageListNormal = imageList;
1765         m_ownsImageListNormal = false;
1766     }
1767     else if ( which == wxIMAGE_LIST_SMALL )
1768     {
1769         if (m_ownsImageListSmall) delete m_imageListSmall;
1770         m_imageListSmall = imageList;
1771         m_ownsImageListSmall = false;
1772     }
1773     else if ( which == wxIMAGE_LIST_STATE )
1774     {
1775         if (m_ownsImageListState) delete m_imageListState;
1776         m_imageListState = imageList;
1777         m_ownsImageListState = false;
1778     }
1779 }
1780
1781 void wxListCtrl::AssignImageList(wxImageList *imageList, int which)
1782 {
1783     if (m_genericImpl)
1784     {
1785         m_genericImpl->AssignImageList(imageList, which);
1786         return;
1787     }
1788
1789     SetImageList(imageList, which);
1790     if ( which == wxIMAGE_LIST_NORMAL )
1791         m_ownsImageListNormal = true;
1792     else if ( which == wxIMAGE_LIST_SMALL )
1793         m_ownsImageListSmall = true;
1794     else if ( which == wxIMAGE_LIST_STATE )
1795         m_ownsImageListState = true;
1796 }
1797
1798 // ----------------------------------------------------------------------------
1799 // Operations
1800 // ----------------------------------------------------------------------------
1801
1802 // Arranges the items
1803 bool wxListCtrl::Arrange(int flag)
1804 {
1805     if (m_genericImpl)
1806         return m_genericImpl->Arrange(flag);
1807     return false;
1808 }
1809
1810 // Deletes an item
1811 bool wxListCtrl::DeleteItem(long item)
1812 {
1813     if (m_genericImpl)
1814         return m_genericImpl->DeleteItem(item);
1815
1816     if (m_dbImpl)
1817     {
1818         m_dbImpl->MacDelete(item);
1819         wxListEvent event( wxEVT_COMMAND_LIST_DELETE_ITEM, GetId() );
1820         event.SetEventObject( this );
1821         event.m_itemIndex = item;
1822         HandleWindowEvent( event );
1823
1824     }
1825     return true;
1826 }
1827
1828 // Deletes all items
1829 bool wxListCtrl::DeleteAllItems()
1830 {
1831     m_current = -1;
1832     if (m_genericImpl)
1833         return m_genericImpl->DeleteAllItems();
1834
1835     if (m_dbImpl)
1836     {
1837         m_dbImpl->MacClear();
1838         wxListEvent event( wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS, GetId() );
1839         event.SetEventObject( this );
1840         HandleWindowEvent( event );
1841     }
1842     return true;
1843 }
1844
1845 // Deletes all items
1846 bool wxListCtrl::DeleteAllColumns()
1847 {
1848     if (m_genericImpl)
1849         return m_genericImpl->DeleteAllColumns();
1850
1851     if (m_dbImpl)
1852     {
1853         UInt32 cols;
1854         m_dbImpl->GetColumnCount(&cols);
1855         for (UInt32 col = 0; col < cols; col++)
1856         {
1857                 DeleteColumn(0);
1858         }
1859     }
1860
1861     return true;
1862 }
1863
1864 // Deletes a column
1865 bool wxListCtrl::DeleteColumn(int col)
1866 {
1867     if (m_genericImpl)
1868         return m_genericImpl->DeleteColumn(col);
1869
1870     if (m_dbImpl)
1871     {
1872         OSStatus err = m_dbImpl->RemoveColumn(col);
1873         return err == noErr;
1874     }
1875
1876     return true;
1877 }
1878
1879 // Clears items, and columns if there are any.
1880 void wxListCtrl::ClearAll()
1881 {
1882     if (m_genericImpl)
1883     {
1884         m_genericImpl->ClearAll();
1885         return;
1886     }
1887
1888     if (m_dbImpl)
1889     {
1890         DeleteAllItems();
1891         DeleteAllColumns();
1892     }
1893 }
1894
1895 wxTextCtrl* wxListCtrl::EditLabel(long item, wxClassInfo* textControlClass)
1896 {
1897     if (m_genericImpl)
1898         return m_genericImpl->EditLabel(item, textControlClass);
1899
1900     if (m_dbImpl)
1901     {
1902         wxCHECK_MSG( (item >= 0) && ((long)item < GetItemCount()), NULL,
1903                      wxT("wrong index in wxListCtrl::EditLabel()") );
1904
1905         wxASSERT_MSG( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)),
1906                      wxT("EditLabel() needs a text control") );
1907
1908         wxListEvent le( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT, GetParent()->GetId() );
1909         le.SetEventObject( this );
1910         le.m_itemIndex = item;
1911         le.m_col = 0;
1912         GetItem( le.m_item );
1913
1914         if ( GetParent()->HandleWindowEvent( le ) && !le.IsAllowed() )
1915         {
1916             // vetoed by user code
1917             return NULL;
1918         }
1919
1920         wxTextCtrl * const text = (wxTextCtrl *)textControlClass->CreateObject();
1921         m_textctrlWrapper = new wxListCtrlTextCtrlWrapper(this, text, item);
1922         return m_textctrlWrapper->GetText();
1923     }
1924     return NULL;
1925 }
1926
1927 // End label editing, optionally cancelling the edit
1928 bool wxListCtrl::EndEditLabel(bool WXUNUSED(cancel))
1929 {
1930     // TODO: generic impl. doesn't have this method - is it needed for us?
1931     if (m_genericImpl)
1932         return true; // m_genericImpl->EndEditLabel(cancel);
1933
1934     if (m_dbImpl)
1935     {
1936         DataBrowserTableViewColumnID id = 0;
1937         verify_noerr( m_dbImpl->GetColumnIDFromIndex( 0, &id ) );
1938         verify_noerr( SetDataBrowserEditItem(m_dbImpl->GetControlRef(), kDataBrowserNoItem, id ) );
1939     }
1940     return true;
1941 }
1942
1943 // Ensures this item is visible
1944 bool wxListCtrl::EnsureVisible(long item)
1945 {
1946     if (m_genericImpl)
1947         return m_genericImpl->EnsureVisible(item);
1948
1949     if (m_dbImpl)
1950     {
1951         wxMacDataItem* dataItem = m_dbImpl->GetItemFromLine(item);
1952         m_dbImpl->RevealItem(dataItem, kDataBrowserRevealWithoutSelecting);
1953     }
1954
1955     return true;
1956 }
1957
1958 // Find an item whose label matches this string, starting from the item after 'start'
1959 // or the beginning if 'start' is -1.
1960 long wxListCtrl::FindItem(long start, const wxString& str, bool partial)
1961 {
1962     if (m_genericImpl)
1963         return m_genericImpl->FindItem(start, str, partial);
1964
1965     wxString str_upper = str.Upper();
1966
1967     long idx = start;
1968     if (idx < 0)
1969         idx = 0;
1970     long count = GetItemCount();
1971
1972     while (idx < count)
1973     {
1974         wxString line_upper = GetItemText(idx).Upper();
1975         if (!partial)
1976         {
1977             if (line_upper == str_upper )
1978                 return idx;
1979         }
1980         else
1981         {
1982             if (line_upper.find(str_upper) == 0)
1983                 return idx;
1984         }
1985
1986         idx++;
1987     };
1988
1989     return wxNOT_FOUND;
1990 }
1991
1992 // Find an item whose data matches this data, starting from the item after 'start'
1993 // or the beginning if 'start' is -1.
1994 long wxListCtrl::FindItem(long start, long data)
1995 {
1996     if (m_genericImpl)
1997         return m_genericImpl->FindItem(start, data);
1998
1999     long idx = start;
2000     if (idx < 0)
2001         idx = 0;
2002     long count = GetItemCount();
2003
2004     while (idx < count)
2005     {
2006         if (GetItemData(idx) == data)
2007             return idx;
2008         idx++;
2009     };
2010
2011     return wxNOT_FOUND;
2012 }
2013
2014 // Find an item nearest this position in the specified direction, starting from
2015 // the item after 'start' or the beginning if 'start' is -1.
2016 long wxListCtrl::FindItem(long start, const wxPoint& pt, int direction)
2017 {
2018     if (m_genericImpl)
2019         return m_genericImpl->FindItem(start, pt, direction);
2020     return -1;
2021 }
2022
2023 static void calculateCGDrawingBounds(CGRect inItemRect, CGRect *outIconRect, CGRect *outTextRect, bool hasIcon);
2024
2025 // Determines which item (if any) is at the specified point,
2026 // giving details in 'flags' (see wxLIST_HITTEST_... flags above)
2027 long
2028 wxListCtrl::HitTest(const wxPoint& point, int& flags, long *ptrSubItem) const
2029 {
2030     if (ptrSubItem)
2031         *ptrSubItem = -1;
2032
2033     if (m_genericImpl)
2034         return m_genericImpl->HitTest(point, flags, ptrSubItem);
2035
2036     flags = wxLIST_HITTEST_NOWHERE;
2037     if (m_dbImpl)
2038     {
2039         int colHeaderHeight = 22; // TODO: Find a way to get this value from the db control?
2040         UInt16 rowHeight = 0;
2041         m_dbImpl->GetDefaultRowHeight(&rowHeight);
2042
2043         int y = point.y;
2044         // get the actual row by taking scroll position into account
2045         UInt32 offsetX, offsetY;
2046         m_dbImpl->GetScrollPosition( &offsetY, &offsetX );
2047         y += offsetY;
2048
2049         if ( !(GetWindowStyleFlag() & wxLC_NO_HEADER) )
2050             y -= colHeaderHeight;
2051
2052         if ( y < 0 )
2053             return -1;
2054
2055         int row = y / rowHeight;
2056         DataBrowserItemID id;
2057         m_dbImpl->GetItemID( (DataBrowserTableViewRowIndex) row, &id );
2058
2059         CGPoint click_point = CGPointMake( point.x, point.y );
2060         if (row < GetItemCount() )
2061         {
2062             short column;
2063             for( column = 0; column < GetColumnCount(); column++ )
2064             {
2065                Rect enclosingRect;
2066                CGRect enclosingCGRect, iconCGRect, textCGRect;
2067                int imgIndex = -1;
2068                wxMacListCtrlItem* lcItem;
2069
2070                WXUNUSED_UNLESS_DEBUG( OSStatus status = ) m_dbImpl->GetItemPartBounds( id, kMinColumnId + column, kDataBrowserPropertyEnclosingPart, &enclosingRect );
2071                wxASSERT( status == noErr );
2072
2073                enclosingCGRect = CGRectMake(enclosingRect.left,
2074                                             enclosingRect.top,
2075                                             enclosingRect.right - enclosingRect.left,
2076                                             enclosingRect.bottom - enclosingRect.top);
2077
2078                if (column >= 0)
2079                {
2080                    if ( !(GetWindowStyleFlag() & wxLC_VIRTUAL ) )
2081                    {
2082                        lcItem = (wxMacListCtrlItem*) id;
2083                        if (lcItem->HasColumnInfo(column))
2084                        {
2085                            wxListItem* item = lcItem->GetColumnInfo(column);
2086
2087                            if (item->GetMask() & wxLIST_MASK_IMAGE)
2088                            {
2089                                imgIndex = item->GetImage();
2090                            }
2091                        }
2092                    }
2093                    else
2094                    {
2095                        long itemNum = (long)id-1;
2096                        if (itemNum >= 0 && itemNum < GetItemCount())
2097                        {
2098                            imgIndex = OnGetItemColumnImage( itemNum, column );
2099                        }
2100                    }
2101                }
2102
2103                calculateCGDrawingBounds(enclosingCGRect, &iconCGRect, &textCGRect, (imgIndex != -1) );
2104
2105                if ( CGRectContainsPoint( iconCGRect, click_point ) )
2106                {
2107                    flags = wxLIST_HITTEST_ONITEMICON;
2108                    if (ptrSubItem)
2109                        *ptrSubItem = column;
2110                    return row;
2111                }
2112                else if ( CGRectContainsPoint( textCGRect, click_point ) )
2113                {
2114                    flags = wxLIST_HITTEST_ONITEMLABEL;
2115                    if (ptrSubItem)
2116                        *ptrSubItem = column;
2117                    return row;
2118                }
2119            }
2120
2121            if ( !(GetWindowStyleFlag() & wxLC_VIRTUAL ) )
2122            {
2123                wxMacListCtrlItem* lcItem;
2124                lcItem = (wxMacListCtrlItem*) id;
2125                if (lcItem)
2126                {
2127                    flags = wxLIST_HITTEST_ONITEM;
2128                    if (ptrSubItem)
2129                        *ptrSubItem = column;
2130                    return row;
2131                }
2132            }
2133            else
2134            {
2135                flags = wxLIST_HITTEST_ONITEM;
2136                if (ptrSubItem)
2137                    *ptrSubItem = column;
2138                return row;
2139            }
2140          }
2141          else
2142          {
2143              if ( wxControl::HitTest( point ) )
2144                  flags = wxLIST_HITTEST_NOWHERE;
2145          }
2146     }
2147
2148     return -1;
2149 }
2150
2151 int wxListCtrl::GetScrollPos(int orient) const
2152 {
2153     if (m_genericImpl)
2154         return m_genericImpl->GetScrollPos(orient);
2155
2156     if (m_dbImpl)
2157     {
2158         UInt32 offsetX, offsetY;
2159         m_dbImpl->GetScrollPosition( &offsetY, &offsetX );
2160         if ( orient == wxHORIZONTAL )
2161            return offsetX;
2162         else
2163            return offsetY;
2164     }
2165
2166     return 0;
2167 }
2168
2169 // Inserts an item, returning the index of the new item if successful,
2170 // -1 otherwise.
2171 long wxListCtrl::InsertItem(wxListItem& info)
2172 {
2173     wxASSERT_MSG( !IsVirtual(), wxT("can't be used with virtual controls") );
2174
2175     if (m_genericImpl)
2176         return m_genericImpl->InsertItem(info);
2177
2178     if (m_dbImpl && !IsVirtual())
2179     {
2180         int count = GetItemCount();
2181
2182         if (info.m_itemId > count)
2183             info.m_itemId = count;
2184
2185         m_dbImpl->MacInsertItem(info.m_itemId, &info );
2186
2187         wxListEvent event( wxEVT_COMMAND_LIST_INSERT_ITEM, GetId() );
2188         event.SetEventObject( this );
2189         event.m_itemIndex = info.m_itemId;
2190         HandleWindowEvent( event );
2191         return info.m_itemId;
2192     }
2193     return -1;
2194 }
2195
2196 long wxListCtrl::InsertItem(long index, const wxString& label)
2197 {
2198     if (m_genericImpl)
2199         return m_genericImpl->InsertItem(index, label);
2200
2201     wxListItem info;
2202     info.m_text = label;
2203     info.m_mask = wxLIST_MASK_TEXT;
2204     info.m_itemId = index;
2205     return InsertItem(info);
2206 }
2207
2208 // Inserts an image item
2209 long wxListCtrl::InsertItem(long index, int imageIndex)
2210 {
2211     if (m_genericImpl)
2212         return m_genericImpl->InsertItem(index, imageIndex);
2213
2214     wxListItem info;
2215     info.m_image = imageIndex;
2216     info.m_mask = wxLIST_MASK_IMAGE;
2217     info.m_itemId = index;
2218     return InsertItem(info);
2219 }
2220
2221 // Inserts an image/string item
2222 long wxListCtrl::InsertItem(long index, const wxString& label, int imageIndex)
2223 {
2224     if (m_genericImpl)
2225         return m_genericImpl->InsertItem(index, label, imageIndex);
2226
2227     wxListItem info;
2228     info.m_image = imageIndex;
2229     info.m_text = label;
2230     info.m_mask = wxLIST_MASK_IMAGE | wxLIST_MASK_TEXT;
2231     info.m_itemId = index;
2232     return InsertItem(info);
2233 }
2234
2235 // For list view mode (only), inserts a column.
2236 long wxListCtrl::InsertColumn(long col, wxListItem& item)
2237 {
2238     if (m_genericImpl)
2239         return m_genericImpl->InsertColumn(col, item);
2240
2241     if (m_dbImpl)
2242     {
2243         int width = item.GetWidth();
2244         if ( !(item.GetMask() & wxLIST_MASK_WIDTH) )
2245             width = 150;
2246
2247         DataBrowserPropertyType type = kDataBrowserCustomType; //kDataBrowserTextType;
2248         wxImageList* imageList = GetImageList(wxIMAGE_LIST_SMALL);
2249         if (imageList && imageList->GetImageCount() > 0)
2250         {
2251             wxBitmap bmp = imageList->GetBitmap(0);
2252             //if (bmp.Ok())
2253             //    type = kDataBrowserIconAndTextType;
2254         }
2255
2256         SInt16 just = teFlushDefault;
2257         if (item.GetMask() & wxLIST_MASK_FORMAT)
2258         {
2259             if (item.GetAlign() == wxLIST_FORMAT_LEFT)
2260                 just = teFlushLeft;
2261             else if (item.GetAlign() == wxLIST_FORMAT_CENTER)
2262                 just = teCenter;
2263             else if (item.GetAlign() == wxLIST_FORMAT_RIGHT)
2264                 just = teFlushRight;
2265         }
2266         m_dbImpl->InsertColumn(col, type, item.GetText(), just, width);
2267
2268         wxListItem* listItem = new wxListItem(item);
2269         m_colsInfo.Insert( col, listItem );
2270         SetColumn(col, item);
2271
2272         // set/remove options based on the wxListCtrl type.
2273         DataBrowserTableViewColumnID id;
2274         m_dbImpl->GetColumnIDFromIndex(col, &id);
2275         DataBrowserPropertyFlags flags;
2276         verify_noerr(m_dbImpl->GetPropertyFlags(id, &flags));
2277         if (GetWindowStyleFlag() & wxLC_EDIT_LABELS)
2278             flags |= kDataBrowserPropertyIsEditable;
2279
2280         if (GetWindowStyleFlag() & wxLC_VIRTUAL){
2281             flags &= ~kDataBrowserListViewSortableColumn;
2282         }
2283         verify_noerr(m_dbImpl->SetPropertyFlags(id, flags));
2284     }
2285
2286     return col;
2287 }
2288
2289 long wxListCtrl::InsertColumn(long col,
2290                               const wxString& heading,
2291                               int format,
2292                               int width)
2293 {
2294     if (m_genericImpl)
2295         return m_genericImpl->InsertColumn(col, heading, format, width);
2296
2297     wxListItem item;
2298     item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT;
2299     item.m_text = heading;
2300     if ( width > -1 )
2301     {
2302         item.m_mask |= wxLIST_MASK_WIDTH;
2303         item.m_width = width;
2304     }
2305     item.m_format = format;
2306
2307     return InsertColumn(col, item);
2308 }
2309
2310 // scroll the control by the given number of pixels (exception: in list view,
2311 // dx is interpreted as number of columns)
2312 bool wxListCtrl::ScrollList(int dx, int dy)
2313 {
2314     if (m_genericImpl)
2315         return m_genericImpl->ScrollList(dx, dy);
2316
2317     if (m_dbImpl)
2318     {
2319         m_dbImpl->SetScrollPosition(dx, dy);
2320     }
2321     return true;
2322 }
2323
2324
2325 bool wxListCtrl::SortItems(wxListCtrlCompare fn, wxIntPtr data)
2326 {
2327     if (m_genericImpl)
2328         return m_genericImpl->SortItems(fn, data);
2329
2330     if (m_dbImpl)
2331     {
2332         m_compareFunc = fn;
2333         m_compareFuncData = data;
2334         SortDataBrowserContainer( m_dbImpl->GetControlRef(), kDataBrowserNoItem, true);
2335
2336         // we need to do this after each call, else we get a crash from wxPython when
2337         // SortItems is called the second time.
2338         m_compareFunc = NULL;
2339         m_compareFuncData = 0;
2340     }
2341
2342     return true;
2343 }
2344
2345 void wxListCtrl::OnRenameTimer()
2346 {
2347     wxCHECK_RET( HasCurrent(), wxT("unexpected rename timer") );
2348
2349     EditLabel( m_current );
2350 }
2351
2352 bool wxListCtrl::OnRenameAccept(long itemEdit, const wxString& value)
2353 {
2354     wxListEvent le( wxEVT_COMMAND_LIST_END_LABEL_EDIT, GetId() );
2355     le.SetEventObject( this );
2356     le.m_itemIndex = itemEdit;
2357
2358     GetItem( le.m_item );
2359     le.m_item.m_text = value;
2360     return !HandleWindowEvent( le ) ||
2361                 le.IsAllowed();
2362 }
2363
2364 void wxListCtrl::OnRenameCancelled(long itemEdit)
2365 {
2366     // let owner know that the edit was cancelled
2367     wxListEvent le( wxEVT_COMMAND_LIST_END_LABEL_EDIT, GetParent()->GetId() );
2368
2369     le.SetEditCanceled(true);
2370
2371     le.SetEventObject( this );
2372     le.m_itemIndex = itemEdit;
2373
2374     GetItem( le.m_item );
2375     HandleWindowEvent( le );
2376 }
2377
2378 // ----------------------------------------------------------------------------
2379 // virtual list controls
2380 // ----------------------------------------------------------------------------
2381
2382 wxString wxListCtrl::OnGetItemText(long WXUNUSED(item), long WXUNUSED(col)) const
2383 {
2384     // this is a pure virtual function, in fact - which is not really pure
2385     // because the controls which are not virtual don't need to implement it
2386     wxFAIL_MSG( wxT("wxListCtrl::OnGetItemText not supposed to be called") );
2387
2388     return wxEmptyString;
2389 }
2390
2391 int wxListCtrl::OnGetItemImage(long WXUNUSED(item)) const
2392 {
2393     wxCHECK_MSG(!GetImageList(wxIMAGE_LIST_SMALL),
2394                 -1,
2395                 wxT("List control has an image list, OnGetItemImage or OnGetItemColumnImage should be overridden."));
2396     return -1;
2397 }
2398
2399 int wxListCtrl::OnGetItemColumnImage(long item, long column) const
2400 {
2401     if (!column)
2402         return OnGetItemImage(item);
2403
2404     return -1;
2405 }
2406
2407 wxListItemAttr *wxListCtrl::OnGetItemAttr(long WXUNUSED_UNLESS_DEBUG(item)) const
2408 {
2409     wxASSERT_MSG( item >= 0 && item < GetItemCount(),
2410                   wxT("invalid item index in OnGetItemAttr()") );
2411
2412     // no attributes by default
2413     return NULL;
2414 }
2415
2416 void wxListCtrl::SetItemCount(long count)
2417 {
2418     wxASSERT_MSG( IsVirtual(), wxT("this is for virtual controls only") );
2419
2420     if (m_genericImpl)
2421     {
2422         m_genericImpl->SetItemCount(count);
2423         return;
2424     }
2425
2426     if (m_dbImpl)
2427     {
2428         // we need to temporarily disable the new item creation notification
2429         // procedure to speed things up
2430         // FIXME: Even this doesn't seem to help much...
2431
2432         // FIXME: Find a more efficient way to do this.
2433         m_dbImpl->MacClear();
2434
2435         DataBrowserCallbacks callbacks;
2436         DataBrowserItemNotificationUPP itemUPP;
2437         GetDataBrowserCallbacks(m_dbImpl->GetControlRef(), &callbacks);
2438         itemUPP = callbacks.u.v1.itemNotificationCallback;
2439         callbacks.u.v1.itemNotificationCallback = 0;
2440         m_dbImpl->SetCallbacks(&callbacks);
2441         ::AddDataBrowserItems(m_dbImpl->GetControlRef(), kDataBrowserNoItem,
2442             count, NULL, kDataBrowserItemNoProperty);
2443         callbacks.u.v1.itemNotificationCallback = itemUPP;
2444         m_dbImpl->SetCallbacks(&callbacks);
2445     }
2446     m_count = count;
2447 }
2448
2449 void wxListCtrl::RefreshItem(long item)
2450 {
2451     if (m_genericImpl)
2452     {
2453         m_genericImpl->RefreshItem(item);
2454         return;
2455     }
2456
2457     if (m_dbImpl)
2458     {
2459         DataBrowserItemID id;
2460
2461         if ( !IsVirtual() )
2462         {
2463             wxMacDataItem* thisItem = m_dbImpl->GetItemFromLine(item);
2464             id = (DataBrowserItemID) thisItem;
2465         }
2466         else
2467             id = item+1;
2468
2469         m_dbImpl->wxMacDataBrowserControl::UpdateItems
2470                   (
2471                     kDataBrowserNoItem,
2472                     1, &id,
2473                     kDataBrowserItemNoProperty, // preSortProperty
2474                     kDataBrowserNoItem // update all columns
2475                   );
2476     }
2477 }
2478
2479 void wxListCtrl::RefreshItems(long itemFrom, long itemTo)
2480 {
2481     if (m_genericImpl)
2482     {
2483         m_genericImpl->RefreshItems(itemFrom, itemTo);
2484         return;
2485     }
2486
2487     if (m_dbImpl)
2488     {
2489         const long count = itemTo - itemFrom + 1;
2490         DataBrowserItemID *ids = new DataBrowserItemID[count];
2491
2492         if ( !IsVirtual() )
2493         {
2494             for ( long i = 0; i < count; i++ )
2495             {
2496                 wxMacDataItem* thisItem = m_dbImpl->GetItemFromLine(itemFrom+i);
2497                 ids[i] = (DataBrowserItemID) thisItem;
2498             }
2499         }
2500         else
2501         {
2502             for ( long i = 0; i < count; i++ )
2503                 ids[i] = itemFrom+i+1;
2504         }
2505
2506         m_dbImpl->wxMacDataBrowserControl::UpdateItems
2507                   (
2508                     kDataBrowserNoItem,
2509                     count, ids,
2510                     kDataBrowserItemNoProperty, // preSortProperty
2511                     kDataBrowserNoItem // update all columns
2512                   );
2513
2514         delete[] ids;
2515     }
2516 }
2517
2518 void wxListCtrl::SetDropTarget( wxDropTarget *dropTarget )
2519 {
2520 #if wxUSE_DRAG_AND_DROP
2521     if (m_genericImpl)
2522         m_genericImpl->SetDropTarget( dropTarget );
2523
2524     if (m_dbImpl)
2525         wxWindow::SetDropTarget( dropTarget );
2526 #endif
2527 }
2528
2529 wxDropTarget *wxListCtrl::GetDropTarget() const
2530 {
2531 #if wxUSE_DRAG_AND_DROP
2532     if (m_genericImpl)
2533         return m_genericImpl->GetDropTarget();
2534
2535     if (m_dbImpl)
2536         return wxWindow::GetDropTarget();
2537 #endif
2538     return NULL;
2539 }
2540
2541 #if wxABI_VERSION >= 20801
2542 void wxListCtrl::SetFocus()
2543 {
2544         if (m_genericImpl)
2545         {
2546                 m_genericImpl->SetFocus();
2547                 return;
2548         }
2549
2550         wxWindow::SetFocus();
2551 }
2552 #endif
2553
2554 // wxMac internal data structures
2555
2556 wxMacListCtrlItem::~wxMacListCtrlItem()
2557 {
2558     WX_CLEAR_HASH_MAP( wxListItemList, m_rowItems );
2559 }
2560
2561 void wxMacListCtrlItem::Notification(wxMacDataItemBrowserControl *owner ,
2562     DataBrowserItemNotification message,
2563     DataBrowserItemDataRef WXUNUSED(itemData) ) const
2564 {
2565
2566     wxMacDataBrowserListCtrlControl *lb = wxDynamicCast(owner, wxMacDataBrowserListCtrlControl);
2567
2568     // we want to depend on as little as possible to make sure tear-down of controls is safe
2569     if ( message == kDataBrowserItemRemoved)
2570     {
2571         delete this;
2572         return;
2573     }
2574     else if ( message == kDataBrowserItemAdded )
2575     {
2576         // we don't issue events on adding, the item is not really stored in the list yet, so we
2577         // avoid asserts by gettting out now
2578         return  ;
2579     }
2580
2581     wxListCtrl *list = wxDynamicCast( owner->GetWXPeer() , wxListCtrl );
2582     if ( list && lb )
2583     {
2584         bool trigger = false;
2585
2586         wxListEvent event( wxEVT_COMMAND_LIST_ITEM_SELECTED, list->GetId() );
2587         bool isSingle = (list->GetWindowStyle() & wxLC_SINGLE_SEL) != 0;
2588
2589         event.SetEventObject( list );
2590         event.m_itemIndex = owner->GetLineFromItem( this ) ;
2591         event.m_item.m_itemId = event.m_itemIndex;
2592         list->GetItem(event.m_item);
2593
2594         switch (message)
2595         {
2596             case kDataBrowserItemDeselected:
2597                 event.SetEventType(wxEVT_COMMAND_LIST_ITEM_DESELECTED);
2598                 if ( !isSingle )
2599                     trigger = !lb->IsSelectionSuppressed();
2600                 break;
2601
2602             case kDataBrowserItemSelected:
2603                 trigger = !lb->IsSelectionSuppressed();
2604                 break;
2605
2606             case kDataBrowserItemDoubleClicked:
2607                 event.SetEventType( wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
2608                 trigger = true;
2609                 break;
2610
2611             case kDataBrowserEditStarted :
2612                 // TODO : how to veto ?
2613                 event.SetEventType( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT ) ;
2614                 trigger = true ;
2615                 break ;
2616
2617             case kDataBrowserEditStopped :
2618                 // TODO probably trigger only upon the value store callback, because
2619                 // here IIRC we cannot veto
2620                 event.SetEventType( wxEVT_COMMAND_LIST_END_LABEL_EDIT ) ;
2621                 trigger = true ;
2622                 break ;
2623
2624             default:
2625                 break;
2626         }
2627
2628         if ( trigger )
2629         {
2630             // direct notification is not always having the listbox GetSelection() having in synch with event
2631             wxPostEvent( list->GetEventHandler(), event );
2632         }
2633     }
2634
2635 }
2636
2637 IMPLEMENT_DYNAMIC_CLASS(wxMacDataBrowserListCtrlControl, wxMacDataItemBrowserControl )
2638
2639 wxMacDataBrowserListCtrlControl::wxMacDataBrowserListCtrlControl( wxWindow *peer, const wxPoint& pos, const wxSize& size, long style)
2640     : wxMacDataItemBrowserControl( peer, pos, size, style )
2641 {
2642     OSStatus err = noErr;
2643     m_clientDataItemsType = wxClientData_None;
2644     m_isVirtual = false;
2645     m_flags = 0;
2646
2647     if ( style & wxLC_VIRTUAL )
2648         m_isVirtual = true;
2649
2650     DataBrowserSelectionFlags  options = kDataBrowserDragSelect;
2651     if ( style & wxLC_SINGLE_SEL )
2652     {
2653         options |= kDataBrowserSelectOnlyOne;
2654     }
2655     else
2656     {
2657         options |= kDataBrowserCmdTogglesSelection;
2658     }
2659
2660     err = SetSelectionFlags( options );
2661     verify_noerr( err );
2662
2663     DataBrowserCustomCallbacks callbacks;
2664     InitializeDataBrowserCustomCallbacks( &callbacks, kDataBrowserLatestCustomCallbacks );
2665
2666     if ( gDataBrowserDrawItemUPP == NULL )
2667         gDataBrowserDrawItemUPP = NewDataBrowserDrawItemUPP(DataBrowserDrawItemProc);
2668
2669     if ( gDataBrowserHitTestUPP == NULL )
2670         gDataBrowserHitTestUPP = NewDataBrowserHitTestUPP(DataBrowserHitTestProc);
2671
2672     callbacks.u.v1.drawItemCallback = gDataBrowserDrawItemUPP;
2673     callbacks.u.v1.hitTestCallback = gDataBrowserHitTestUPP;
2674
2675     SetDataBrowserCustomCallbacks( GetControlRef(), &callbacks );
2676
2677     if ( style & wxLC_LIST )
2678     {
2679         InsertColumn(0, kDataBrowserIconAndTextType, wxEmptyString, -1, -1);
2680         verify_noerr( AutoSizeColumns() );
2681     }
2682
2683     if ( style & wxLC_LIST || style & wxLC_NO_HEADER )
2684         verify_noerr( SetHeaderButtonHeight( 0 ) );
2685
2686     if ( m_isVirtual )
2687         SetSortProperty( kMinColumnId - 1 );
2688     else
2689         SetSortProperty( kMinColumnId );
2690
2691     m_sortOrder = SortOrder_None;
2692
2693     if ( style & wxLC_SORT_DESCENDING )
2694     {
2695         SetSortOrder( kDataBrowserOrderDecreasing );
2696     }
2697     else if ( style & wxLC_SORT_ASCENDING )
2698     {
2699         SetSortOrder( kDataBrowserOrderIncreasing );
2700     }
2701
2702     if ( style & wxLC_VRULES )
2703     {
2704         verify_noerr( DataBrowserChangeAttributes(m_controlRef, kDataBrowserAttributeListViewDrawColumnDividers, kDataBrowserAttributeNone) );
2705     }
2706
2707     verify_noerr( SetHiliteStyle(kDataBrowserTableViewFillHilite ) );
2708     verify_noerr( SetHasScrollBars( (style & wxHSCROLL) != 0 , true ) );
2709 }
2710
2711 pascal Boolean wxMacDataBrowserListCtrlControl::DataBrowserEditTextProc(
2712         ControlRef browser,
2713         DataBrowserItemID itemID,
2714         DataBrowserPropertyID property,
2715         CFStringRef theString,
2716         Rect *maxEditTextRect,
2717         Boolean *shrinkToFit)
2718 {
2719     Boolean result = false;
2720     wxMacDataBrowserListCtrlControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserListCtrlControl);
2721     if ( ctl != 0 )
2722     {
2723         result = ctl->ConfirmEditText(itemID, property, theString, maxEditTextRect, shrinkToFit);
2724         theString = CFSTR("Hello!");
2725     }
2726     return result;
2727 }
2728
2729 bool wxMacDataBrowserListCtrlControl::ConfirmEditText(
2730         DataBrowserItemID WXUNUSED(itemID),
2731         DataBrowserPropertyID WXUNUSED(property),
2732         CFStringRef WXUNUSED(theString),
2733         Rect *WXUNUSED(maxEditTextRect),
2734         Boolean *WXUNUSED(shrinkToFit))
2735 {
2736     return false;
2737 }
2738
2739 pascal void wxMacDataBrowserListCtrlControl::DataBrowserDrawItemProc(
2740         ControlRef browser,
2741         DataBrowserItemID itemID,
2742         DataBrowserPropertyID property,
2743         DataBrowserItemState itemState,
2744         const Rect *itemRect,
2745         SInt16 gdDepth,
2746         Boolean colorDevice)
2747 {
2748     wxMacDataBrowserListCtrlControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserListCtrlControl);
2749     if ( ctl != 0 )
2750     {
2751         ctl->DrawItem(itemID, property, itemState, itemRect, gdDepth, colorDevice);
2752     }
2753 }
2754
2755 // routines needed for DrawItem
2756 enum
2757 {
2758   kIconWidth = 16,
2759   kIconHeight = 16,
2760   kTextBoxHeight = 14,
2761   kIconTextSpacingV = 2,
2762   kItemPadding = 4,
2763   kContentHeight = kIconHeight + kTextBoxHeight + kIconTextSpacingV
2764 };
2765
2766 static void calculateCGDrawingBounds(CGRect inItemRect, CGRect *outIconRect, CGRect *outTextRect, bool hasIcon = false)
2767 {
2768   float textBottom;
2769   float iconH, iconW = 0;
2770   float padding = kItemPadding;
2771   if (hasIcon)
2772   {
2773     iconH = kIconHeight;
2774     iconW = kIconWidth;
2775     padding = padding*2;
2776   }
2777
2778   textBottom = inItemRect.origin.y;
2779
2780   *outIconRect = CGRectMake(inItemRect.origin.x + kItemPadding,
2781                 textBottom + kIconTextSpacingV, kIconWidth,
2782                 kIconHeight);
2783
2784   *outTextRect = CGRectMake(inItemRect.origin.x + padding + iconW,
2785                 textBottom + kIconTextSpacingV, inItemRect.size.width - padding - iconW,
2786                 inItemRect.size.height - kIconTextSpacingV);
2787 }
2788
2789 void wxMacDataBrowserListCtrlControl::DrawItem(
2790         DataBrowserItemID itemID,
2791         DataBrowserPropertyID property,
2792         DataBrowserItemState itemState,
2793         const Rect *WXUNUSED(itemRect),
2794         SInt16 gdDepth,
2795         Boolean colorDevice)
2796 {
2797     wxString text;
2798     wxFont font = wxNullFont;
2799     int imgIndex = -1;
2800
2801     DataBrowserTableViewColumnIndex listColumn = 0;
2802     GetColumnPosition( property, &listColumn );
2803
2804     wxListCtrl* list = wxDynamicCast( GetWXPeer() , wxListCtrl );
2805     wxMacListCtrlItem* lcItem;
2806     wxColour color = *wxBLACK;
2807     wxColour bgColor = wxNullColour;
2808
2809     if (listColumn >= 0)
2810     {
2811         if (!m_isVirtual)
2812         {
2813             lcItem = (wxMacListCtrlItem*) itemID;
2814             if (lcItem->HasColumnInfo(listColumn))
2815             {
2816                 wxListItem* item = lcItem->GetColumnInfo(listColumn);
2817
2818                 // we always use the 0 column to get font and text/background colors.
2819                 if (lcItem->HasColumnInfo(0))
2820                 {
2821                     wxListItem* firstItem = lcItem->GetColumnInfo(0);
2822                     color = firstItem->GetTextColour();
2823                     bgColor = firstItem->GetBackgroundColour();
2824                     font = firstItem->GetFont();
2825                 }
2826
2827                 if (item->GetMask() & wxLIST_MASK_TEXT)
2828                     text = item->GetText();
2829                 if (item->GetMask() & wxLIST_MASK_IMAGE)
2830                     imgIndex = item->GetImage();
2831             }
2832
2833         }
2834         else
2835         {
2836             long itemNum = (long)itemID-1;
2837             if (itemNum >= 0 && itemNum < list->GetItemCount())
2838             {
2839                 text = list->OnGetItemText( itemNum, listColumn );
2840                 imgIndex = list->OnGetItemColumnImage( itemNum, listColumn );
2841                 wxListItemAttr* attrs = list->OnGetItemAttr( itemNum );
2842                 if (attrs)
2843                 {
2844                     if (attrs->HasBackgroundColour())
2845                         bgColor = attrs->GetBackgroundColour();
2846                     if (attrs->HasTextColour())
2847                         color = attrs->GetTextColour();
2848                     if (attrs->HasFont())
2849                         font = attrs->GetFont();
2850                 }
2851             }
2852         }
2853     }
2854
2855     wxColour listBgColor = list->GetBackgroundColour();
2856     if (bgColor == wxNullColour)
2857         bgColor = listBgColor;
2858
2859     if (!font.Ok())
2860         font = list->GetFont();
2861
2862     wxCFStringRef cfString( text, wxLocale::GetSystemEncoding() );
2863
2864     Rect enclosingRect;
2865     CGRect enclosingCGRect, iconCGRect, textCGRect;
2866     Boolean active;
2867     ThemeDrawingState savedState = NULL;
2868     CGContextRef context = (CGContextRef)list->MacGetDrawingContext();
2869     wxMacCGContextStateSaver top_saver_cg( context );
2870
2871     RGBColor labelColor;
2872     labelColor.red = 0;
2873     labelColor.green = 0;
2874     labelColor.blue = 0;
2875
2876     RGBColor backgroundColor;
2877     backgroundColor.red = 255;
2878     backgroundColor.green = 255;
2879     backgroundColor.blue = 255;
2880
2881     GetDataBrowserItemPartBounds(GetControlRef(), itemID, property, kDataBrowserPropertyEnclosingPart,
2882               &enclosingRect);
2883
2884     enclosingCGRect = CGRectMake(enclosingRect.left,
2885                       enclosingRect.top,
2886                       enclosingRect.right - enclosingRect.left,
2887                       enclosingRect.bottom - enclosingRect.top);
2888
2889     bool hasFocus = (wxWindow::FindFocus() == list);
2890     active = IsControlActive(GetControlRef());
2891
2892     // don't paint the background over the vertical rule line
2893     if ( list->GetWindowStyleFlag() & wxLC_VRULES )
2894     {
2895         enclosingCGRect.origin.x += 1;
2896         enclosingCGRect.size.width -= 1;
2897     }
2898     if (itemState == kDataBrowserItemIsSelected)
2899     {
2900
2901         GetThemeDrawingState(&savedState);
2902
2903         if (active && hasFocus)
2904         {
2905             GetThemeBrushAsColor(kThemeBrushAlternatePrimaryHighlightColor, 32, true, &backgroundColor);
2906             GetThemeTextColor(kThemeTextColorWhite, gdDepth, colorDevice, &labelColor);
2907         }
2908         else
2909         {
2910             GetThemeBrushAsColor(kThemeBrushSecondaryHighlightColor, 32, true, &backgroundColor);
2911             GetThemeTextColor(kThemeTextColorBlack, gdDepth, colorDevice, &labelColor);
2912         }
2913         wxMacCGContextStateSaver cg( context );
2914
2915         CGContextSetRGBFillColor(context, (CGFloat)backgroundColor.red / (CGFloat)USHRT_MAX,
2916                       (CGFloat)backgroundColor.green / (CGFloat)USHRT_MAX,
2917                       (CGFloat)backgroundColor.blue / (CGFloat)USHRT_MAX, (CGFloat) 1.0);
2918         CGContextFillRect(context, enclosingCGRect);
2919     }
2920     else
2921     {
2922
2923         if (color.Ok())
2924             color.GetRGBColor(&labelColor);
2925         else if (list->GetTextColour().Ok())
2926             list->GetTextColour().GetRGBColor(&labelColor);
2927
2928         if (bgColor.Ok())
2929         {
2930             bgColor.GetRGBColor(&backgroundColor);
2931             CGContextSaveGState(context);
2932
2933             CGContextSetRGBFillColor(context, (CGFloat)backgroundColor.red / (CGFloat)USHRT_MAX,
2934                           (CGFloat)backgroundColor.green / (CGFloat)USHRT_MAX,
2935                           (CGFloat)backgroundColor.blue / (CGFloat)USHRT_MAX, (CGFloat) 1.0);
2936             CGContextFillRect(context, enclosingCGRect);
2937
2938             CGContextRestoreGState(context);
2939         }
2940     }
2941
2942     calculateCGDrawingBounds(enclosingCGRect, &iconCGRect, &textCGRect, (imgIndex != -1) );
2943
2944     if (imgIndex != -1)
2945     {
2946         wxImageList* imageList = list->GetImageList(wxIMAGE_LIST_SMALL);
2947         if (imageList && imageList->GetImageCount() > 0)
2948         {
2949             wxBitmap bmp = imageList->GetBitmap(imgIndex);
2950             IconRef icon = bmp.GetIconRef();
2951
2952             wxMacCGContextStateSaver cg( context );
2953
2954             CGContextTranslateCTM(context, 0,iconCGRect.origin.y + CGRectGetMaxY(iconCGRect));
2955             CGContextScaleCTM(context,1.0f,-1.0f);
2956             PlotIconRefInContext(context, &iconCGRect, kAlignNone,
2957               active ? kTransformNone : kTransformDisabled, NULL,
2958               kPlotIconRefNormalFlags, icon);
2959         }
2960     }
2961
2962     HIThemeTextHorizontalFlush hFlush = kHIThemeTextHorizontalFlushLeft;
2963     HIThemeTextInfo info;
2964     bool setup = false;
2965 #if wxOSX_USE_CORE_TEXT
2966     if ( UMAGetSystemVersion() >= 0x1050 )
2967     {
2968         info.version = kHIThemeTextInfoVersionOne;
2969         info.fontID = kThemeViewsFont;
2970         if (font.Ok())
2971         {
2972             info.fontID = kThemeSpecifiedFont;
2973             info.font = (CTFontRef) font.OSXGetCTFont();
2974             setup = true;
2975         }
2976     }
2977 #endif
2978 #if wxOSX_USE_ATSU_TEXT
2979     if ( !setup )
2980     {
2981         info.version = kHIThemeTextInfoVersionZero;
2982         info.fontID = kThemeViewsFont;
2983
2984         if (font.Ok())
2985         {
2986             info.fontID = font.MacGetThemeFontID();
2987
2988             ::TextSize( (short)(font.GetPointSize()) ) ;
2989             ::TextFace( font.MacGetFontStyle() ) ;
2990         }
2991     }
2992 #endif
2993
2994     wxListItem item;
2995     list->GetColumn(listColumn, item);
2996     if (item.GetMask() & wxLIST_MASK_FORMAT)
2997     {
2998         if (item.GetAlign() == wxLIST_FORMAT_LEFT)
2999             hFlush = kHIThemeTextHorizontalFlushLeft;
3000         else if (item.GetAlign() == wxLIST_FORMAT_CENTER)
3001             hFlush = kHIThemeTextHorizontalFlushCenter;
3002         else if (item.GetAlign() == wxLIST_FORMAT_RIGHT)
3003         {
3004             hFlush = kHIThemeTextHorizontalFlushRight;
3005             textCGRect.origin.x -= kItemPadding; // give a little extra paddding
3006         }
3007     }
3008
3009     info.state = active ? kThemeStateActive : kThemeStateInactive;
3010     info.horizontalFlushness = hFlush;
3011     info.verticalFlushness = kHIThemeTextVerticalFlushCenter;
3012     info.options = kHIThemeTextBoxOptionNone;
3013     info.truncationPosition = kHIThemeTextTruncationEnd;
3014     info.truncationMaxLines = 1;
3015
3016     {
3017         wxMacCGContextStateSaver cg( context );
3018         CGContextSetRGBFillColor (context, (CGFloat)labelColor.red / (CGFloat)USHRT_MAX,
3019                       (CGFloat)labelColor.green / (CGFloat)USHRT_MAX,
3020                       (CGFloat)labelColor.blue / (CGFloat)USHRT_MAX, (CGFloat) 1.0);
3021
3022         HIThemeDrawTextBox(cfString, &textCGRect, &info, context, kHIThemeOrientationNormal);
3023     }
3024
3025 #ifndef __LP64__
3026     if (savedState != NULL)
3027         SetThemeDrawingState(savedState, true);
3028 #endif
3029 }
3030
3031 OSStatus wxMacDataBrowserListCtrlControl::GetSetItemData(DataBrowserItemID itemID,
3032                         DataBrowserPropertyID property,
3033                         DataBrowserItemDataRef itemData,
3034                         Boolean changeValue )
3035 {
3036     wxString text;
3037     int imgIndex = -1;
3038
3039     DataBrowserTableViewColumnIndex listColumn = 0;
3040     verify_noerr( GetColumnPosition( property, &listColumn ) );
3041
3042     OSStatus err = errDataBrowserPropertyNotSupported;
3043     wxListCtrl* list = wxDynamicCast( GetWXPeer() , wxListCtrl );
3044     wxMacListCtrlItem* lcItem = NULL;
3045
3046     if (listColumn >= 0)
3047     {
3048         if (!m_isVirtual)
3049         {
3050             lcItem = (wxMacListCtrlItem*) itemID;
3051             if (lcItem && lcItem->HasColumnInfo(listColumn)){
3052                 wxListItem* item = lcItem->GetColumnInfo(listColumn);
3053                 if (item->GetMask() & wxLIST_MASK_TEXT)
3054                     text = item->GetText();
3055                 if (item->GetMask() & wxLIST_MASK_IMAGE)
3056                     imgIndex = item->GetImage();
3057             }
3058         }
3059         else
3060         {
3061             long itemNum = (long)itemID-1;
3062             if (itemNum >= 0 && itemNum < list->GetItemCount())
3063             {
3064                 text = list->OnGetItemText( itemNum, listColumn );
3065                 imgIndex = list->OnGetItemColumnImage( itemNum, listColumn );
3066             }
3067         }
3068     }
3069
3070     if ( !changeValue )
3071     {
3072         switch (property)
3073         {
3074             case kDataBrowserItemIsEditableProperty :
3075                 if ( list && list->HasFlag( wxLC_EDIT_LABELS ) )
3076                 {
3077                     verify_noerr(SetDataBrowserItemDataBooleanValue( itemData, true ));
3078                     err = noErr ;
3079                 }
3080                 break ;
3081             default :
3082                 if ( property >= kMinColumnId )
3083                 {
3084                     if (!text.IsEmpty()){
3085                         wxCFStringRef cfStr( text, wxLocale::GetSystemEncoding() );
3086                         err = ::SetDataBrowserItemDataText( itemData, cfStr );
3087                         err = noErr;
3088                     }
3089
3090
3091
3092                     if ( imgIndex != -1 )
3093                     {
3094                         wxImageList* imageList = list->GetImageList(wxIMAGE_LIST_SMALL);
3095                         if (imageList && imageList->GetImageCount() > 0){
3096                             wxBitmap bmp = imageList->GetBitmap(imgIndex);
3097                             IconRef icon = bmp.GetIconRef();
3098                             ::SetDataBrowserItemDataIcon(itemData, icon);
3099                         }
3100                     }
3101
3102                 }
3103                 break ;
3104         }
3105
3106     }
3107     else
3108     {
3109         switch (property)
3110         {
3111              default:
3112                 if ( property >= kMinColumnId )
3113                 {
3114                     DataBrowserTableViewColumnIndex listColumn = 0;
3115                     verify_noerr( GetColumnPosition( property, &listColumn ) );
3116
3117                     // TODO probably send the 'end edit' from here, as we
3118                     // can then deal with the veto
3119                     CFStringRef sr ;
3120                     verify_noerr( GetDataBrowserItemDataText( itemData , &sr ) ) ;
3121                     wxCFStringRef cfStr(sr) ;;
3122                     if (m_isVirtual)
3123                         list->SetItem( (long)itemData-1 , listColumn, cfStr.AsString() ) ;
3124                     else
3125                     {
3126                         if (lcItem)
3127                             lcItem->SetColumnTextValue( listColumn, cfStr.AsString() );
3128                     }
3129                     err = noErr ;
3130                 }
3131                 break;
3132         }
3133     }
3134     return err;
3135 }
3136
3137 void wxMacDataBrowserListCtrlControl::ItemNotification(DataBrowserItemID itemID,
3138     DataBrowserItemNotification message,
3139     DataBrowserItemDataRef itemData )
3140 {
3141     wxMacListCtrlItem *item = NULL;
3142     if ( !m_isVirtual )
3143     {
3144         item = (wxMacListCtrlItem *) itemID;
3145     }
3146
3147     // we want to depend on as little as possible to make sure tear-down of controls is safe
3148     if ( message == kDataBrowserItemRemoved )
3149     {
3150         if ( item )
3151             item->Notification(this, message, itemData);
3152         return;
3153     }
3154     else if ( message == kDataBrowserItemAdded )
3155     {
3156         // we don't issue events on adding, the item is not really stored in the list yet, so we
3157         // avoid asserts by getting out now
3158         if ( item )
3159             item->Notification(this, message, itemData);
3160         return  ;
3161     }
3162
3163     wxListCtrl *list = wxDynamicCast( GetWXPeer() , wxListCtrl );
3164     if ( list )
3165     {
3166         bool trigger = false;
3167
3168         wxListEvent event( wxEVT_COMMAND_LIST_ITEM_SELECTED, list->GetId() );
3169
3170         event.SetEventObject( list );
3171         if ( !list->IsVirtual() )
3172         {
3173             DataBrowserTableViewRowIndex result = 0;
3174             verify_noerr( GetItemRow( itemID, &result ) ) ;
3175             event.m_itemIndex = result;
3176         }
3177         else
3178         {
3179             event.m_itemIndex = (long)itemID-1;
3180         }
3181         event.m_item.m_itemId = event.m_itemIndex;
3182         list->GetItem(event.m_item);
3183
3184         switch (message)
3185         {
3186             case kDataBrowserItemDeselected:
3187                 event.SetEventType(wxEVT_COMMAND_LIST_ITEM_DESELECTED);
3188                 // as the generic implementation is also triggering this
3189                 // event for single selection, we do the same (different than listbox)
3190                 trigger = !IsSelectionSuppressed();
3191                 break;
3192
3193             case kDataBrowserItemSelected:
3194                 trigger = !IsSelectionSuppressed();
3195
3196                 break;
3197
3198             case kDataBrowserItemDoubleClicked:
3199                 event.SetEventType( wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
3200                 trigger = true;
3201                 break;
3202
3203             case kDataBrowserEditStarted :
3204                 // TODO : how to veto ?
3205                 event.SetEventType( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT ) ;
3206                 trigger = true ;
3207                 break ;
3208
3209             case kDataBrowserEditStopped :
3210                 // TODO probably trigger only upon the value store callback, because
3211                 // here IIRC we cannot veto
3212                 event.SetEventType( wxEVT_COMMAND_LIST_END_LABEL_EDIT ) ;
3213                 trigger = true ;
3214                 break ;
3215
3216             default:
3217                 break;
3218         }
3219
3220         if ( trigger )
3221         {
3222             // direct notification is not always having the listbox GetSelection() having in synch with event
3223             wxPostEvent( list->GetEventHandler(), event );
3224         }
3225     }
3226 }
3227
3228 Boolean wxMacDataBrowserListCtrlControl::CompareItems(DataBrowserItemID itemOneID,
3229                         DataBrowserItemID itemTwoID,
3230                         DataBrowserPropertyID sortProperty)
3231 {
3232
3233     bool retval = false;
3234     wxString itemText;
3235     wxString otherItemText;
3236     long itemOrder;
3237     long otherItemOrder;
3238
3239     DataBrowserTableViewColumnIndex colId = 0;
3240     verify_noerr( GetColumnPosition( sortProperty, &colId ) );
3241
3242     wxListCtrl* list = wxDynamicCast( GetWXPeer() , wxListCtrl );
3243
3244     DataBrowserSortOrder sort;
3245     verify_noerr(GetSortOrder(&sort));
3246
3247     if (colId >= 0)
3248     {
3249         if (!m_isVirtual)
3250         {
3251             wxMacListCtrlItem* item = (wxMacListCtrlItem*)itemOneID;
3252             wxMacListCtrlItem* otherItem = (wxMacListCtrlItem*)itemTwoID;
3253
3254             itemOrder = item->GetOrder();
3255             otherItemOrder = otherItem->GetOrder();
3256
3257             wxListCtrlCompare func = list->GetCompareFunc();
3258             if (func != NULL)
3259             {
3260
3261                 long item1 = -1;
3262                 long item2 = -1;
3263                 if (item && item->HasColumnInfo(0))
3264                     item1 = item->GetColumnInfo(0)->GetData();
3265                 if (otherItem && otherItem->HasColumnInfo(0))
3266                     item2 = otherItem->GetColumnInfo(0)->GetData();
3267
3268                 if (item1 > -1 && item2 > -1)
3269                 {
3270                     int result = func(item1, item2, list->GetCompareFuncData());
3271                     if (sort == kDataBrowserOrderIncreasing)
3272                         return result >= 0;
3273                     else
3274                         return result < 0;
3275                 }
3276             }
3277
3278             // we can't use the native control's sorting abilities, so just
3279             // sort by item id.
3280             return itemOrder < otherItemOrder;
3281         }
3282         else
3283         {
3284
3285             long itemNum = (long)itemOneID;
3286             long otherItemNum = (long)itemTwoID;
3287
3288             // virtual listctrls don't support sorting
3289             return itemNum < otherItemNum;
3290         }
3291     }
3292     else{
3293         // fallback for undefined cases
3294         retval = itemOneID < itemTwoID;
3295     }
3296
3297     return retval;
3298 }
3299
3300 wxMacDataBrowserListCtrlControl::~wxMacDataBrowserListCtrlControl()
3301 {
3302 }
3303
3304 void wxMacDataBrowserListCtrlControl::MacSetColumnInfo( unsigned int row, unsigned int column, wxListItem* item )
3305 {
3306     wxMacDataItem* dataItem = GetItemFromLine(row);
3307     wxASSERT_MSG( dataItem, wxT("could not obtain wxMacDataItem for row in MacSetColumnInfo. Is row a valid wxListCtrl row?") );
3308     if (item)
3309     {
3310         wxMacListCtrlItem* listItem = static_cast<wxMacListCtrlItem *>(dataItem);
3311         bool hasInfo = listItem->HasColumnInfo( column );
3312         listItem->SetColumnInfo( column, item );
3313         listItem->SetOrder(row);
3314         UpdateState(dataItem, item);
3315
3316         wxListCtrl* list = wxDynamicCast( GetWXPeer() , wxListCtrl );
3317
3318         // NB: When this call was made before a control was completely shown, it would
3319         // update the item prematurely (i.e. no text would be listed) and, on show,
3320         // only the sorted column would be refreshed, meaning only first column text labels
3321         // would be shown. Making sure not to update items until the control is visible
3322         // seems to fix this issue.
3323         if (hasInfo && list->IsShown())
3324         {
3325             DataBrowserTableViewColumnID id = 0;
3326             verify_noerr( GetColumnIDFromIndex( column, &id ) );
3327             UpdateItem( wxMacDataBrowserRootContainer, listItem , id );
3328         }
3329     }
3330 }
3331
3332 // apply changes that need to happen immediately, rather than when the
3333 // databrowser control fires a callback.
3334 void wxMacDataBrowserListCtrlControl::UpdateState(wxMacDataItem* dataItem, wxListItem* listItem)
3335 {
3336     bool isSelected = IsItemSelected( dataItem );
3337     bool isSelectedState = (listItem->GetState() == wxLIST_STATE_SELECTED);
3338
3339     // toggle the selection state if wxListInfo state and actual state don't match.
3340     if ( listItem->GetMask() & wxLIST_MASK_STATE && isSelected != isSelectedState )
3341     {
3342         DataBrowserSetOption options = kDataBrowserItemsAdd;
3343         if (!isSelectedState)
3344             options = kDataBrowserItemsRemove;
3345         SetSelectedItem(dataItem, options);
3346     }
3347     // TODO: Set column width if item width > than current column width
3348 }
3349
3350 void wxMacDataBrowserListCtrlControl::MacGetColumnInfo( unsigned int row, unsigned int column, wxListItem& item )
3351 {
3352     wxMacDataItem* dataItem = GetItemFromLine(row);
3353     wxASSERT_MSG( dataItem, wxT("could not obtain wxMacDataItem in MacGetColumnInfo. Is row a valid wxListCtrl row?") );
3354     // CS should this guard against dataItem = 0 ? , as item is not a pointer if (item) is not appropriate
3355     //if (item)
3356     {
3357         wxMacListCtrlItem* listItem = static_cast<wxMacListCtrlItem *>(dataItem);
3358
3359         if (!listItem->HasColumnInfo( column ))
3360             return;
3361
3362         wxListItem* oldItem = listItem->GetColumnInfo( column );
3363
3364         if (oldItem)
3365         {
3366             long mask = item.GetMask();
3367             if ( !mask )
3368                 // by default, get everything for backwards compatibility
3369                 mask = -1;
3370
3371             if ( mask & wxLIST_MASK_TEXT )
3372                 item.SetText(oldItem->GetText());
3373             if ( mask & wxLIST_MASK_IMAGE )
3374                 item.SetImage(oldItem->GetImage());
3375             if ( mask & wxLIST_MASK_DATA )
3376                 item.SetData(oldItem->GetData());
3377             if ( mask & wxLIST_MASK_STATE )
3378                 item.SetState(oldItem->GetState());
3379             if ( mask & wxLIST_MASK_WIDTH )
3380                 item.SetWidth(oldItem->GetWidth());
3381             if ( mask & wxLIST_MASK_FORMAT )
3382                 item.SetAlign(oldItem->GetAlign());
3383
3384             item.SetTextColour(oldItem->GetTextColour());
3385             item.SetBackgroundColour(oldItem->GetBackgroundColour());
3386             item.SetFont(oldItem->GetFont());
3387         }
3388     }
3389 }
3390
3391 void wxMacDataBrowserListCtrlControl::MacInsertItem( unsigned int n, wxListItem* item )
3392 {
3393
3394     wxMacDataItemBrowserControl::MacInsert(n, new wxMacListCtrlItem() );
3395     MacSetColumnInfo(n, 0, item);
3396 }
3397
3398 wxMacListCtrlItem::wxMacListCtrlItem()
3399 {
3400     m_rowItems = wxListItemList();
3401 }
3402
3403 int wxMacListCtrlItem::GetColumnImageValue( unsigned int column )
3404 {
3405     if ( HasColumnInfo(column) )
3406         return GetColumnInfo(column)->GetImage();
3407
3408     return -1;
3409 }
3410
3411 void wxMacListCtrlItem::SetColumnImageValue( unsigned int column, int imageIndex )
3412 {
3413     if ( HasColumnInfo(column) )
3414         GetColumnInfo(column)->SetImage(imageIndex);
3415 }
3416
3417 wxString wxMacListCtrlItem::GetColumnTextValue( unsigned int column )
3418 {
3419 /* TODO CHECK REMOVE
3420     if ( column == 0 )
3421         return GetLabel();
3422 */
3423     if ( HasColumnInfo(column) )
3424         return GetColumnInfo(column)->GetText();
3425
3426     return wxEmptyString;
3427 }
3428
3429 void wxMacListCtrlItem::SetColumnTextValue( unsigned int column, const wxString& text )
3430 {
3431     if ( HasColumnInfo(column) )
3432         GetColumnInfo(column)->SetText(text);
3433
3434 /* TODO CHECK REMOVE
3435     // for compatibility with superclass APIs
3436     if ( column == 0 )
3437         SetLabel(text);
3438 */
3439 }
3440
3441 wxListItem* wxMacListCtrlItem::GetColumnInfo( unsigned int column )
3442 {
3443     wxASSERT_MSG( HasColumnInfo(column), wxT("invalid column index in wxMacListCtrlItem") );
3444     return m_rowItems[column];
3445 }
3446
3447 bool wxMacListCtrlItem::HasColumnInfo( unsigned int column )
3448 {
3449     return !(m_rowItems.find( column ) == m_rowItems.end());
3450 }
3451
3452 void wxMacListCtrlItem::SetColumnInfo( unsigned int column, wxListItem* item )
3453 {
3454
3455     if ( !HasColumnInfo(column) )
3456     {
3457         wxListItem* listItem = new wxListItem(*item);
3458         m_rowItems[column] = listItem;
3459     }
3460     else
3461     {
3462         wxListItem* listItem = GetColumnInfo( column );
3463         long mask = item->GetMask();
3464         if (mask & wxLIST_MASK_TEXT)
3465             listItem->SetText(item->GetText());
3466         if (mask & wxLIST_MASK_DATA)
3467             listItem->SetData(item->GetData());
3468         if (mask & wxLIST_MASK_IMAGE)
3469             listItem->SetImage(item->GetImage());
3470         if (mask & wxLIST_MASK_STATE)
3471             listItem->SetState(item->GetState());
3472         if (mask & wxLIST_MASK_FORMAT)
3473             listItem->SetAlign(item->GetAlign());
3474         if (mask & wxLIST_MASK_WIDTH)
3475             listItem->SetWidth(item->GetWidth());
3476
3477         if ( item->HasAttributes() )
3478         {
3479             if ( listItem->HasAttributes() )
3480                 listItem->GetAttributes()->AssignFrom(*item->GetAttributes());
3481             else
3482             {
3483                 listItem->SetTextColour(item->GetTextColour());
3484                 listItem->SetBackgroundColour(item->GetBackgroundColour());
3485                 listItem->SetFont(item->GetFont());
3486             }
3487         }
3488     }
3489 }
3490
3491 int wxListCtrl::CalcColumnAutoWidth(int col) const
3492 {
3493     int width = 0;
3494
3495     for ( int i = 0; i < GetItemCount(); i++ )
3496     {
3497         wxListItem info;
3498         info.SetMask(wxLIST_MASK_TEXT | wxLIST_MASK_IMAGE);
3499         info.SetId(i);
3500         info.SetColumn(col);
3501         GetItem(info);
3502
3503         const wxFont font = info.GetFont();
3504
3505         int w = 0;
3506         if ( font.IsOk() )
3507             GetTextExtent(info.GetText(), &w, NULL, NULL, NULL, &font);
3508         else
3509             GetTextExtent(info.GetText(), &w, NULL);
3510
3511         w += 2 * kItemPadding;
3512
3513         if ( info.GetImage() != -1 )
3514             w += kIconWidth;
3515
3516         width = wxMax(width, w);
3517     }
3518
3519     return width;
3520 }
3521
3522 #endif // wxUSE_LISTCTRL
3523