src/osx/carbon/listctrl_mac.cpp

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