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