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->GetEventHandler()->ProcessEvent( 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 browser,
 263                                     DataBrowserItemID itemID,
 264                                     DataBrowserPropertyID property,
 265                                     const Rect *theRect,
 266                                     const Rect *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->GetEventHandler()->ProcessEvent( 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         GetEventHandler()->ProcessEvent(le);
 652     }
 653 }
 654
 655 void wxListCtrl::OnChar(wxKeyEvent& event)
 656 {
 657     if (m_dbImpl)
 658     {
 659         wxListEvent le( wxEVT_COMMAND_LIST_KEY_DOWN, GetId() );
 660         le.SetEventObject(this);
 661         le.m_code = event.GetKeyCode();
 662         le.m_itemIndex = -1;
 663
 664         if (m_current != -1)
 665         {
 666             le.m_itemIndex = m_current;
 667             le.m_item.m_itemId = m_current;
 668             GetItem(le.m_item);
 669             GetEventHandler()->ProcessEvent(le);
 670         }
 671     }
 672     event.Skip();
 673 }
 674 #endif
 675
 676 bool wxListCtrl::Create(wxWindow *parent,
 677                         wxWindowID id,
 678                         const wxPoint& pos,
 679                         const wxSize& size,
 680                         long style,
 681                         const wxValidator& validator,
 682                         const wxString& name)
 683 {
 684
 685     // for now, we'll always use the generic list control for ICON and LIST views,
 686     // because they dynamically change the number of columns on resize.
 687     // Also, allow the user to set it to use the list ctrl as well.
 688     if ( (wxSystemOptions::HasOption( wxMAC_ALWAYS_USE_GENERIC_LISTCTRL )
 689             && (wxSystemOptions::GetOptionInt( wxMAC_ALWAYS_USE_GENERIC_LISTCTRL ) == 1)) ||
 690             (style & wxLC_ICON) || (style & wxLC_SMALL_ICON) || (style & wxLC_LIST) )
 691     {
 692         m_macIsUserPane = true;
 693
 694         long paneStyle = style;
 695         paneStyle &= ~wxSIMPLE_BORDER;
 696         paneStyle &= ~wxDOUBLE_BORDER;
 697         paneStyle &= ~wxSUNKEN_BORDER;
 698         paneStyle &= ~wxRAISED_BORDER;
 699         paneStyle &= ~wxSTATIC_BORDER;
 700         if ( !wxWindow::Create(parent, id, pos, size, paneStyle | wxNO_BORDER, name) )
 701             return false;
 702
 703         // since the generic control is a child, make sure we position it at 0, 0
 704         m_genericImpl = new wxGenericListCtrlHook(this, id, wxPoint(0, 0), size, style, validator, name);
 705         m_genericImpl->PushEventHandler( new wxMacListCtrlEventDelegate( this, GetId() ) );
 706         return true;
 707     }
 708
 709     else
 710     {
 711          m_macIsUserPane = false;
 712         if ( !wxWindow::Create(parent, id, pos, size, style & ~(wxHSCROLL | wxVSCROLL), name) )
 713             return false;
 714         m_dbImpl = new wxMacDataBrowserListCtrlControl( this, pos, size, style );
 715         m_peer = m_dbImpl;
 716
 717         MacPostControlCreate( pos, size );
 718
 719         InstallControlEventHandler( m_peer->GetControlRef() , GetwxMacListCtrlEventHandlerUPP(),
 720             GetEventTypeCount(eventList), eventList, this,
 721             (EventHandlerRef *)&m_macListCtrlEventHandler);
 722     }
 723
 724     return true;
 725 }
 726
 727 wxListCtrl::~wxListCtrl()
 728 {
 729     if (m_genericImpl)
 730     {
 731         m_genericImpl->PopEventHandler(/* deleteHandler = */ true);
 732     }
 733
 734     if (m_ownsImageListNormal)
 735         delete m_imageListNormal;
 736     if (m_ownsImageListSmall)
 737         delete m_imageListSmall;
 738     if (m_ownsImageListState)
 739         delete m_imageListState;
 740
 741     delete m_renameTimer;
 742 }
 743
 744 // ----------------------------------------------------------------------------
 745 // set/get/change style
 746 // ----------------------------------------------------------------------------
 747
 748 // Add or remove a single window style
 749 void wxListCtrl::SetSingleStyle(long style, bool add)
 750 {
 751     long flag = GetWindowStyleFlag();
 752
 753     // Get rid of conflicting styles
 754     if ( add )
 755     {
 756         if ( style & wxLC_MASK_TYPE)
 757             flag = flag & ~wxLC_MASK_TYPE;
 758         if ( style & wxLC_MASK_ALIGN )
 759             flag = flag & ~wxLC_MASK_ALIGN;
 760         if ( style & wxLC_MASK_SORT )
 761             flag = flag & ~wxLC_MASK_SORT;
 762     }
 763
 764     if ( add )
 765         flag |= style;
 766     else
 767         flag &= ~style;
 768
 769     SetWindowStyleFlag(flag);
 770 }
 771
 772 // Set the whole window style
 773 void wxListCtrl::SetWindowStyleFlag(long flag)
 774 {
 775     if ( flag != m_windowStyle )
 776     {
 777         m_windowStyle = flag;
 778
 779         if (m_genericImpl)
 780         {
 781             m_genericImpl->SetWindowStyleFlag(flag);
 782         }
 783
 784         Refresh();
 785     }
 786 }
 787
 788 void wxListCtrl::DoSetSize( int x, int y, int width, int height, int sizeFlags )
 789 {
 790     wxControl::DoSetSize(x, y, width, height, sizeFlags);
 791
 792     if (m_genericImpl)
 793         m_genericImpl->SetSize(0, 0, width, height, sizeFlags);
 794
 795     // determine if we need a horizontal scrollbar, and add it if so
 796     if (m_dbImpl)
 797     {
 798         int totalWidth = 0;
 799         for (int column = 0; column < GetColumnCount(); column++)
 800         {
 801               totalWidth += m_dbImpl->GetColumnWidth( column );
 802         }
 803
 804         if ( !(m_dbImpl->GetFlags() & wxHSCROLL) )
 805         {
 806             Boolean vertScrollBar;
 807             GetDataBrowserHasScrollBars( m_dbImpl->GetControlRef(), NULL, &vertScrollBar );
 808             if (totalWidth > width)
 809                 SetDataBrowserHasScrollBars( m_dbImpl->GetControlRef(), true, vertScrollBar );
 810             else
 811                 SetDataBrowserHasScrollBars( m_dbImpl->GetControlRef(), false, vertScrollBar );
 812         }
 813     }
 814 }
 815
 816 wxSize wxListCtrl::DoGetBestSize() const
 817 {
 818     return wxWindow::DoGetBestSize();
 819 }
 820
 821 bool wxListCtrl::SetFont(const wxFont& font)
 822 {
 823     bool rv = true;
 824     rv = wxControl::SetFont(font);
 825     if (m_genericImpl)
 826         rv = m_genericImpl->SetFont(font);
 827     return rv;
 828 }
 829
 830 bool wxListCtrl::SetForegroundColour(const wxColour& colour)
 831 {
 832     bool rv = true;
 833     if (m_genericImpl)
 834         rv = m_genericImpl->SetForegroundColour(colour);
 835     if (m_dbImpl)
 836         SetTextColour(colour);
 837     return rv;
 838 }
 839
 840 bool wxListCtrl::SetBackgroundColour(const wxColour& colour)
 841 {
 842     bool rv = true;
 843     if (m_genericImpl)
 844         rv = m_genericImpl->SetBackgroundColour(colour);
 845     if (m_dbImpl)
 846         m_bgColor = colour;
 847     return rv;
 848 }
 849
 850 wxColour wxListCtrl::GetBackgroundColour()
 851 {
 852     if (m_genericImpl)
 853         return m_genericImpl->GetBackgroundColour();
 854     if (m_dbImpl)
 855         return m_bgColor;
 856
 857     return wxNullColour;
 858 }
 859
 860 // ----------------------------------------------------------------------------
 861 // accessors
 862 // ----------------------------------------------------------------------------
 863
 864 // Gets information about this column
 865 bool wxListCtrl::GetColumn(int col, wxListItem& item) const
 866 {
 867     if (m_genericImpl)
 868         return m_genericImpl->GetColumn(col, item);
 869
 870     bool success = true;
 871
 872     if (m_dbImpl)
 873     {
 874         wxColumnList::compatibility_iterator node = m_colsInfo.Item( col );
 875         wxASSERT_MSG( node, _T("invalid column index in wxMacListCtrlItem") );
 876         wxListItem* column = node->GetData();
 877
 878         long mask = column->GetMask();
 879         if (mask & wxLIST_MASK_TEXT)
 880             item.SetText(column->GetText());
 881         if (mask & wxLIST_MASK_DATA)
 882             item.SetData(column->GetData());
 883         if (mask & wxLIST_MASK_IMAGE)
 884             item.SetImage(column->GetImage());
 885         if (mask & wxLIST_MASK_STATE)
 886             item.SetState(column->GetState());
 887         if (mask & wxLIST_MASK_FORMAT)
 888             item.SetAlign(column->GetAlign());
 889         if (mask & wxLIST_MASK_WIDTH)
 890             item.SetWidth(column->GetWidth());
 891     }
 892
 893     return success;
 894 }
 895
 896 // Sets information about this column
 897 bool wxListCtrl::SetColumn(int col, wxListItem& item)
 898 {
 899     if (m_genericImpl)
 900         return m_genericImpl->SetColumn(col, item);
 901
 902     if (m_dbImpl)
 903     {
 904         long mask = item.GetMask();
 905         if ( col >= (int)m_colsInfo.GetCount() )
 906         {
 907             wxListItem* listItem = new wxListItem(item);
 908             m_colsInfo.Append( listItem );
 909         }
 910         else
 911         {
 912             wxListItem listItem;
 913             GetColumn( col, listItem );
 914
 915             if (mask & wxLIST_MASK_TEXT)
 916                 listItem.SetText(item.GetText());
 917             if (mask & wxLIST_MASK_DATA)
 918                 listItem.SetData(item.GetData());
 919             if (mask & wxLIST_MASK_IMAGE)
 920                 listItem.SetImage(item.GetImage());
 921             if (mask & wxLIST_MASK_STATE)
 922                 listItem.SetState(item.GetState());
 923             if (mask & wxLIST_MASK_FORMAT)
 924                 listItem.SetAlign(item.GetAlign());
 925             if (mask & wxLIST_MASK_WIDTH)
 926                 listItem.SetWidth(item.GetWidth());
 927         }
 928
 929         // change the appearance in the databrowser.
 930         DataBrowserListViewHeaderDesc columnDesc;
 931         columnDesc.version=kDataBrowserListViewLatestHeaderDesc;
 932         verify_noerr( m_dbImpl->GetHeaderDesc( kMinColumnId + col, &columnDesc ) );
 933
 934         /*
 935         if (item.GetMask() & wxLIST_MASK_TEXT)
 936         {
 937             wxFontEncoding enc;
 938             if ( m_font.Ok() )
 939                 enc = m_font.GetEncoding();
 940             else
 941                 enc = wxLocale::GetSystemEncoding();
 942             wxMacCFStringHolder cfTitle;
 943             cfTitle.Assign( item.GetText() , enc );
 944             if(columnDesc.titleString)
 945                 CFRelease(columnDesc.titleString);
 946             columnDesc.titleString = cfTitle;
 947         }
 948         */
 949
 950         if (item.GetMask() & wxLIST_MASK_IMAGE && item.GetImage() != -1 )
 951         {
 952             columnDesc.btnContentInfo.contentType = kControlContentIconRef;
 953             wxImageList* imageList = GetImageList(wxIMAGE_LIST_SMALL);
 954             if (imageList && imageList->GetImageCount() > 0 )
 955             {
 956                 wxBitmap bmp = imageList->GetBitmap( item.GetImage() );
 957                 IconRef icon = bmp.GetBitmapData()->GetIconRef();
 958                 columnDesc.btnContentInfo.u.iconRef = icon;
 959             }
 960         }
 961
 962         verify_noerr( m_dbImpl->SetHeaderDesc( kMinColumnId + col, &columnDesc ) );
 963
 964     }
 965     return true;
 966 }
 967
 968 int wxListCtrl::GetColumnCount() const
 969 {
 970     if (m_genericImpl)
 971         return m_genericImpl->GetColumnCount();
 972
 973     if (m_dbImpl)
 974     {
 975         UInt32 count;
 976         m_dbImpl->GetColumnCount(&count);
 977         return count;
 978     }
 979
 980     return m_colCount;
 981 }
 982
 983 // Gets the column width
 984 int wxListCtrl::GetColumnWidth(int col) const
 985 {
 986     if (m_genericImpl)
 987         return m_genericImpl->GetColumnWidth(col);
 988
 989     if (m_dbImpl)
 990     {
 991         return m_dbImpl->GetColumnWidth(col);
 992     }
 993
 994     return 0;
 995 }
 996
 997 // Sets the column width
 998 bool wxListCtrl::SetColumnWidth(int col, int width)
 999 {
1000     if (m_genericImpl)
1001         return m_genericImpl->SetColumnWidth(col, width);
1002
1003     if (m_dbImpl)
1004     {
1005         int mywidth = width;
1006         if (width == wxLIST_AUTOSIZE || width == wxLIST_AUTOSIZE_USEHEADER)
1007             mywidth = 150;
1008
1009         if (col == -1)
1010         {
1011             for (int column = 0; column < GetColumnCount(); column++)
1012             {
1013                 wxListItem colInfo;
1014                 GetColumn(col, colInfo);
1015
1016                 colInfo.SetWidth(width);
1017                 SetColumn(col, colInfo);
1018
1019                 m_dbImpl->SetColumnWidth(col, mywidth);
1020             }
1021         }
1022         else
1023         {
1024             wxListItem colInfo;
1025             GetColumn(col, colInfo);
1026
1027             colInfo.SetWidth(width);
1028             SetColumn(col, colInfo);
1029             m_dbImpl->SetColumnWidth(col, mywidth);
1030         }
1031         return true;
1032     }
1033
1034     return false;
1035 }
1036
1037 // Gets the number of items that can fit vertically in the
1038 // visible area of the list control (list or report view)
1039 // or the total number of items in the list control (icon
1040 // or small icon view)
1041 int wxListCtrl::GetCountPerPage() const
1042 {
1043     if (m_genericImpl)
1044         return m_genericImpl->GetCountPerPage();
1045
1046     if (m_dbImpl)
1047     {
1048     }
1049
1050     return 1;
1051 }
1052
1053 // Gets the edit control for editing labels.
1054 wxTextCtrl* wxListCtrl::GetEditControl() const
1055 {
1056     if (m_genericImpl)
1057         return m_genericImpl->GetEditControl();
1058
1059     return NULL;
1060 }
1061
1062 // Gets information about the item
1063 bool wxListCtrl::GetItem(wxListItem& info) const
1064 {
1065     if (m_genericImpl)
1066         return m_genericImpl->GetItem(info);
1067
1068     if (m_dbImpl)
1069     {
1070         if (!IsVirtual())
1071         {
1072             if (info.m_itemId >= 0 && info.m_itemId < GetItemCount())
1073                 m_dbImpl->MacGetColumnInfo(info.m_itemId, info.m_col, info);
1074         }
1075         else
1076         {
1077             if (info.m_itemId >= 0 && info.m_itemId < GetItemCount())
1078             {
1079                 info.SetText( OnGetItemText(info.m_itemId, info.m_col) );
1080                 info.SetImage( OnGetItemColumnImage(info.m_itemId, info.m_col) );
1081                 if (info.GetMask() & wxLIST_MASK_STATE)
1082                 {
1083                     if (IsDataBrowserItemSelected( m_dbImpl->GetControlRef(), info.m_itemId+1 ))
1084                         info.SetState(info.GetState() | wxLIST_STATE_SELECTED);
1085                 }
1086
1087                 wxListItemAttr* attrs = OnGetItemAttr( info.m_itemId );
1088                 if (attrs)
1089                 {
1090                     info.SetFont( attrs->GetFont() );
1091                     info.SetBackgroundColour( attrs->GetBackgroundColour() );
1092                     info.SetTextColour( attrs->GetTextColour() );
1093                 }
1094             }
1095         }
1096     }
1097     bool success = true;
1098     return success;
1099 }
1100
1101 // Sets information about the item
1102 bool wxListCtrl::SetItem(wxListItem& info)
1103 {
1104     if (m_genericImpl)
1105         return m_genericImpl->SetItem(info);
1106
1107     if (m_dbImpl)
1108         m_dbImpl->MacSetColumnInfo( info.m_itemId, info.m_col, &info );
1109
1110     return true;
1111 }
1112
1113 long wxListCtrl::SetItem(long index, int col, const wxString& label, int imageId)
1114 {
1115     if (m_genericImpl)
1116         return m_genericImpl->SetItem(index, col, label, imageId);
1117
1118     wxListItem info;
1119     info.m_text = label;
1120     info.m_mask = wxLIST_MASK_TEXT;
1121     info.m_itemId = index;
1122     info.m_col = col;
1123     if ( imageId > -1 )
1124     {
1125         info.m_image = imageId;
1126         info.m_mask |= wxLIST_MASK_IMAGE;
1127     }
1128     return SetItem(info);
1129 }
1130
1131
1132 // Gets the item state
1133 int wxListCtrl::GetItemState(long item, long stateMask) const
1134 {
1135     if (m_genericImpl)
1136         return m_genericImpl->GetItemState(item, stateMask);
1137
1138     if (m_dbImpl)
1139     {
1140         if ( HasFlag(wxLC_VIRTUAL) )
1141         {
1142             if (stateMask == wxLIST_STATE_SELECTED)
1143             {
1144                 if (IsDataBrowserItemSelected( m_dbImpl->GetControlRef(), item+1 ))
1145                     return wxLIST_STATE_SELECTED;
1146                 else
1147                     return 0;
1148             }
1149         }
1150         else
1151         {
1152             wxListItem info;
1153
1154             info.m_mask = wxLIST_MASK_STATE;
1155             info.m_stateMask = stateMask;
1156             info.m_itemId = item;
1157
1158             if (!GetItem(info))
1159                 return 0;
1160
1161             return info.m_state;
1162         }
1163     }
1164
1165     return 0;
1166 }
1167
1168 // Sets the item state
1169 bool wxListCtrl::SetItemState(long item, long state, long stateMask)
1170 {
1171     if (m_genericImpl)
1172         return m_genericImpl->SetItemState(item, state, stateMask);
1173
1174     if (m_dbImpl)
1175     {
1176         DataBrowserSetOption option = kDataBrowserItemsAdd;
1177         if ( stateMask == wxLIST_STATE_SELECTED && state == 0 )
1178             option = kDataBrowserItemsRemove;
1179
1180         if (item == -1)
1181         {
1182             if ( HasFlag(wxLC_VIRTUAL) )
1183             {
1184                 wxMacDataItemBrowserSelectionSuppressor suppressor(m_dbImpl);
1185                 m_dbImpl->SetSelectedAllItems(option);
1186             }
1187             else
1188             {
1189                 for(int i = 0; i < GetItemCount();i++)
1190                 {
1191                     wxListItem info;
1192                     info.m_itemId = i;
1193                     info.m_mask = wxLIST_MASK_STATE;
1194                     info.m_stateMask = stateMask;
1195                     info.m_state = state;
1196                     SetItem(info);
1197                 }
1198             }
1199         }
1200         else
1201         {
1202             if ( HasFlag(wxLC_VIRTUAL) )
1203             {
1204                 long itemID = item+1;
1205                 SetDataBrowserSelectedItems(m_dbImpl->GetControlRef(), 1, (DataBrowserItemID*)&itemID, option);
1206             }
1207             else
1208             {
1209                 wxListItem info;
1210                 info.m_itemId = item;
1211                 info.m_mask = wxLIST_MASK_STATE;
1212                 info.m_stateMask = stateMask;
1213                 info.m_state = state;
1214                 return SetItem(info);
1215             }
1216         }
1217     }
1218     return true;
1219 }
1220
1221 // Sets the item image
1222 bool wxListCtrl::SetItemImage(long item, int image, int WXUNUSED(selImage))
1223 {
1224     return SetItemColumnImage(item, 0, image);
1225 }
1226
1227 // Sets the item image
1228 bool wxListCtrl::SetItemColumnImage(long item, long column, int image)
1229 {
1230     if (m_genericImpl)
1231         return m_genericImpl->SetItemColumnImage(item, column, image);
1232
1233     wxListItem info;
1234
1235     info.m_mask = wxLIST_MASK_IMAGE;
1236     info.m_image = image;
1237     info.m_itemId = item;
1238     info.m_col = column;
1239
1240     return SetItem(info);
1241 }
1242
1243 // Gets the item text
1244 wxString wxListCtrl::GetItemText(long item) const
1245 {
1246     if (m_genericImpl)
1247         return m_genericImpl->GetItemText(item);
1248
1249     wxListItem info;
1250
1251     info.m_mask = wxLIST_MASK_TEXT;
1252     info.m_itemId = item;
1253
1254     if (!GetItem(info))
1255         return wxEmptyString;
1256     return info.m_text;
1257 }
1258
1259 // Sets the item text
1260 void wxListCtrl::SetItemText(long item, const wxString& str)
1261 {
1262     if (m_genericImpl)
1263         return m_genericImpl->SetItemText(item, str);
1264
1265     wxListItem info;
1266
1267     info.m_mask = wxLIST_MASK_TEXT;
1268     info.m_itemId = item;
1269     info.m_text = str;
1270
1271     SetItem(info);
1272 }
1273
1274 // Gets the item data
1275 long wxListCtrl::GetItemData(long item) const
1276 {
1277     if (m_genericImpl)
1278         return m_genericImpl->GetItemData(item);
1279
1280     wxListItem info;
1281
1282     info.m_mask = wxLIST_MASK_DATA;
1283     info.m_itemId = item;
1284
1285     if (!GetItem(info))
1286         return 0;
1287     return info.m_data;
1288 }
1289
1290 // Sets the item data
1291 bool wxListCtrl::SetItemData(long item, long data)
1292 {
1293     if (m_genericImpl)
1294         return m_genericImpl->SetItemData(item, data);
1295
1296     wxListItem info;
1297
1298     info.m_mask = wxLIST_MASK_DATA;
1299     info.m_itemId = item;
1300     info.m_data = data;
1301
1302     return SetItem(info);
1303 }
1304
1305 wxRect wxListCtrl::GetViewRect() const
1306 {
1307     wxASSERT_MSG( !HasFlag(wxLC_REPORT | wxLC_LIST),
1308                     _T("wxListCtrl::GetViewRect() only works in icon mode") );
1309
1310     if (m_genericImpl)
1311         return m_genericImpl->GetViewRect();
1312
1313     wxRect rect;
1314     return rect;
1315 }
1316
1317 // Gets the item rectangle
1318 bool wxListCtrl::GetItemRect(long item, wxRect& rect, int code) const
1319 {
1320     if (m_genericImpl)
1321         return m_genericImpl->GetItemRect(item, rect, code);
1322
1323
1324     if (m_dbImpl)
1325     {
1326         DataBrowserItemID id;
1327         DataBrowserPropertyID col = kMinColumnId;
1328         Rect bounds;
1329         DataBrowserPropertyPart part = kDataBrowserPropertyEnclosingPart;
1330         if ( code == wxLIST_RECT_LABEL )
1331             part = kDataBrowserPropertyTextPart;
1332         else if ( code == wxLIST_RECT_ICON )
1333             part = kDataBrowserPropertyIconPart;
1334
1335         if ( !(GetWindowStyleFlag() & wxLC_VIRTUAL) )
1336         {
1337             wxMacDataItem* thisItem = m_dbImpl->GetItemFromLine(item);
1338             id = (DataBrowserItemID) thisItem;
1339         }
1340         else
1341             id = item+1;
1342
1343         GetDataBrowserItemPartBounds( m_dbImpl->GetControlRef(), id, col, part, &bounds );
1344
1345         rect.x = bounds.left;
1346         rect.y = bounds.top;
1347         rect.width = bounds.right - bounds.left; //GetClientSize().x; // we need the width of the whole row, not just the item.
1348         rect.height = bounds.bottom - bounds.top;
1349         //fprintf("id = %d, bounds = %d, %d, %d, %d\n", id, rect.x, rect.y, rect.width, rect.height);
1350     }
1351     return true;
1352 }
1353
1354 // Gets the item position
1355 bool wxListCtrl::GetItemPosition(long item, wxPoint& pos) const
1356 {
1357     if (m_genericImpl)
1358         return m_genericImpl->GetItemPosition(item, pos);
1359
1360     bool success = false;
1361
1362     if (m_dbImpl)
1363     {
1364         wxRect itemRect;
1365         GetItemRect(item, itemRect);
1366         pos = itemRect.GetPosition();
1367         success = true;
1368     }
1369
1370     return success;
1371 }
1372
1373 // Sets the item position.
1374 bool wxListCtrl::SetItemPosition(long item, const wxPoint& pos)
1375 {
1376     if (m_genericImpl)
1377         return m_genericImpl->SetItemPosition(item, pos);
1378
1379     return false;
1380 }
1381
1382 // Gets the number of items in the list control
1383 int wxListCtrl::GetItemCount() const
1384 {
1385     if (m_genericImpl)
1386         return m_genericImpl->GetItemCount();
1387
1388     if (m_dbImpl)
1389         return m_dbImpl->MacGetCount();
1390
1391     return m_count;
1392 }
1393
1394 void wxListCtrl::SetItemSpacing( int spacing, bool isSmall )
1395 {
1396     if (m_genericImpl)
1397         m_genericImpl->SetItemSpacing(spacing, isSmall);
1398 }
1399
1400 wxSize wxListCtrl::GetItemSpacing() const
1401 {
1402     if (m_genericImpl)
1403         return m_genericImpl->GetItemSpacing();
1404
1405     return wxSize(0, 0);
1406 }
1407
1408 void wxListCtrl::SetItemTextColour( long item, const wxColour &col )
1409 {
1410     if (m_genericImpl)
1411     {
1412         m_genericImpl->SetItemTextColour(item, col);
1413         return;
1414     }
1415
1416     wxListItem info;
1417     info.m_itemId = item;
1418     info.SetTextColour( col );
1419     SetItem( info );
1420 }
1421
1422 wxColour wxListCtrl::GetItemTextColour( long item ) const
1423 {
1424     if (m_genericImpl)
1425         return m_genericImpl->GetItemTextColour(item);
1426
1427     if (m_dbImpl)
1428     {
1429         wxListItem info;
1430         if (GetItem(info))
1431             return info.GetTextColour();
1432     }
1433     return wxNullColour;
1434 }
1435
1436 void wxListCtrl::SetItemBackgroundColour( long item, const wxColour &col )
1437 {
1438     if (m_genericImpl)
1439     {
1440         m_genericImpl->SetItemBackgroundColour(item, col);
1441         return;
1442     }
1443
1444     wxListItem info;
1445     info.m_itemId = item;
1446     info.SetBackgroundColour( col );
1447     SetItem( info );
1448 }
1449
1450 wxColour wxListCtrl::GetItemBackgroundColour( long item ) const
1451 {
1452     if (m_genericImpl)
1453         return m_genericImpl->GetItemBackgroundColour(item);
1454
1455     if (m_dbImpl)
1456     {
1457         wxListItem info;
1458         if (GetItem(info))
1459             return info.GetBackgroundColour();
1460     }
1461     return wxNullColour;
1462 }
1463
1464 void wxListCtrl::SetItemFont( long item, const wxFont &f )
1465 {
1466     if (m_genericImpl)
1467     {
1468         m_genericImpl->SetItemFont(item, f);
1469         return;
1470     }
1471
1472     wxListItem info;
1473     info.m_itemId = item;
1474     info.SetFont( f );
1475     SetItem( info );
1476 }
1477
1478 wxFont wxListCtrl::GetItemFont( long item ) const
1479 {
1480     if (m_genericImpl)
1481         return m_genericImpl->GetItemFont(item);
1482
1483     if (m_dbImpl)
1484     {
1485         wxListItem info;
1486         if (GetItem(info))
1487             return info.GetFont();
1488     }
1489
1490     return wxNullFont;
1491 }
1492
1493 // Gets the number of selected items in the list control
1494 int wxListCtrl::GetSelectedItemCount() const
1495 {
1496     if (m_genericImpl)
1497         return m_genericImpl->GetSelectedItemCount();
1498
1499     if (m_dbImpl)
1500         return m_dbImpl->GetSelectedItemCount(NULL, true);
1501
1502     return 0;
1503 }
1504
1505 // Gets the text colour of the listview
1506 wxColour wxListCtrl::GetTextColour() const
1507 {
1508     if (m_genericImpl)
1509         return m_genericImpl->GetTextColour();
1510
1511     // TODO: we need owner drawn list items to customize text color.
1512     if (m_dbImpl)
1513         return m_textColor;
1514
1515     return wxNullColour;
1516 }
1517
1518 // Sets the text colour of the listview
1519 void wxListCtrl::SetTextColour(const wxColour& col)
1520 {
1521     if (m_genericImpl)
1522     {
1523         m_genericImpl->SetTextColour(col);
1524         return;
1525     }
1526
1527     if (m_dbImpl)
1528         m_textColor = col;
1529 }
1530
1531 // Gets the index of the topmost visible item when in
1532 // list or report view
1533 long wxListCtrl::GetTopItem() const
1534 {
1535     if (m_genericImpl)
1536         return m_genericImpl->GetTopItem();
1537
1538     if (m_dbImpl)
1539     {
1540         int flags = 0;
1541         long item = HitTest( wxPoint(1, 1), flags);
1542         if (flags == wxLIST_HITTEST_ONITEM)
1543             return item;
1544     }
1545
1546     return 0;
1547 }
1548
1549 // Searches for an item, starting from 'item'.
1550 // 'geometry' is one of
1551 // wxLIST_NEXT_ABOVE/ALL/BELOW/LEFT/RIGHT.
1552 // 'state' is a state bit flag, one or more of
1553 // wxLIST_STATE_DROPHILITED/FOCUSED/SELECTED/CUT.
1554 // item can be -1 to find the first item that matches the
1555 // specified flags.
1556 // Returns the item or -1 if unsuccessful.
1557 long wxListCtrl::GetNextItem(long item, int geom, int state) const
1558 {
1559     if (m_genericImpl)
1560         return m_genericImpl->GetNextItem(item, geom, state);
1561
1562     // TODO: implement all geometry and state options?
1563     if ( m_dbImpl )
1564     {
1565         if ( geom == wxLIST_NEXT_ALL || geom == wxLIST_NEXT_BELOW )
1566         {
1567             long count = m_dbImpl->MacGetCount() ;
1568             for ( long line = item + 1 ; line < count; line++ )
1569             {
1570                 DataBrowserItemID id = line + 1;
1571                 if ( !IsVirtual() )
1572                     id = (DataBrowserItemID)m_dbImpl->GetItemFromLine(line);
1573
1574                 if ( (state == wxLIST_STATE_DONTCARE ) )
1575                     return line;
1576
1577                 if ( (state & wxLIST_STATE_SELECTED) && IsDataBrowserItemSelected(m_dbImpl->GetControlRef(), id ) )
1578                     return line;
1579             }
1580         }
1581
1582         if ( geom == wxLIST_NEXT_ALL || geom == wxLIST_NEXT_ABOVE )
1583         {
1584             int item2 = item;
1585             if ( item2 == -1 )
1586                 item2 = m_dbImpl->MacGetCount();
1587
1588             for ( long line = item2 - 1 ; line >= 0; line-- )
1589             {
1590                 DataBrowserItemID id = line + 1;
1591                 if ( !IsVirtual() )
1592                     id = (DataBrowserItemID)m_dbImpl->GetItemFromLine(line);
1593
1594                 if ( (state == wxLIST_STATE_DONTCARE ) )
1595                     return line;
1596
1597                 if ( (state & wxLIST_STATE_SELECTED) && IsDataBrowserItemSelected(m_dbImpl->GetControlRef(), id ) )
1598                     return line;
1599             }
1600         }
1601     }
1602
1603     return -1;
1604 }
1605
1606
1607 wxImageList *wxListCtrl::GetImageList(int which) const
1608 {
1609     if (m_genericImpl)
1610         return m_genericImpl->GetImageList(which);
1611
1612     if ( which == wxIMAGE_LIST_NORMAL )
1613     {
1614         return m_imageListNormal;
1615     }
1616     else if ( which == wxIMAGE_LIST_SMALL )
1617     {
1618         return m_imageListSmall;
1619     }
1620     else if ( which == wxIMAGE_LIST_STATE )
1621     {
1622         return m_imageListState;
1623     }
1624     return NULL;
1625 }
1626
1627 void wxListCtrl::SetImageList(wxImageList *imageList, int which)
1628 {
1629     if (m_genericImpl)
1630     {
1631         m_genericImpl->SetImageList(imageList, which);
1632         return;
1633     }
1634
1635     if ( which == wxIMAGE_LIST_NORMAL )
1636     {
1637         if (m_ownsImageListNormal) delete m_imageListNormal;
1638         m_imageListNormal = imageList;
1639         m_ownsImageListNormal = false;
1640     }
1641     else if ( which == wxIMAGE_LIST_SMALL )
1642     {
1643         if (m_ownsImageListSmall) delete m_imageListSmall;
1644         m_imageListSmall = imageList;
1645         m_ownsImageListSmall = false;
1646     }
1647     else if ( which == wxIMAGE_LIST_STATE )
1648     {
1649         if (m_ownsImageListState) delete m_imageListState;
1650         m_imageListState = imageList;
1651         m_ownsImageListState = false;
1652     }
1653 }
1654
1655 void wxListCtrl::AssignImageList(wxImageList *imageList, int which)
1656 {
1657     if (m_genericImpl)
1658     {
1659         m_genericImpl->AssignImageList(imageList, which);
1660         return;
1661     }
1662
1663     SetImageList(imageList, which);
1664     if ( which == wxIMAGE_LIST_NORMAL )
1665         m_ownsImageListNormal = true;
1666     else if ( which == wxIMAGE_LIST_SMALL )
1667         m_ownsImageListSmall = true;
1668     else if ( which == wxIMAGE_LIST_STATE )
1669         m_ownsImageListState = true;
1670 }
1671
1672 // ----------------------------------------------------------------------------
1673 // Operations
1674 // ----------------------------------------------------------------------------
1675
1676 // Arranges the items
1677 bool wxListCtrl::Arrange(int flag)
1678 {
1679     if (m_genericImpl)
1680         return m_genericImpl->Arrange(flag);
1681     return false;
1682 }
1683
1684 // Deletes an item
1685 bool wxListCtrl::DeleteItem(long item)
1686 {
1687     if (m_genericImpl)
1688         return m_genericImpl->DeleteItem(item);
1689
1690     if (m_dbImpl)
1691     {
1692         m_dbImpl->MacDelete(item);
1693         wxListEvent event( wxEVT_COMMAND_LIST_DELETE_ITEM, GetId() );
1694         event.SetEventObject( this );
1695         event.m_itemIndex = item;
1696         GetEventHandler()->ProcessEvent( event );
1697
1698     }
1699     return true;
1700 }
1701
1702 // Deletes all items
1703 bool wxListCtrl::DeleteAllItems()
1704 {
1705     if (m_genericImpl)
1706         return m_genericImpl->DeleteAllItems();
1707
1708     if (m_dbImpl)
1709     {
1710         m_dbImpl->MacClear();
1711         wxListEvent event( wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS, GetId() );
1712         event.SetEventObject( this );
1713         GetEventHandler()->ProcessEvent( event );
1714     }
1715     return true;
1716 }
1717
1718 // Deletes all items
1719 bool wxListCtrl::DeleteAllColumns()
1720 {
1721     if (m_genericImpl)
1722         return m_genericImpl->DeleteAllColumns();
1723
1724     if (m_dbImpl)
1725     {
1726         UInt32 cols;
1727         m_dbImpl->GetColumnCount(&cols);
1728         for (UInt32 col = 0; col < cols; col++)
1729         {
1730                 DeleteColumn(0);
1731         }
1732     }
1733
1734     return true;
1735 }
1736
1737 // Deletes a column
1738 bool wxListCtrl::DeleteColumn(int col)
1739 {
1740     if (m_genericImpl)
1741         return m_genericImpl->DeleteColumn(col);
1742
1743     if (m_dbImpl)
1744     {
1745         OSStatus err = m_dbImpl->RemoveColumn(col);
1746         return err == noErr;
1747     }
1748
1749     return true;
1750 }
1751
1752 // Clears items, and columns if there are any.
1753 void wxListCtrl::ClearAll()
1754 {
1755     if (m_genericImpl)
1756     {
1757         m_genericImpl->ClearAll();
1758         return;
1759     }
1760
1761     if (m_dbImpl)
1762     {
1763         DeleteAllItems();
1764         DeleteAllColumns();
1765     }
1766 }
1767
1768 wxTextCtrl* wxListCtrl::EditLabel(long item, wxClassInfo* textControlClass)
1769 {
1770     if (m_genericImpl)
1771         return m_genericImpl->EditLabel(item, textControlClass);
1772
1773     if (m_dbImpl)
1774     {
1775         wxCHECK_MSG( (item >= 0) && ((long)item < GetItemCount()), NULL,
1776                      wxT("wrong index in wxListCtrl::EditLabel()") );
1777
1778         wxASSERT_MSG( textControlClass->IsKindOf(CLASSINFO(wxTextCtrl)),
1779                      wxT("EditLabel() needs a text control") );
1780
1781         wxListEvent le( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT, GetParent()->GetId() );
1782         le.SetEventObject( this );
1783         le.m_itemIndex = item;
1784         le.m_col = 0;
1785         GetItem( le.m_item );
1786
1787         if ( GetParent()->GetEventHandler()->ProcessEvent( le ) && !le.IsAllowed() )
1788         {
1789             // vetoed by user code
1790             return NULL;
1791         }
1792
1793         wxTextCtrl * const text = (wxTextCtrl *)textControlClass->CreateObject();
1794         m_textctrlWrapper = new wxListCtrlTextCtrlWrapper(this, text, item);
1795         return m_textctrlWrapper->GetText();
1796     }
1797     return NULL;
1798 }
1799
1800 // End label editing, optionally cancelling the edit
1801 bool wxListCtrl::EndEditLabel(bool cancel)
1802 {
1803     // TODO: generic impl. doesn't have this method - is it needed for us?
1804     if (m_genericImpl)
1805         return true; // m_genericImpl->EndEditLabel(cancel);
1806
1807     if (m_dbImpl)
1808         verify_noerr( SetDataBrowserEditItem(m_dbImpl->GetControlRef(), kDataBrowserNoItem, kMinColumnId) );
1809     return true;
1810 }
1811
1812 // Ensures this item is visible
1813 bool wxListCtrl::EnsureVisible(long item)
1814 {
1815     if (m_genericImpl)
1816         return m_genericImpl->EnsureVisible(item);
1817
1818     if (m_dbImpl)
1819     {
1820         wxMacDataItem* dataItem = m_dbImpl->GetItemFromLine(item);
1821         m_dbImpl->RevealItem(dataItem, kDataBrowserRevealWithoutSelecting);
1822     }
1823
1824     return true;
1825 }
1826
1827 // Find an item whose label matches this string, starting from the item after 'start'
1828 // or the beginning if 'start' is -1.
1829 long wxListCtrl::FindItem(long start, const wxString& str, bool partial)
1830 {
1831     if (m_genericImpl)
1832         return m_genericImpl->FindItem(start, str, partial);
1833
1834     wxString str_upper = str.Upper();
1835
1836     long idx = start;
1837     if (idx < 0)
1838         idx = 0;
1839     long count = GetItemCount();
1840
1841     while (idx < count)
1842     {
1843         wxString line_upper = GetItemText(idx).Upper();
1844         if (!partial)
1845         {
1846             if (line_upper == str_upper )
1847                 return idx;
1848         }
1849         else
1850         {
1851             if (line_upper.find(str_upper) == 0)
1852                 return idx;
1853         }
1854
1855         idx++;
1856     };
1857
1858     return wxNOT_FOUND;
1859 }
1860
1861 // Find an item whose data matches this data, starting from the item after 'start'
1862 // or the beginning if 'start' is -1.
1863 long wxListCtrl::FindItem(long start, long data)
1864 {
1865     if (m_genericImpl)
1866         return m_genericImpl->FindItem(start, data);
1867
1868     long idx = start;
1869     if (idx < 0)
1870         idx = 0;
1871     long count = GetItemCount();
1872
1873     while (idx < count)
1874     {
1875         if (GetItemData(idx) == data)
1876             return idx;
1877         idx++;
1878     };
1879
1880     return wxNOT_FOUND;
1881 }
1882
1883 // Find an item nearest this position in the specified direction, starting from
1884 // the item after 'start' or the beginning if 'start' is -1.
1885 long wxListCtrl::FindItem(long start, const wxPoint& pt, int direction)
1886 {
1887     if (m_genericImpl)
1888         return m_genericImpl->FindItem(start, pt, direction);
1889     return -1;
1890 }
1891
1892 // Determines which item (if any) is at the specified point,
1893 // giving details in 'flags' (see wxLIST_HITTEST_... flags above)
1894 long
1895 wxListCtrl::HitTest(const wxPoint& point, int& flags, long *ptrSubItem) const
1896 {
1897     if (m_genericImpl)
1898         return m_genericImpl->HitTest(point, flags, ptrSubItem);
1899
1900     flags = wxLIST_HITTEST_NOWHERE;
1901     if (m_dbImpl)
1902     {
1903         int colHeaderHeight = 22; // TODO: Find a way to get this value from the db control?
1904         UInt16 rowHeight = 0;
1905         m_dbImpl->GetDefaultRowHeight(&rowHeight);
1906
1907         int y = point.y;
1908         // get the actual row by taking scroll position into account
1909         UInt32 offsetX, offsetY;
1910         m_dbImpl->GetScrollPosition( &offsetY, &offsetX );
1911         y += offsetY;
1912
1913         if ( !(GetWindowStyleFlag() & wxLC_NO_HEADER) )
1914             y -= colHeaderHeight;
1915
1916         if ( y < 0 )
1917             return -1;
1918
1919         int row = y / rowHeight;
1920         DataBrowserItemID id;
1921         m_dbImpl->GetItemID( (DataBrowserTableViewRowIndex) row, &id );
1922
1923         // TODO: Use GetDataBrowserItemPartBounds to return if we are in icon or label
1924         if ( !(GetWindowStyleFlag() & wxLC_VIRTUAL ) )
1925         {
1926             wxMacListCtrlItem* lcItem;
1927             lcItem = (wxMacListCtrlItem*) id;
1928             if (lcItem)
1929             {
1930                 flags = wxLIST_HITTEST_ONITEM;
1931                 return row;
1932             }
1933         }
1934         else
1935         {
1936             if (row < GetItemCount() )
1937             {
1938                 flags = wxLIST_HITTEST_ONITEM;
1939                 return row;
1940             }
1941         }
1942
1943     }
1944     return -1;
1945 }
1946
1947 int wxListCtrl::GetScrollPos(int orient) const
1948 {
1949     if (m_genericImpl)
1950         return m_genericImpl->GetScrollPos(orient);
1951
1952     if (m_dbImpl)
1953     {
1954         UInt32 offsetX, offsetY;
1955         m_dbImpl->GetScrollPosition( &offsetY, &offsetX );
1956         if ( orient == wxHORIZONTAL )
1957            return offsetX;
1958         else
1959            return offsetY;
1960     }
1961
1962     return 0;
1963 }
1964
1965 // Inserts an item, returning the index of the new item if successful,
1966 // -1 otherwise.
1967 long wxListCtrl::InsertItem(wxListItem& info)
1968 {
1969     wxASSERT_MSG( !IsVirtual(), _T("can't be used with virtual controls") );
1970
1971     if (m_genericImpl)
1972         return m_genericImpl->InsertItem(info);
1973
1974     if (m_dbImpl && !IsVirtual())
1975     {
1976         int count = GetItemCount();
1977
1978         if (info.m_itemId > count)
1979             info.m_itemId = count;
1980
1981         m_dbImpl->MacInsertItem(info.m_itemId, &info );
1982
1983         wxListEvent event( wxEVT_COMMAND_LIST_INSERT_ITEM, GetId() );
1984         event.SetEventObject( this );
1985         event.m_itemIndex = info.m_itemId;
1986         GetEventHandler()->ProcessEvent( event );
1987         return info.m_itemId;
1988     }
1989     return -1;
1990 }
1991
1992 long wxListCtrl::InsertItem(long index, const wxString& label)
1993 {
1994     if (m_genericImpl)
1995         return m_genericImpl->InsertItem(index, label);
1996
1997     wxListItem info;
1998     info.m_text = label;
1999     info.m_mask = wxLIST_MASK_TEXT;
2000     info.m_itemId = index;
2001     return InsertItem(info);
2002 }
2003
2004 // Inserts an image item
2005 long wxListCtrl::InsertItem(long index, int imageIndex)
2006 {
2007     if (m_genericImpl)
2008         return m_genericImpl->InsertItem(index, imageIndex);
2009
2010     wxListItem info;
2011     info.m_image = imageIndex;
2012     info.m_mask = wxLIST_MASK_IMAGE;
2013     info.m_itemId = index;
2014     return InsertItem(info);
2015 }
2016
2017 // Inserts an image/string item
2018 long wxListCtrl::InsertItem(long index, const wxString& label, int imageIndex)
2019 {
2020     if (m_genericImpl)
2021         return m_genericImpl->InsertItem(index, label, imageIndex);
2022
2023     wxListItem info;
2024     info.m_image = imageIndex;
2025     info.m_text = label;
2026     info.m_mask = wxLIST_MASK_IMAGE | wxLIST_MASK_TEXT;
2027     info.m_itemId = index;
2028     return InsertItem(info);
2029 }
2030
2031 // For list view mode (only), inserts a column.
2032 long wxListCtrl::InsertColumn(long col, wxListItem& item)
2033 {
2034     if (m_genericImpl)
2035         return m_genericImpl->InsertColumn(col, item);
2036
2037     if (m_dbImpl)
2038     {
2039         int width = item.GetWidth();
2040         if ( !(item.GetMask() & wxLIST_MASK_WIDTH) )
2041             width = 150;
2042
2043         DataBrowserPropertyType type = kDataBrowserCustomType; //kDataBrowserTextType;
2044         wxImageList* imageList = GetImageList(wxIMAGE_LIST_SMALL);
2045         if (imageList && imageList->GetImageCount() > 0)
2046         {
2047             wxBitmap bmp = imageList->GetBitmap(0);
2048             //if (bmp.Ok())
2049             //    type = kDataBrowserIconAndTextType;
2050         }
2051
2052         SInt16 just = teFlushDefault;
2053         if (item.GetMask() & wxLIST_MASK_FORMAT)
2054         {
2055             if (item.GetAlign() == wxLIST_FORMAT_LEFT)
2056                 just = teFlushLeft;
2057             else if (item.GetAlign() == wxLIST_FORMAT_CENTER)
2058                 just = teCenter;
2059             else if (item.GetAlign() == wxLIST_FORMAT_RIGHT)
2060                 just = teFlushRight;
2061         }
2062         m_dbImpl->InsertColumn(col, type, item.GetText(), just, width);
2063         SetColumn(col, item);
2064
2065         // set/remove options based on the wxListCtrl type.
2066         DataBrowserTableViewColumnID id;
2067         m_dbImpl->GetColumnIDFromIndex(col, &id);
2068         DataBrowserPropertyFlags flags;
2069         verify_noerr(m_dbImpl->GetPropertyFlags(id, &flags));
2070         if (GetWindowStyleFlag() & wxLC_EDIT_LABELS)
2071             flags |= kDataBrowserPropertyIsEditable;
2072
2073         if (GetWindowStyleFlag() & wxLC_VIRTUAL){
2074             flags &= ~kDataBrowserListViewSortableColumn;
2075         }
2076         verify_noerr(m_dbImpl->SetPropertyFlags(id, flags));
2077     }
2078
2079     return col;
2080 }
2081
2082 long wxListCtrl::InsertColumn(long col,
2083                               const wxString& heading,
2084                               int format,
2085                               int width)
2086 {
2087     if (m_genericImpl)
2088         return m_genericImpl->InsertColumn(col, heading, format, width);
2089
2090     wxListItem item;
2091     item.m_mask = wxLIST_MASK_TEXT | wxLIST_MASK_FORMAT;
2092     item.m_text = heading;
2093     if ( width > -1 )
2094     {
2095         item.m_mask |= wxLIST_MASK_WIDTH;
2096         item.m_width = width;
2097     }
2098     item.m_format = format;
2099
2100     return InsertColumn(col, item);
2101 }
2102
2103 // scroll the control by the given number of pixels (exception: in list view,
2104 // dx is interpreted as number of columns)
2105 bool wxListCtrl::ScrollList(int dx, int dy)
2106 {
2107     if (m_genericImpl)
2108         return m_genericImpl->ScrollList(dx, dy);
2109
2110     if (m_dbImpl)
2111     {
2112         m_dbImpl->SetScrollPosition(dx, dy);
2113     }
2114     return true;
2115 }
2116
2117
2118 bool wxListCtrl::SortItems(wxListCtrlCompare fn, long data)
2119 {
2120     if (m_genericImpl)
2121         return m_genericImpl->SortItems(fn, data);
2122
2123     if (m_dbImpl)
2124     {
2125         m_compareFunc = fn;
2126         m_compareFuncData = data;
2127         SortDataBrowserContainer( m_dbImpl->GetControlRef(), kDataBrowserNoItem, true);
2128
2129         // we need to do this after each call, else we get a crash from wxPython when
2130         // SortItems is called the second time.
2131         m_compareFunc = NULL;
2132         m_compareFuncData = 0;
2133     }
2134
2135     return true;
2136 }
2137
2138 void wxListCtrl::OnRenameTimer()
2139 {
2140     wxCHECK_RET( HasCurrent(), wxT("unexpected rename timer") );
2141
2142     EditLabel( m_current );
2143 }
2144
2145 bool wxListCtrl::OnRenameAccept(long itemEdit, const wxString& value)
2146 {
2147     wxListEvent le( wxEVT_COMMAND_LIST_END_LABEL_EDIT, GetId() );
2148     le.SetEventObject( this );
2149     le.m_itemIndex = itemEdit;
2150
2151     GetItem( le.m_item );
2152     le.m_item.m_text = value;
2153     return !GetEventHandler()->ProcessEvent( le ) ||
2154                 le.IsAllowed();
2155 }
2156
2157 void wxListCtrl::OnRenameCancelled(long itemEdit)
2158 {
2159     // let owner know that the edit was cancelled
2160     wxListEvent le( wxEVT_COMMAND_LIST_END_LABEL_EDIT, GetParent()->GetId() );
2161
2162     le.SetEditCanceled(true);
2163
2164     le.SetEventObject( this );
2165     le.m_itemIndex = itemEdit;
2166
2167     GetItem( le.m_item );
2168     GetEventHandler()->ProcessEvent( le );
2169 }
2170
2171 // ----------------------------------------------------------------------------
2172 // virtual list controls
2173 // ----------------------------------------------------------------------------
2174
2175 wxString wxListCtrl::OnGetItemText(long WXUNUSED(item), long WXUNUSED(col)) const
2176 {
2177     // this is a pure virtual function, in fact - which is not really pure
2178     // because the controls which are not virtual don't need to implement it
2179     wxFAIL_MSG( _T("wxListCtrl::OnGetItemText not supposed to be called") );
2180
2181     return wxEmptyString;
2182 }
2183
2184 int wxListCtrl::OnGetItemImage(long WXUNUSED(item)) const
2185 {
2186     wxCHECK_MSG(!GetImageList(wxIMAGE_LIST_SMALL),
2187                 -1,
2188                 wxT("List control has an image list, OnGetItemImage or OnGetItemColumnImage should be overridden."));
2189     return -1;
2190 }
2191
2192 int wxListCtrl::OnGetItemColumnImage(long item, long column) const
2193 {
2194     if (!column)
2195         return OnGetItemImage(item);
2196
2197     return -1;
2198 }
2199
2200 wxListItemAttr *wxListCtrl::OnGetItemAttr(long WXUNUSED_UNLESS_DEBUG(item)) const
2201 {
2202     wxASSERT_MSG( item >= 0 && item < GetItemCount(),
2203                   _T("invalid item index in OnGetItemAttr()") );
2204
2205     // no attributes by default
2206     return NULL;
2207 }
2208
2209 void wxListCtrl::SetItemCount(long count)
2210 {
2211     wxASSERT_MSG( IsVirtual(), _T("this is for virtual controls only") );
2212
2213     if (m_genericImpl)
2214     {
2215         m_genericImpl->SetItemCount(count);
2216         return;
2217     }
2218
2219     if (m_dbImpl)
2220     {
2221         // we need to temporarily disable the new item creation notification
2222         // procedure to speed things up
2223         // FIXME: Even this doesn't seem to help much...
2224
2225         // FIXME: Find a more efficient way to do this.
2226         m_dbImpl->MacClear();
2227
2228         DataBrowserCallbacks callbacks;
2229         DataBrowserItemNotificationUPP itemUPP;
2230         GetDataBrowserCallbacks(m_dbImpl->GetControlRef(), &callbacks);
2231         itemUPP = callbacks.u.v1.itemNotificationCallback;
2232         callbacks.u.v1.itemNotificationCallback = 0;
2233         m_dbImpl->SetCallbacks(&callbacks);
2234         ::AddDataBrowserItems(m_dbImpl->GetControlRef(), kDataBrowserNoItem,
2235             count, NULL, kDataBrowserItemNoProperty);
2236         callbacks.u.v1.itemNotificationCallback = itemUPP;
2237         m_dbImpl->SetCallbacks(&callbacks);
2238     }
2239     m_count = count;
2240 }
2241
2242 void wxListCtrl::RefreshItem(long item)
2243 {
2244     if (m_genericImpl)
2245     {
2246         m_genericImpl->RefreshItem(item);
2247         return;
2248     }
2249
2250     wxRect rect;
2251     GetItemRect(item, rect);
2252     RefreshRect(rect);
2253 }
2254
2255 void wxListCtrl::RefreshItems(long itemFrom, long itemTo)
2256 {
2257     if (m_genericImpl)
2258     {
2259         m_genericImpl->RefreshItems(itemFrom, itemTo);
2260         return;
2261     }
2262
2263     wxRect rect1, rect2;
2264     GetItemRect(itemFrom, rect1);
2265     GetItemRect(itemTo, rect2);
2266
2267     wxRect rect = rect1;
2268     rect.height = rect2.GetBottom() - rect1.GetTop();
2269
2270     RefreshRect(rect);
2271 }
2272
2273 void wxListCtrl::SetDropTarget( wxDropTarget *dropTarget )
2274 {
2275 #if wxUSE_DRAG_AND_DROP
2276     if (m_genericImpl)
2277         m_genericImpl->SetDropTarget( dropTarget );
2278
2279     if (m_dbImpl)
2280         wxWindow::SetDropTarget( dropTarget );
2281 #endif
2282 }
2283
2284 wxDropTarget *wxListCtrl::GetDropTarget() const
2285 {
2286 #if wxUSE_DRAG_AND_DROP
2287     if (m_genericImpl)
2288         return m_genericImpl->GetDropTarget();
2289
2290     if (m_dbImpl)
2291         return wxWindow::GetDropTarget();
2292 #endif
2293     return NULL;
2294 }
2295
2296 #if wxABI_VERSION >= 20801
2297 void wxListCtrl::SetFocus()
2298 {
2299         if (m_genericImpl)
2300         {
2301                 m_genericImpl->SetFocus();
2302                 return;
2303         }
2304
2305         wxWindow::SetFocus();
2306 }
2307 #endif
2308
2309 // wxMac internal data structures
2310
2311 wxMacListCtrlItem::~wxMacListCtrlItem()
2312 {
2313 }
2314
2315 void wxMacListCtrlItem::Notification(wxMacDataItemBrowserControl *owner ,
2316     DataBrowserItemNotification message,
2317     DataBrowserItemDataRef itemData ) const
2318 {
2319
2320     wxMacDataBrowserListCtrlControl *lb = wxDynamicCast(owner, wxMacDataBrowserListCtrlControl);
2321
2322     // we want to depend on as little as possible to make sure tear-down of controls is safe
2323     if ( message == kDataBrowserItemRemoved)
2324     {
2325         if ( lb != NULL && lb->GetClientDataType() == wxClientData_Object )
2326         {
2327             delete (wxClientData*) (m_data);
2328         }
2329
2330         delete this;
2331         return;
2332     }
2333     else if ( message == kDataBrowserItemAdded )
2334     {
2335         // we don't issue events on adding, the item is not really stored in the list yet, so we
2336         // avoid asserts by gettting out now
2337         return  ;
2338     }
2339
2340     wxListCtrl *list = wxDynamicCast( owner->GetPeer() , wxListCtrl );
2341     if ( list && lb )
2342     {
2343         bool trigger = false;
2344
2345         wxListEvent event( wxEVT_COMMAND_LIST_ITEM_SELECTED, list->GetId() );
2346         bool isSingle = (list->GetWindowStyle() & wxLC_SINGLE_SEL) != 0;
2347
2348         event.SetEventObject( list );
2349         event.m_itemIndex = owner->GetLineFromItem( this ) ;
2350         event.m_item.m_itemId = event.m_itemIndex;
2351         list->GetItem(event.m_item);
2352
2353         switch (message)
2354         {
2355             case kDataBrowserItemDeselected:
2356                 event.SetEventType(wxEVT_COMMAND_LIST_ITEM_DESELECTED);
2357                 if ( !isSingle )
2358                     trigger = !lb->IsSelectionSuppressed();
2359                 break;
2360
2361             case kDataBrowserItemSelected:
2362                 trigger = !lb->IsSelectionSuppressed();
2363                 break;
2364
2365             case kDataBrowserItemDoubleClicked:
2366                 event.SetEventType( wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
2367                 trigger = true;
2368                 break;
2369
2370             case kDataBrowserEditStarted :
2371                 // TODO : how to veto ?
2372                 event.SetEventType( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT ) ;
2373                 trigger = true ;
2374                 break ;
2375
2376             case kDataBrowserEditStopped :
2377                 // TODO probably trigger only upon the value store callback, because
2378                 // here IIRC we cannot veto
2379                 event.SetEventType( wxEVT_COMMAND_LIST_END_LABEL_EDIT ) ;
2380                 trigger = true ;
2381                 break ;
2382
2383             default:
2384                 break;
2385         }
2386
2387         if ( trigger )
2388         {
2389             // direct notification is not always having the listbox GetSelection() having in synch with event
2390             wxPostEvent( list->GetEventHandler(), event );
2391         }
2392     }
2393
2394 }
2395
2396 IMPLEMENT_DYNAMIC_CLASS(wxMacDataBrowserListCtrlControl, wxMacDataItemBrowserControl )
2397
2398 wxMacDataBrowserListCtrlControl::wxMacDataBrowserListCtrlControl( wxWindow *peer, const wxPoint& pos, const wxSize& size, long style)
2399     : wxMacDataItemBrowserControl( peer, pos, size, style )
2400 {
2401     OSStatus err = noErr;
2402     m_clientDataItemsType = wxClientData_None;
2403     m_isVirtual = false;
2404     m_flags = 0;
2405
2406     if ( style & wxLC_VIRTUAL )
2407         m_isVirtual = true;
2408
2409     DataBrowserSelectionFlags  options = kDataBrowserDragSelect;
2410     if ( style & wxLC_SINGLE_SEL )
2411     {
2412         options |= kDataBrowserSelectOnlyOne;
2413     }
2414     else
2415     {
2416         options |= kDataBrowserCmdTogglesSelection;
2417     }
2418
2419     err = SetSelectionFlags( options );
2420     verify_noerr( err );
2421
2422     DataBrowserCustomCallbacks callbacks;
2423     InitializeDataBrowserCustomCallbacks( &callbacks, kDataBrowserLatestCustomCallbacks );
2424
2425     if ( gDataBrowserDrawItemUPP == NULL )
2426         gDataBrowserDrawItemUPP = NewDataBrowserDrawItemUPP(DataBrowserDrawItemProc);
2427
2428     if ( gDataBrowserHitTestUPP == NULL )
2429         gDataBrowserHitTestUPP = NewDataBrowserHitTestUPP(DataBrowserHitTestProc);
2430
2431     callbacks.u.v1.drawItemCallback = gDataBrowserDrawItemUPP;
2432     callbacks.u.v1.hitTestCallback = gDataBrowserHitTestUPP;
2433
2434     SetDataBrowserCustomCallbacks( GetControlRef(), &callbacks );
2435
2436     if ( style & wxLC_LIST )
2437     {
2438         InsertColumn(0, kDataBrowserIconAndTextType, wxEmptyString, -1, -1);
2439         verify_noerr( AutoSizeColumns() );
2440     }
2441
2442     if ( style & wxLC_LIST || style & wxLC_NO_HEADER )
2443         verify_noerr( SetHeaderButtonHeight( 0 ) );
2444
2445     if ( m_isVirtual )
2446         SetSortProperty( kMinColumnId - 1 );
2447     else
2448         SetSortProperty( kMinColumnId );
2449
2450     m_sortOrder = SortOrder_None;
2451
2452     if ( style & wxLC_SORT_DESCENDING )
2453     {
2454         SetSortOrder( kDataBrowserOrderDecreasing );
2455     }
2456     else if ( style & wxLC_SORT_ASCENDING )
2457     {
2458         SetSortOrder( kDataBrowserOrderIncreasing );
2459     }
2460
2461     if ( style & wxLC_VRULES )
2462     {
2463 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
2464         verify_noerr( DataBrowserChangeAttributes(m_controlRef, kDataBrowserAttributeListViewDrawColumnDividers, kDataBrowserAttributeNone) );
2465 #endif
2466     }
2467
2468     verify_noerr( SetHiliteStyle(kDataBrowserTableViewFillHilite ) );
2469     verify_noerr( SetHasScrollBars( (style & wxHSCROLL) != 0 , true ) );
2470 }
2471
2472 pascal Boolean wxMacDataBrowserListCtrlControl::DataBrowserEditTextProc(
2473         ControlRef browser,
2474         DataBrowserItemID itemID,
2475         DataBrowserPropertyID property,
2476         CFStringRef theString,
2477         Rect *maxEditTextRect,
2478         Boolean *shrinkToFit)
2479 {
2480     Boolean result = false;
2481     wxMacDataBrowserListCtrlControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserListCtrlControl);
2482     if ( ctl != 0 )
2483     {
2484         result = ctl->ConfirmEditText(itemID, property, theString, maxEditTextRect, shrinkToFit);
2485         theString = CFSTR("Hello!");
2486     }
2487     return result;
2488 }
2489
2490 bool wxMacDataBrowserListCtrlControl::ConfirmEditText(
2491         DataBrowserItemID itemID,
2492         DataBrowserPropertyID property,
2493         CFStringRef theString,
2494         Rect *maxEditTextRect,
2495         Boolean *shrinkToFit)
2496 {
2497     return false;
2498 }
2499
2500 pascal void wxMacDataBrowserListCtrlControl::DataBrowserDrawItemProc(
2501         ControlRef browser,
2502         DataBrowserItemID itemID,
2503         DataBrowserPropertyID property,
2504         DataBrowserItemState itemState,
2505         const Rect *itemRect,
2506         SInt16 gdDepth,
2507         Boolean colorDevice)
2508 {
2509     wxMacDataBrowserListCtrlControl* ctl = wxDynamicCast(wxMacControl::GetReferenceFromNativeControl( browser ), wxMacDataBrowserListCtrlControl);
2510     if ( ctl != 0 )
2511     {
2512         ctl->DrawItem(itemID, property, itemState, itemRect, gdDepth, colorDevice);
2513     }
2514 }
2515
2516 // routines needed for DrawItem
2517 enum
2518 {
2519   kIconWidth = 16,
2520   kIconHeight = 16,
2521   kTextBoxHeight = 14,
2522   kIconTextSpacingV = 2,
2523   kItemPadding = 4,
2524   kContentHeight = kIconHeight + kTextBoxHeight + kIconTextSpacingV
2525 };
2526
2527 static void calculateCGDrawingBounds(CGRect inItemRect, CGRect *outIconRect, CGRect *outTextRect, bool hasIcon = false)
2528 {
2529   float textBottom;
2530   float iconH, iconW = 0;
2531   float padding = kItemPadding;
2532   if (hasIcon)
2533   {
2534     iconH = kIconHeight;
2535     iconW = kIconWidth;
2536     padding = padding*2;
2537   }
2538
2539   textBottom = inItemRect.origin.y;
2540
2541   *outIconRect = CGRectMake(inItemRect.origin.x + kItemPadding,
2542                 textBottom + kIconTextSpacingV, kIconWidth,
2543                 kIconHeight);
2544
2545   *outTextRect = CGRectMake(inItemRect.origin.x + padding + iconW,
2546                 textBottom + kIconTextSpacingV, inItemRect.size.width - padding - iconW,
2547                 inItemRect.size.height - kIconTextSpacingV);
2548 }
2549
2550 void wxMacDataBrowserListCtrlControl::DrawItem(
2551         DataBrowserItemID itemID,
2552         DataBrowserPropertyID property,
2553         DataBrowserItemState itemState,
2554         const Rect *itemRect,
2555         SInt16 gdDepth,
2556         Boolean colorDevice)
2557 {
2558     wxString text;
2559     wxFont font = wxNullFont;
2560     int imgIndex = -1;
2561     short listColumn = property - kMinColumnId;
2562
2563     wxListCtrl* list = wxDynamicCast( GetPeer() , wxListCtrl );
2564     wxMacListCtrlItem* lcItem;
2565     wxColour color = *wxBLACK;
2566     wxColour bgColor = wxNullColour;
2567
2568     if (listColumn >= 0)
2569     {
2570         if (!m_isVirtual)
2571         {
2572             lcItem = (wxMacListCtrlItem*) itemID;
2573             if (lcItem->HasColumnInfo(listColumn)){
2574                 wxListItem* item = lcItem->GetColumnInfo(listColumn);
2575
2576                 // we always use the 0 column to get font and text/background colors.
2577                 if (lcItem->HasColumnInfo(0))
2578                 {
2579                     wxListItem* firstItem = lcItem->GetColumnInfo(0);
2580                     color = firstItem->GetTextColour();
2581                     bgColor = firstItem->GetBackgroundColour();
2582                     font = firstItem->GetFont();
2583                 }
2584
2585                 if (item->GetMask() & wxLIST_MASK_TEXT)
2586                     text = item->GetText();
2587                 if (item->GetMask() & wxLIST_MASK_IMAGE)
2588                     imgIndex = item->GetImage();
2589             }
2590
2591         }
2592         else
2593         {
2594             long itemNum = (long)itemID-1;
2595             if (itemNum >= 0 && itemNum < list->GetItemCount())
2596             {
2597                 text = list->OnGetItemText( itemNum, listColumn );
2598                 imgIndex = list->OnGetItemColumnImage( itemNum, listColumn );
2599                 wxListItemAttr* attrs = list->OnGetItemAttr( itemNum );
2600                 if (attrs)
2601                 {
2602                     if (attrs->HasBackgroundColour())
2603                         bgColor = attrs->GetBackgroundColour();
2604                     if (attrs->HasTextColour())
2605                         color = attrs->GetTextColour();
2606                     if (attrs->HasFont())
2607                         font = attrs->GetFont();
2608                 }
2609             }
2610         }
2611     }
2612
2613     wxColour listBgColor = list->GetBackgroundColour();
2614     if (bgColor == wxNullColour)
2615         bgColor = listBgColor;
2616
2617     wxFont listFont = list->GetFont();
2618     if (font == wxNullFont)
2619         font = listFont;
2620
2621     wxMacCFStringHolder cfString;
2622     cfString.Assign( text, wxLocale::GetSystemEncoding() );
2623
2624     Rect enclosingRect;
2625     CGRect enclosingCGRect, iconCGRect, textCGRect;
2626     Boolean active;
2627     ThemeDrawingState savedState = NULL;
2628     CGContextRef context = (CGContextRef)list->MacGetDrawingContext();
2629     RGBColor labelColor;
2630     labelColor.red = 0;
2631     labelColor.green = 0;
2632     labelColor.blue = 0;
2633
2634     RGBColor backgroundColor;
2635     backgroundColor.red = 255;
2636     backgroundColor.green = 255;
2637     backgroundColor.blue = 255;
2638
2639     GetDataBrowserItemPartBounds(GetControlRef(), itemID, property, kDataBrowserPropertyEnclosingPart,
2640               &enclosingRect);
2641
2642     enclosingCGRect = CGRectMake(enclosingRect.left,
2643                       enclosingRect.top,
2644                       enclosingRect.right - enclosingRect.left,
2645                       enclosingRect.bottom - enclosingRect.top);
2646
2647     bool hasFocus = (wxWindow::FindFocus() == list);
2648     active = IsControlActive(GetControlRef());
2649
2650     // don't paint the background over the vertical rule line
2651     if ( list->GetWindowStyleFlag() & wxLC_VRULES )
2652     {
2653         enclosingCGRect.origin.x += 1;
2654         enclosingCGRect.size.width -= 1;
2655     }
2656     if (itemState == kDataBrowserItemIsSelected)
2657     {
2658
2659         GetThemeDrawingState(&savedState);
2660
2661         if (active && hasFocus)
2662         {
2663             GetThemeBrushAsColor(kThemeBrushAlternatePrimaryHighlightColor, 32, true, &backgroundColor);
2664             GetThemeTextColor(kThemeTextColorWhite, gdDepth, colorDevice, &labelColor);
2665         }
2666         else
2667         {
2668             GetThemeBrushAsColor(kThemeBrushSecondaryHighlightColor, 32, true, &backgroundColor);
2669             GetThemeTextColor(kThemeTextColorBlack, gdDepth, colorDevice, &labelColor);
2670         }
2671         CGContextSaveGState(context);
2672
2673         CGContextSetRGBFillColor(context, (float)backgroundColor.red / (float)USHRT_MAX,
2674                       (float)backgroundColor.green / (float)USHRT_MAX,
2675                       (float)backgroundColor.blue / (float)USHRT_MAX, 1.0);
2676         CGContextFillRect(context, enclosingCGRect);
2677
2678         CGContextRestoreGState(context);
2679     }
2680     else
2681     {
2682
2683         if (color.Ok())
2684             labelColor = MAC_WXCOLORREF( color.GetPixel() );
2685         else if (list->GetTextColour().Ok())
2686             labelColor = MAC_WXCOLORREF( list->GetTextColour().GetPixel() );
2687
2688         if (bgColor.Ok())
2689         {
2690             backgroundColor = MAC_WXCOLORREF( bgColor.GetPixel() );
2691             CGContextSaveGState(context);
2692
2693             CGContextSetRGBFillColor(context, (float)backgroundColor.red / (float)USHRT_MAX,
2694                           (float)backgroundColor.green / (float)USHRT_MAX,
2695                           (float)backgroundColor.blue / (float)USHRT_MAX, 1.0);
2696             CGContextFillRect(context, enclosingCGRect);
2697
2698             CGContextRestoreGState(context);
2699         }
2700     }
2701
2702     calculateCGDrawingBounds(enclosingCGRect, &iconCGRect, &textCGRect, (imgIndex != -1) );
2703
2704     if (imgIndex != -1)
2705     {
2706         wxImageList* imageList = list->GetImageList(wxIMAGE_LIST_SMALL);
2707         if (imageList && imageList->GetImageCount() > 0){
2708             wxBitmap bmp = imageList->GetBitmap(imgIndex);
2709             IconRef icon = bmp.GetBitmapData()->GetIconRef();
2710
2711             CGContextSaveGState(context);
2712             CGContextTranslateCTM(context, 0,iconCGRect.origin.y + CGRectGetMaxY(iconCGRect));
2713             CGContextScaleCTM(context,1.0f,-1.0f);
2714             PlotIconRefInContext(context, &iconCGRect, kAlignNone,
2715               active ? kTransformNone : kTransformDisabled, NULL,
2716               kPlotIconRefNormalFlags, icon);
2717
2718             CGContextRestoreGState(context);
2719         }
2720     }
2721
2722     HIThemeTextHorizontalFlush hFlush = kHIThemeTextHorizontalFlushLeft;
2723     UInt16 fontID = kThemeViewsFont;
2724
2725     if (font.Ok())
2726     {
2727         if (font.GetFamily() != wxFONTFAMILY_DEFAULT)
2728             fontID = font.MacGetThemeFontID();
2729
2730 // FIXME: replace these with CG or ATSUI calls so we can remove this #ifndef.
2731 #ifndef __LP64__
2732         ::TextSize( (short)(font.MacGetFontSize()) ) ;
2733         ::TextFace( font.MacGetFontStyle() ) ;
2734 #endif
2735     }
2736
2737     wxListItem item;
2738     list->GetColumn(listColumn, item);
2739     if (item.GetMask() & wxLIST_MASK_FORMAT)
2740     {
2741         if (item.GetAlign() == wxLIST_FORMAT_LEFT)
2742             hFlush = kHIThemeTextHorizontalFlushLeft;
2743         else if (item.GetAlign() == wxLIST_FORMAT_CENTER)
2744             hFlush = kHIThemeTextHorizontalFlushCenter;
2745         else if (item.GetAlign() == wxLIST_FORMAT_RIGHT)
2746         {
2747             hFlush = kHIThemeTextHorizontalFlushRight;
2748             textCGRect.origin.x -= kItemPadding; // give a little extra paddding
2749         }
2750     }
2751
2752     HIThemeTextInfo info;
2753     info.version = kHIThemeTextInfoVersionZero;
2754     info.state = active ? kThemeStateActive : kThemeStateInactive;
2755     info.fontID = fontID;
2756     info.horizontalFlushness = hFlush;
2757     info.verticalFlushness = kHIThemeTextVerticalFlushCenter;
2758     info.options = kHIThemeTextBoxOptionNone;
2759     info.truncationPosition = kHIThemeTextTruncationEnd;
2760     info.truncationMaxLines = 1;
2761
2762     CGContextSaveGState(context);
2763     CGContextSetRGBFillColor (context, (float)labelColor.red / (float)USHRT_MAX,
2764                       (float)labelColor.green / (float)USHRT_MAX,
2765                       (float)labelColor.blue / (float)USHRT_MAX, 1.0);
2766
2767     HIThemeDrawTextBox(cfString, &textCGRect, &info, context, kHIThemeOrientationNormal);
2768
2769     CGContextRestoreGState(context);
2770
2771     if (savedState != NULL)
2772         SetThemeDrawingState(savedState, true);
2773 }
2774
2775 OSStatus wxMacDataBrowserListCtrlControl::GetSetItemData(DataBrowserItemID itemID,
2776                         DataBrowserPropertyID property,
2777                         DataBrowserItemDataRef itemData,
2778                         Boolean changeValue )
2779 {
2780     wxString text;
2781     int imgIndex = -1;
2782     short listColumn = property - kMinColumnId;
2783
2784     OSStatus err = errDataBrowserPropertyNotSupported;
2785     wxListCtrl* list = wxDynamicCast( GetPeer() , wxListCtrl );
2786     wxMacListCtrlItem* lcItem;
2787
2788     if (listColumn >= 0)
2789     {
2790         if (!m_isVirtual)
2791         {
2792             lcItem = (wxMacListCtrlItem*) itemID;
2793             if (lcItem && lcItem->HasColumnInfo(listColumn)){
2794                 wxListItem* item = lcItem->GetColumnInfo(listColumn);
2795                 if (item->GetMask() & wxLIST_MASK_TEXT)
2796                     text = item->GetText();
2797                 if (item->GetMask() & wxLIST_MASK_IMAGE)
2798                     imgIndex = item->GetImage();
2799             }
2800         }
2801         else
2802         {
2803             long itemNum = (long)itemID-1;
2804             if (itemNum >= 0 && itemNum < list->GetItemCount())
2805             {
2806                 text = list->OnGetItemText( itemNum, listColumn );
2807                 imgIndex = list->OnGetItemColumnImage( itemNum, listColumn );
2808             }
2809         }
2810     }
2811
2812     if ( !changeValue )
2813     {
2814         switch (property)
2815         {
2816             case kDataBrowserItemIsEditableProperty :
2817                 if ( list && list->HasFlag( wxLC_EDIT_LABELS ) )
2818                 {
2819                     verify_noerr(SetDataBrowserItemDataBooleanValue( itemData, true ));
2820                 }
2821                 break ;
2822             default :
2823                 if ( property >= kMinColumnId )
2824                 {
2825                     wxMacCFStringHolder cfStr(text);
2826                     verify_noerr( ::SetDataBrowserItemDataText( itemData, cfStr) );
2827
2828
2829
2830                     if ( imgIndex != -1 )
2831                     {
2832                         wxImageList* imageList = list->GetImageList(wxIMAGE_LIST_SMALL);
2833                         if (imageList && imageList->GetImageCount() > 0){
2834                             wxBitmap bmp = imageList->GetBitmap(imgIndex);
2835                             IconRef icon = bmp.GetBitmapData()->GetIconRef();
2836                             ::SetDataBrowserItemDataIcon(itemData, icon);
2837                         }
2838                     }
2839
2840                 }
2841                 break ;
2842         }
2843
2844     }
2845     else
2846     {
2847         switch (property)
2848         {
2849              default:
2850                 if ( property >= kMinColumnId )
2851                 {
2852                     short listColumn = property - kMinColumnId;
2853
2854                     // TODO probably send the 'end edit' from here, as we
2855                     // can then deal with the veto
2856                     CFStringRef sr ;
2857                     verify_noerr( GetDataBrowserItemDataText( itemData , &sr ) ) ;
2858                     wxMacCFStringHolder cfStr(sr) ;;
2859                     if (m_isVirtual)
2860                         list->SetItem( (long)itemData-1 , listColumn, cfStr.AsString() ) ;
2861                     else
2862                     {
2863                         if (lcItem)
2864                             lcItem->SetColumnTextValue( listColumn, cfStr.AsString() );
2865                     }
2866                     err = noErr ;
2867                 }
2868                 break;
2869         }
2870     }
2871     return err;
2872 }
2873
2874 void wxMacDataBrowserListCtrlControl::ItemNotification(DataBrowserItemID itemID,
2875     DataBrowserItemNotification message,
2876     DataBrowserItemDataRef itemData )
2877 {
2878     // we want to depend on as little as possible to make sure tear-down of controls is safe
2879     if ( message == kDataBrowserItemRemoved)
2880     {
2881         // make sure MacDelete does the proper teardown.
2882         return;
2883     }
2884     else if ( message == kDataBrowserItemAdded )
2885     {
2886         // we don't issue events on adding, the item is not really stored in the list yet, so we
2887         // avoid asserts by getting out now
2888         return  ;
2889     }
2890
2891     wxListCtrl *list = wxDynamicCast( GetPeer() , wxListCtrl );
2892     if ( list )
2893     {
2894         bool trigger = false;
2895
2896         wxListEvent event( wxEVT_COMMAND_LIST_ITEM_SELECTED, list->GetId() );
2897         bool isSingle = (list->GetWindowStyle() & wxLC_SINGLE_SEL) != 0;
2898
2899         event.SetEventObject( list );
2900         if ( !list->IsVirtual() )
2901         {
2902             DataBrowserTableViewRowIndex result = 0;
2903             verify_noerr( GetItemRow( itemID, &result ) ) ;
2904             event.m_itemIndex = result;
2905         }
2906         else
2907         {
2908             event.m_itemIndex = (long)itemID-1;
2909         }
2910         event.m_item.m_itemId = event.m_itemIndex;
2911         list->GetItem(event.m_item);
2912
2913         switch (message)
2914         {
2915             case kDataBrowserItemDeselected:
2916                 event.SetEventType(wxEVT_COMMAND_LIST_ITEM_DESELECTED);
2917                 if ( !isSingle )
2918                     trigger = !IsSelectionSuppressed();
2919                 break;
2920
2921             case kDataBrowserItemSelected:
2922                 trigger = !IsSelectionSuppressed();
2923
2924                 break;
2925
2926             case kDataBrowserItemDoubleClicked:
2927                 event.SetEventType( wxEVT_COMMAND_LIST_ITEM_ACTIVATED );
2928                 trigger = true;
2929                 break;
2930
2931             case kDataBrowserEditStarted :
2932                 // TODO : how to veto ?
2933                 event.SetEventType( wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT ) ;
2934                 trigger = true ;
2935                 break ;
2936
2937             case kDataBrowserEditStopped :
2938                 // TODO probably trigger only upon the value store callback, because
2939                 // here IIRC we cannot veto
2940                 event.SetEventType( wxEVT_COMMAND_LIST_END_LABEL_EDIT ) ;
2941                 trigger = true ;
2942                 break ;
2943
2944             default:
2945                 break;
2946         }
2947
2948         if ( trigger )
2949         {
2950             // direct notification is not always having the listbox GetSelection() having in synch with event
2951             wxPostEvent( list->GetEventHandler(), event );
2952         }
2953     }
2954 }
2955
2956 Boolean wxMacDataBrowserListCtrlControl::CompareItems(DataBrowserItemID itemOneID,
2957                         DataBrowserItemID itemTwoID,
2958                         DataBrowserPropertyID sortProperty)
2959 {
2960
2961     bool retval = false;
2962     wxString itemText;
2963     wxString otherItemText;
2964     long itemOrder;
2965     long otherItemOrder;
2966
2967     int colId = sortProperty - kMinColumnId;
2968
2969     wxListCtrl* list = wxDynamicCast( GetPeer() , wxListCtrl );
2970
2971     DataBrowserSortOrder sort;
2972     verify_noerr(GetSortOrder(&sort));
2973
2974     if (colId >= 0)
2975     {
2976         if (!m_isVirtual)
2977         {
2978             wxMacListCtrlItem* item = (wxMacListCtrlItem*)itemOneID;
2979             wxMacListCtrlItem* otherItem = (wxMacListCtrlItem*)itemTwoID;
2980
2981             itemOrder = item->GetOrder();
2982             otherItemOrder = item->GetOrder();
2983
2984             wxListCtrlCompare func = list->GetCompareFunc();
2985             if (func != NULL)
2986             {
2987                 long item1 = -1;
2988                 long item2 = -1;
2989                 if (item && item->HasColumnInfo(0))
2990                     item1 = item->GetColumnInfo(0)->GetData();
2991                 if (otherItem && otherItem->HasColumnInfo(0))
2992                     item2 = otherItem->GetColumnInfo(0)->GetData();
2993
2994                 if (item1 > -1 && item2 > -1)
2995                 {
2996                     int result = func(item1, item2, list->GetCompareFuncData());
2997                     if (sort == kDataBrowserOrderIncreasing)
2998                         return result >= 0;
2999                     else
3000                         return result < 0;
3001                 }
3002             }
3003
3004             // we can't use the native control's sorting abilities, so just
3005             // sort by item id.
3006             return itemOrder < otherItemOrder;
3007         }
3008         else
3009         {
3010
3011             long itemNum = (long)itemOneID;
3012             long otherItemNum = (long)itemTwoID;
3013
3014             // virtual listctrls don't support sorting
3015             return itemNum < otherItemNum;
3016         }
3017     }
3018     else{
3019         // fallback for undefined cases
3020         retval = itemOneID < itemTwoID;
3021     }
3022
3023     return retval;
3024 }
3025
3026 wxMacDataBrowserListCtrlControl::~wxMacDataBrowserListCtrlControl()
3027 {
3028 }
3029
3030 void wxMacDataBrowserListCtrlControl::MacSetColumnInfo( unsigned int row, unsigned int column, wxListItem* item )
3031 {
3032     wxMacDataItem* dataItem = GetItemFromLine(row);
3033     wxASSERT_MSG( dataItem, _T("could not obtain wxMacDataItem for row in MacSetColumnInfo. Is row a valid wxListCtrl row?") );
3034     if (item)
3035     {
3036         wxMacListCtrlItem* listItem = wx_static_cast(wxMacListCtrlItem*,dataItem);
3037         bool hasInfo = listItem->HasColumnInfo( column );
3038         listItem->SetColumnInfo( column, item );
3039         listItem->SetOrder(row);
3040         UpdateState(dataItem, item);
3041
3042         wxListCtrl* list = wxDynamicCast( GetPeer() , wxListCtrl );
3043
3044         // NB: When this call was made before a control was completely shown, it would
3045         // update the item prematurely (i.e. no text would be listed) and, on show,
3046         // only the sorted column would be refreshed, meaning only first column text labels
3047         // would be shown. Making sure not to update items until the control is visible
3048         // seems to fix this issue.
3049         if (hasInfo && list->IsShown())
3050             UpdateItem( wxMacDataBrowserRootContainer, listItem , kMinColumnId + column );
3051     }
3052 }
3053
3054 // apply changes that need to happen immediately, rather than when the
3055 // databrowser control fires a callback.
3056 void wxMacDataBrowserListCtrlControl::UpdateState(wxMacDataItem* dataItem, wxListItem* listItem)
3057 {
3058     bool isSelected = IsItemSelected( dataItem );
3059     bool isSelectedState = (listItem->GetState() == wxLIST_STATE_SELECTED);
3060
3061     // toggle the selection state if wxListInfo state and actual state don't match.
3062     if ( isSelected != isSelectedState )
3063     {
3064         DataBrowserSetOption options = kDataBrowserItemsAdd;
3065         if (!isSelectedState)
3066             options = kDataBrowserItemsRemove;
3067         SetSelectedItem(dataItem, options);
3068     }
3069     // TODO: Set column width if item width > than current column width
3070 }
3071
3072 void wxMacDataBrowserListCtrlControl::MacGetColumnInfo( unsigned int row, unsigned int column, wxListItem& item )
3073 {
3074     wxMacDataItem* dataItem = GetItemFromLine(row);
3075     wxASSERT_MSG( dataItem, _T("could not obtain wxMacDataItem in MacGetColumnInfo. Is row a valid wxListCtrl row?") );
3076     // CS should this guard against dataItem = 0 ? , as item is not a pointer if (item) is not appropriate
3077     //if (item)
3078     {
3079         wxMacListCtrlItem* listItem =wx_static_cast(wxMacListCtrlItem*,dataItem);
3080
3081         if (!listItem->HasColumnInfo( column ))
3082             return;
3083
3084         wxListItem* oldItem = listItem->GetColumnInfo( column );
3085
3086         if (oldItem)
3087         {
3088             long mask = item.GetMask();
3089             if ( !mask )
3090                 // by default, get everything for backwards compatibility
3091                 mask = -1;
3092
3093             if ( mask & wxLIST_MASK_TEXT )
3094                 item.SetText(oldItem->GetText());
3095             if ( mask & wxLIST_MASK_IMAGE )
3096                 item.SetImage(oldItem->GetImage());
3097             if ( mask & wxLIST_MASK_DATA )
3098                 item.SetData(oldItem->GetData());
3099             if ( mask & wxLIST_MASK_STATE )
3100                 item.SetState(oldItem->GetState());
3101             if ( mask & wxLIST_MASK_WIDTH )
3102                 item.SetWidth(oldItem->GetWidth());
3103             if ( mask & wxLIST_MASK_FORMAT )
3104                 item.SetAlign(oldItem->GetAlign());
3105
3106             item.SetTextColour(oldItem->GetTextColour());
3107             item.SetBackgroundColour(oldItem->GetBackgroundColour());
3108             item.SetFont(oldItem->GetFont());
3109         }
3110     }
3111 }
3112
3113 void wxMacDataBrowserListCtrlControl::MacInsertItem( unsigned int n, wxListItem* item )
3114 {
3115     wxMacDataItemBrowserControl::MacInsert(n, item->GetText());
3116     MacSetColumnInfo(n, 0, item);
3117 }
3118
3119 wxMacDataItem* wxMacDataBrowserListCtrlControl::CreateItem()
3120 {
3121     return new wxMacListCtrlItem();
3122 }
3123
3124 wxMacListCtrlItem::wxMacListCtrlItem()
3125 {
3126     m_rowItems = wxListItemList();
3127 }
3128
3129 int wxMacListCtrlItem::GetColumnImageValue( unsigned int column )
3130 {
3131     if ( HasColumnInfo(column) )
3132         return GetColumnInfo(column)->GetImage();
3133
3134     return -1;
3135 }
3136
3137 void wxMacListCtrlItem::SetColumnImageValue( unsigned int column, int imageIndex )
3138 {
3139     if ( HasColumnInfo(column) )
3140         GetColumnInfo(column)->SetImage(imageIndex);
3141 }
3142
3143 wxString wxMacListCtrlItem::GetColumnTextValue( unsigned int column )
3144 {
3145     if ( column == 0 )
3146         return GetLabel();
3147
3148     if ( HasColumnInfo(column) )
3149         return GetColumnInfo(column)->GetText();
3150
3151     return wxEmptyString;
3152 }
3153
3154 void wxMacListCtrlItem::SetColumnTextValue( unsigned int column, const wxString& text )
3155 {
3156     if ( HasColumnInfo(column) )
3157         GetColumnInfo(column)->SetText(text);
3158
3159     // for compatibility with superclass APIs
3160     if ( column == 0 )
3161         SetLabel(text);
3162 }
3163
3164 wxListItem* wxMacListCtrlItem::GetColumnInfo( unsigned int column )
3165 {
3166     wxASSERT_MSG( HasColumnInfo(column), _T("invalid column index in wxMacListCtrlItem") );
3167     return m_rowItems[column];
3168 }
3169
3170 bool wxMacListCtrlItem::HasColumnInfo( unsigned int column )
3171 {
3172     return !(m_rowItems.find( column ) == m_rowItems.end());
3173 }
3174
3175 void wxMacListCtrlItem::SetColumnInfo( unsigned int column, wxListItem* item )
3176 {
3177
3178     if ( !HasColumnInfo(column) )
3179     {
3180         wxListItem* listItem = new wxListItem(*item);
3181         m_rowItems[column] = listItem;
3182     }
3183     else
3184     {
3185         wxListItem* listItem = GetColumnInfo( column );
3186         long mask = item->GetMask();
3187         if (mask & wxLIST_MASK_TEXT)
3188             listItem->SetText(item->GetText());
3189         if (mask & wxLIST_MASK_DATA)
3190             listItem->SetData(item->GetData());
3191         if (mask & wxLIST_MASK_IMAGE)
3192             listItem->SetImage(item->GetImage());
3193         if (mask & wxLIST_MASK_STATE)
3194             listItem->SetState(item->GetState());
3195         if (mask & wxLIST_MASK_FORMAT)
3196             listItem->SetAlign(item->GetAlign());
3197         if (mask & wxLIST_MASK_WIDTH)
3198             listItem->SetWidth(item->GetWidth());
3199
3200         if ( item->HasAttributes() )
3201         {
3202             if ( listItem->HasAttributes() )
3203                 listItem->GetAttributes()->AssignFrom(*item->GetAttributes());
3204             else
3205             {
3206                 listItem->SetTextColour(item->GetTextColour());
3207                 listItem->SetBackgroundColour(item->GetBackgroundColour());
3208                 listItem->SetFont(item->GetFont());
3209             }
3210         }
3211     }
3212 }
3213
3214 #endif // wxUSE_LISTCTRL
3215