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