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