src/osx/carbon/dataview.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/osx/carbon/datavgen.cpp
   3 // Purpose:     wxDataViewCtrl native mac implementation
   4 // Author:
   5 // Id:          $Id$
   6 // Copyright:   (c) 2007
   7 // Licence:     wxWindows licence
   8 /////////////////////////////////////////////////////////////////////////////
   9
  10 // For compilers that support precompilation, includes "wx.h".
  11 #include "wx/wxprec.h"
  12
  13 #if wxUSE_DATAVIEWCTRL
  14
  15 #include "wx/dataview.h"
  16
  17 #if !defined(wxUSE_GENERICDATAVIEWCTRL) || (wxUSE_GENERICDATAVIEWCTRL == 0)
  18
  19 #include <limits>
  20
  21 #include "wx/osx/carbon/databrow.h"
  22
  23 #ifndef WX_PRECOMP
  24     #include "wx/timer.h"
  25     #include "wx/settings.h"
  26     #include "wx/dcclient.h"
  27     #include "wx/icon.h"
  28 #endif
  29
  30 #include "wx/renderer.h"
  31
  32 //-----------------------------------------------------------------------------
  33 // local constants
  34 //-----------------------------------------------------------------------------
  35
  36 // a list of all catchable events:
  37 static EventTypeSpec const eventList[] =
  38 {
  39   {kEventClassControl, kEventControlDraw},
  40   {kEventClassControl, kEventControlHit}
  41 };
  42
  43 //-----------------------------------------------------------------------------
  44 // local functions
  45 //-----------------------------------------------------------------------------
  46
  47 static pascal OSStatus wxMacDataViewCtrlEventHandler(EventHandlerCallRef handler, EventRef EventReference, void* Data)
  48 {
  49   wxDataViewCtrl* DataViewCtrlPtr((wxDataViewCtrl*) Data); // the 'Data' variable always contains a pointer to the data view control that installed the handler
  50
  51   wxMacCarbonEvent CarbonEvent(EventReference) ;
  52
  53
  54   switch (GetEventKind(EventReference))
  55   {
  56     case kEventControlDraw:
  57       {
  58         OSStatus status;
  59
  60         DataViewCtrlPtr->MacSetDrawingContext(CarbonEvent.GetParameter<CGContextRef>(kEventParamCGContextRef,typeCGContextRef));
  61         status = ::CallNextEventHandler(handler,EventReference);
  62         DataViewCtrlPtr->MacSetDrawingContext(NULL);
  63         return status;
  64       }
  65     case kEventControlHit :
  66       if (CarbonEvent.GetParameter<ControlPartCode>(kEventParamControlPart,typeControlPartCode) == kControlButtonPart) // we only care about the header
  67       {
  68         ControlRef            controlReference;
  69         DataBrowserPropertyID columnPropertyID;
  70         unsigned long         columnIndex;
  71         OSStatus              status;
  72         wxDataViewEvent       DataViewEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK,DataViewCtrlPtr->GetId());
  73
  74         CarbonEvent.GetParameter(kEventParamDirectObject,&controlReference);
  75        // determine the column that triggered the event (this is the column that is responsible for sorting the data view):
  76         status = ::GetDataBrowserSortProperty(controlReference,&columnPropertyID);
  77         wxCHECK(status == noErr,status);
  78         status = ::GetDataBrowserTableViewColumnPosition(controlReference,columnPropertyID,&columnIndex);
  79         if (status == errDataBrowserPropertyNotFound) // user clicked into part of the header that does not have a property
  80           return ::CallNextEventHandler(handler,EventReference);
  81         wxCHECK(status == noErr,status);
  82        // initialize wxWidget event handler:
  83         DataViewEvent.SetEventObject(DataViewCtrlPtr);
  84         DataViewEvent.SetColumn(columnIndex);
  85         DataViewEvent.SetDataViewColumn(DataViewCtrlPtr->GetColumn(columnIndex));
  86        // finally sent the equivalent wxWidget event:
  87         DataViewCtrlPtr->HandleWindowEvent(DataViewEvent);
  88         return ::CallNextEventHandler(handler,EventReference);
  89       }
  90       else
  91         return eventNotHandledErr;
  92   }
  93
  94   return eventNotHandledErr;
  95 }
  96
  97 static DataBrowserItemID* CreateDataBrowserItemIDArray(size_t& noOfEntries, wxDataViewItemArray const& items) // returns a newly allocated pointer to valid data browser item IDs
  98 {
  99   size_t const noOfItems = items.GetCount();
 100
 101   DataBrowserItemID* itemIDs(new DataBrowserItemID[noOfItems]);
 102
 103
 104  // convert all valid data view items to data browser items
 105   noOfEntries = 0;
 106   for (size_t i=0; i<noOfItems; ++i)
 107     if (items[i].IsOk())
 108     {
 109       itemIDs[noOfEntries] = reinterpret_cast<DataBrowserItemID>(items[i].GetID());
 110       ++noOfEntries;
 111     }
 112  // done:
 113   return itemIDs;
 114 }
 115
 116 static bool InitializeColumnDescription(DataBrowserListViewColumnDesc& columnDescription, wxDataViewColumn const* columnPtr, DataBrowserPropertyID columnPropertyID, wxCFStringRef const& title)
 117 {
 118  // set properties for the column:
 119   columnDescription.propertyDesc.propertyID    = columnPropertyID;
 120   columnDescription.propertyDesc.propertyType  = columnPtr->GetRenderer()->GetPropertyType();
 121   columnDescription.propertyDesc.propertyFlags = kDataBrowserListViewSelectionColumn; // make the column selectable
 122   if (columnPtr->IsReorderable())
 123     columnDescription.propertyDesc.propertyFlags |= kDataBrowserListViewMovableColumn;
 124   if (columnPtr->IsResizeable())
 125   {
 126     columnDescription.headerBtnDesc.minimumWidth = 0;
 127     columnDescription.headerBtnDesc.maximumWidth = 30000; // 32767 is the theoretical maximum though but 30000 looks nicer
 128   }
 129   else
 130   {
 131     columnDescription.headerBtnDesc.minimumWidth = columnPtr->GetWidth();
 132     columnDescription.headerBtnDesc.maximumWidth = columnPtr->GetWidth();
 133   }
 134   if (columnPtr->IsSortable())
 135     columnDescription.propertyDesc.propertyFlags |= kDataBrowserListViewSortableColumn;
 136   if (columnPtr->GetRenderer()->GetMode() == wxDATAVIEW_CELL_EDITABLE)
 137     columnDescription.propertyDesc.propertyFlags |= kDataBrowserPropertyIsEditable;
 138   if ((columnDescription.propertyDesc.propertyType == kDataBrowserCustomType) ||
 139       (columnDescription.propertyDesc.propertyType == kDataBrowserDateTimeType) ||
 140       (columnDescription.propertyDesc.propertyType == kDataBrowserIconAndTextType) ||
 141       (columnDescription.propertyDesc.propertyType == kDataBrowserTextType))
 142     columnDescription.propertyDesc.propertyFlags |= kDataBrowserListViewTypeSelectColumn; // enables generally the possibility to have user input for the mentioned types
 143 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
 144   columnDescription.propertyDesc.propertyFlags |= kDataBrowserListViewNoGapForIconInHeaderButton;
 145 #endif
 146  // set header's properties:
 147   columnDescription.headerBtnDesc.version = kDataBrowserListViewLatestHeaderDesc;
 148   columnDescription.headerBtnDesc.titleOffset = 0;
 149   columnDescription.headerBtnDesc.titleString = ::CFStringCreateCopy(kCFAllocatorDefault,title);
 150   columnDescription.headerBtnDesc.initialOrder       = kDataBrowserOrderIncreasing; // choose one of the orders as "undefined" is not supported anyway (s. ControlDefs.h in the HIToolbox framework)
 151   columnDescription.headerBtnDesc.btnFontStyle.flags = kControlUseFontMask | kControlUseJustMask;
 152   switch (columnPtr->GetAlignment())
 153   {
 154     case wxALIGN_CENTER:
 155     case wxALIGN_CENTER_HORIZONTAL:
 156       columnDescription.headerBtnDesc.btnFontStyle.just = teCenter;
 157       break;
 158     case wxALIGN_LEFT:
 159       columnDescription.headerBtnDesc.btnFontStyle.just = teFlushLeft;
 160       break;
 161     case wxALIGN_RIGHT:
 162       columnDescription.headerBtnDesc.btnFontStyle.just = teFlushRight;
 163       break;
 164     default:
 165       columnDescription.headerBtnDesc.btnFontStyle.just = teFlushDefault;
 166   }
 167   columnDescription.headerBtnDesc.btnFontStyle.font  = kControlFontViewSystemFont;
 168   columnDescription.headerBtnDesc.btnFontStyle.style = normal;
 169   if (columnPtr->GetBitmap().IsOk())
 170   {
 171     columnDescription.headerBtnDesc.btnContentInfo.contentType = kControlContentIconRef;
 172     columnDescription.headerBtnDesc.btnContentInfo.u.iconRef = columnPtr->GetBitmap().GetIconRef();
 173   }
 174   else
 175   {
 176     // not text only as we otherwise could not add a bitmap later
 177     // columnDescription.headerBtnDesc.btnContentInfo.contentType = kControlContentTextOnly;
 178     columnDescription.headerBtnDesc.btnContentInfo.contentType = kControlContentIconRef;
 179     columnDescription.headerBtnDesc.btnContentInfo.u.iconRef = NULL;
 180   }
 181
 182  // done:
 183   return true;
 184 }
 185
 186 //-----------------------------------------------------------------------------
 187 // local function pointers
 188 //-----------------------------------------------------------------------------
 189
 190 DEFINE_ONE_SHOT_HANDLER_GETTER(wxMacDataViewCtrlEventHandler)
 191
 192 // ---------------------------------------------------------
 193 // wxMacDataViewModelNotifier
 194 // ---------------------------------------------------------
 195 class wxMacDataViewModelNotifier : public wxDataViewModelNotifier
 196 {
 197 public:
 198   wxMacDataViewModelNotifier(wxMacDataViewDataBrowserListViewControl* initDataViewControlPtr) : m_dataViewControlPtr(initDataViewControlPtr)
 199   {
 200   }
 201
 202   virtual bool ItemAdded(const wxDataViewItem &parent, const wxDataViewItem &item)
 203   {
 204     DataBrowserItemID itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
 205
 206     wxCHECK_MSG(item.IsOk(),false,_("Added item is invalid."));
 207     bool noFailureFlag = (!(parent.IsOk()) && (m_dataViewControlPtr->AddItem(kDataBrowserNoItem,&itemID) == noErr) ||
 208                   parent.IsOk()  && (m_dataViewControlPtr->AddItem(reinterpret_cast<DataBrowserItemID>(parent.GetID()),&itemID) == noErr));
 209
 210     wxDataViewCtrl *dvc = (wxDataViewCtrl*) m_dataViewControlPtr->GetWXPeer();
 211     if (dvc->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT)
 212     {
 213         wxDataViewModel *model = GetOwner();
 214
 215         int height = 20; // TODO find out standard height
 216         unsigned int num = dvc->GetColumnCount();
 217         unsigned int col;
 218         for (col = 0; col < num; col++)
 219         {
 220             wxDataViewColumn *column = dvc->GetColumn( col );
 221             if (column->IsHidden())
 222                 continue;
 223
 224             wxDataViewCustomRenderer *renderer = wxDynamicCast( column->GetRenderer(), wxDataViewCustomRenderer );
 225             if (renderer)
 226             {
 227                 wxVariant value;
 228                 model->GetValue( value, item, column->GetModelColumn() );
 229                 renderer->SetValue( value );
 230                 height = wxMax( height, renderer->GetSize().y );
 231             }
 232
 233         }
 234
 235         if (height > 20)
 236             m_dataViewControlPtr->SetRowHeight( itemID, height );
 237     }
 238
 239     return noFailureFlag;
 240   }
 241
 242   virtual bool ItemsAdded(wxDataViewItem const& parent, wxDataViewItemArray const& items)
 243   {
 244     bool noFailureFlag;
 245
 246     DataBrowserItemID* itemIDs;
 247
 248     size_t noOfEntries;
 249
 250
 251    // convert all valid data view items to data browser items:
 252     itemIDs = ::CreateDataBrowserItemIDArray(noOfEntries,items);
 253    // insert all valid items into control:
 254     noFailureFlag = ((noOfEntries == 0) ||
 255                      !(parent.IsOk()) && (m_dataViewControlPtr->AddItems(kDataBrowserNoItem,noOfEntries,itemIDs,kDataBrowserItemNoProperty) == noErr) ||
 256                      parent.IsOk() && (m_dataViewControlPtr->AddItems(reinterpret_cast<DataBrowserItemID>(parent.GetID()),noOfEntries,itemIDs,kDataBrowserItemNoProperty) == noErr));
 257    // give allocated array space free again:
 258     delete[] itemIDs;
 259
 260     wxDataViewCtrl *dvc = (wxDataViewCtrl*) m_dataViewControlPtr->GetWXPeer();
 261     if (dvc->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT)
 262     {
 263         wxDataViewModel *model = GetOwner();
 264         unsigned int colnum = dvc->GetColumnCount();
 265
 266         size_t i;
 267         size_t count = items.GetCount();
 268         for (i = 0; i < count; i++)
 269         {
 270             wxDataViewItem item = items[i];
 271             DataBrowserItemID itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
 272
 273             int height = 20; // TODO find out standard height
 274             unsigned int col;
 275             for (col = 0; col < colnum; col++)
 276             {
 277                 wxDataViewColumn *column = dvc->GetColumn( col );
 278                 if (column->IsHidden())
 279                     continue;      // skip it!
 280
 281                 if ((col != 0) && model->IsContainer(item) && !model->HasContainerColumns(item))
 282                     continue;      // skip it!
 283
 284                 wxDataViewCustomRenderer *renderer = wxDynamicCast( column->GetRenderer(), wxDataViewCustomRenderer );
 285                 if (renderer)
 286                 {
 287                     wxVariant value;
 288                     model->GetValue( value, item, column->GetModelColumn() );
 289                     renderer->SetValue( value );
 290                     height = wxMax( height, renderer->GetSize().y );
 291                 }
 292             }
 293
 294             if (height > 20)
 295                 m_dataViewControlPtr->SetRowHeight( itemID, height );
 296         }
 297    }
 298
 299    // done:
 300     return noFailureFlag;
 301   }
 302
 303   virtual bool ItemChanged(wxDataViewItem const& item)
 304   {
 305     DataBrowserItemID itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
 306
 307
 308     wxCHECK_MSG(item.IsOk(),false,_("Changed item is invalid."));
 309     if (m_dataViewControlPtr->UpdateItems(&itemID) == noErr)
 310     {
 311       wxDataViewCtrl* dataViewCtrlPtr(dynamic_cast<wxDataViewCtrl*>(m_dataViewControlPtr->GetWXPeer()));
 312
 313      // sent the equivalent wxWidget event:
 314       wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED,dataViewCtrlPtr->GetId());
 315
 316       dataViewEvent.SetEventObject(dataViewCtrlPtr);
 317       dataViewEvent.SetItem(item);
 318      // sent the equivalent wxWidget event:
 319       dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
 320      // done
 321       return true;
 322     }
 323     else
 324       return false;
 325   }
 326
 327   virtual bool ItemsChanged(wxDataViewItemArray const& items)
 328   {
 329     bool noFailureFlag;
 330
 331     DataBrowserItemID* itemIDs;
 332
 333     size_t noOfEntries;
 334
 335
 336    // convert all valid data view items to data browser items:
 337     itemIDs = ::CreateDataBrowserItemIDArray(noOfEntries,items);
 338    // change items (ATTENTION: ONLY ITEMS OF THE ROOT ARE CHANGED BECAUSE THE PARENT PARAMETER IS MISSING):
 339     noFailureFlag = (m_dataViewControlPtr->UpdateItems(kDataBrowserNoItem,noOfEntries,itemIDs,kDataBrowserItemNoProperty,kDataBrowserItemNoProperty) == noErr);
 340     if (noFailureFlag)
 341     {
 342       wxDataViewCtrl* dataViewCtrlPtr(dynamic_cast<wxDataViewCtrl*>(m_dataViewControlPtr->GetWXPeer()));
 343
 344      // send for all changed items a wxWidget event:
 345       wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED,dataViewCtrlPtr->GetId());
 346
 347       dataViewEvent.SetEventObject(dataViewCtrlPtr);
 348       for (size_t i=0; i<noOfEntries; ++i)
 349       {
 350         dataViewEvent.SetItem(reinterpret_cast<void*>(itemIDs[i]));
 351         dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
 352       }
 353     }
 354    // release allocated array space:
 355     delete[] itemIDs;
 356    // done:
 357     return noFailureFlag;
 358   }
 359
 360   virtual bool ItemDeleted(wxDataViewItem const& parent, wxDataViewItem const& item)
 361   {
 362     if (item.IsOk())
 363     {
 364       DataBrowserItemID itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
 365       OSStatus          errorStatus;
 366       wxDataViewCtrl*   dataViewCtrlPtr(dynamic_cast<wxDataViewCtrl*>(m_dataViewControlPtr->GetWXPeer()));
 367
 368      // when this method is called and currently an item is being edited this item may have already been deleted in the model (the passed item and the being edited item have
 369      // not to be identical because the being edited item might be below the passed item in the hierarchy);
 370      // to prevent the control trying to ask the model to update an already deleted item the control is informed that currently a deleting process
 371      // has been started and that variables can currently not be updated even when requested by the system:
 372       dataViewCtrlPtr->SetDeleting(true);
 373       errorStatus = m_dataViewControlPtr->RemoveItem(reinterpret_cast<DataBrowserItemID>(parent.GetID()),&itemID);
 374      // enable automatic updating again:
 375       dataViewCtrlPtr->SetDeleting(false);
 376       return (errorStatus == noErr);
 377     }
 378     else
 379       return false;
 380   }
 381
 382   virtual bool ItemsDeleted(wxDataViewItem const& parent, wxDataViewItemArray const& items)
 383   {
 384     bool noFailureFlag;
 385
 386     DataBrowserItemID* itemIDs;
 387
 388     wxDataViewCtrl* dataViewCtrlPtr(dynamic_cast<wxDataViewCtrl*>(m_dataViewControlPtr->GetWXPeer()));
 389
 390     size_t noOfEntries;
 391
 392
 393     wxCHECK_MSG(dataViewCtrlPtr != NULL,false,_("Data view control is not correctly initialized"));
 394    // convert all valid data view items to data browser items:
 395     itemIDs = ::CreateDataBrowserItemIDArray(noOfEntries,items);
 396    // when this method is called and currently an item is being edited this item may have already been deleted in the model (the passed item and the being edited item have
 397    // not to be identical because the being edited item might be below the passed item in the hierarchy);
 398    // to prevent the control trying to ask the model to update an already deleted item the control is informed that currently a deleting process
 399    // has been started and that variables can currently not be updated even when requested by the system:
 400     dataViewCtrlPtr->SetDeleting(true);
 401    // insert all valid items into control:
 402     noFailureFlag = ((noOfEntries == 0) ||
 403                      !(parent.IsOk()) && (m_dataViewControlPtr->RemoveItems(kDataBrowserNoItem,noOfEntries,itemIDs,kDataBrowserItemNoProperty) == noErr) ||
 404                      parent.IsOk() && (m_dataViewControlPtr->RemoveItems(reinterpret_cast<DataBrowserItemID>(parent.GetID()),noOfEntries,itemIDs,kDataBrowserItemNoProperty) == noErr));
 405    // enable automatic updating again:
 406     dataViewCtrlPtr->SetDeleting(false);
 407    // give allocated array space free again:
 408     delete[] itemIDs;
 409    // done:
 410     return noFailureFlag;
 411   }
 412
 413   virtual bool ValueChanged(wxDataViewItem const& item, unsigned int col)
 414   {
 415     DataBrowserItemID itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
 416     DataBrowserItemID parentID;
 417
 418     DataBrowserPropertyID propertyID;
 419
 420     wxDataViewCtrl* dataViewCtrlPtr(dynamic_cast<wxDataViewCtrl*>(m_dataViewControlPtr->GetWXPeer()));
 421
 422
 423     wxCHECK_MSG(item.IsOk(),             false,_("Passed item is invalid."));
 424     wxCHECK_MSG(this->GetOwner() != NULL,false,_("Owner not initialized."));
 425     wxCHECK_MSG(dataViewCtrlPtr != NULL, false,_("Control is wrongly initialized."));
 426     parentID = reinterpret_cast<DataBrowserItemID>(this->GetOwner()->GetParent(item).GetID());
 427     if ((m_dataViewControlPtr->GetPropertyID(col,&propertyID) == noErr) &&
 428         (m_dataViewControlPtr->UpdateItems(parentID,1,&itemID,dataViewCtrlPtr->GetColumn(col)->GetPropertyID(),propertyID) == noErr))
 429     {
 430       wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED,dataViewCtrlPtr->GetId());
 431
 432       dataViewEvent.SetEventObject(dataViewCtrlPtr);
 433       dataViewEvent.SetColumn(col);
 434       dataViewEvent.SetItem(item);
 435      // send the equivalent wxWidget event:
 436       dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
 437      // done
 438       return true;
 439     }
 440     else
 441       return false;
 442   }
 443
 444   virtual bool Cleared()
 445   {
 446     bool noFailureFlag = (m_dataViewControlPtr->RemoveItems() == noErr);
 447     wxDataViewItem item;
 448     wxDataViewItemArray array;
 449     GetOwner()->GetChildren( item, array );
 450     ItemsAdded( item, array );
 451     m_dataViewControlPtr->SetScrollPosition(0, 0);
 452     return noFailureFlag;
 453   }
 454
 455   virtual void Resort()
 456   {
 457     m_dataViewControlPtr->Resort();
 458   }
 459
 460 private:
 461   wxMacDataViewDataBrowserListViewControl* m_dataViewControlPtr;
 462 };
 463
 464 // ---------------------------------------------------------
 465 // wxDataViewRenderer
 466 // ---------------------------------------------------------
 467 wxDataViewRenderer::wxDataViewRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
 468                    :wxDataViewRendererBase(varianttype,mode,align), m_alignment(align), m_mode(mode)
 469 {
 470 }
 471
 472 void wxDataViewRenderer::SetMode(wxDataViewCellMode mode)
 473 {
 474   wxDataViewColumn* dataViewColumnPtr;
 475
 476
 477   m_mode = mode;
 478   dataViewColumnPtr = this->GetOwner();
 479   if (dataViewColumnPtr != NULL)
 480   {
 481     wxDataViewCtrl* dataViewCtrlPtr(dataViewColumnPtr->GetOwner());
 482
 483     if (dataViewCtrlPtr != NULL)
 484     {
 485       wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
 486
 487       if (macDataViewListCtrlPtr != NULL)
 488       {
 489         DataBrowserPropertyFlags flags;
 490
 491         verify_noerr(macDataViewListCtrlPtr->GetPropertyFlags(dataViewColumnPtr->GetPropertyID(),&flags));
 492         if (mode == wxDATAVIEW_CELL_EDITABLE)
 493           flags |= kDataBrowserPropertyIsEditable;
 494         else
 495           flags &= ~kDataBrowserPropertyIsEditable;
 496         verify_noerr(macDataViewListCtrlPtr->SetPropertyFlags(dataViewColumnPtr->GetPropertyID(),flags));
 497       }
 498     }
 499   }
 500 }
 501
 502 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer,wxDataViewRendererBase)
 503
 504 // ---------------------------------------------------------
 505 // wxDataViewCustomRenderer
 506 // ---------------------------------------------------------
 507 wxDataViewCustomRenderer::wxDataViewCustomRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
 508                          :wxDataViewRenderer(varianttype,mode,align), m_editorCtrlPtr(NULL), m_DCPtr(NULL)
 509 {
 510 }
 511
 512 wxDataViewCustomRenderer::~wxDataViewCustomRenderer()
 513 {
 514     delete m_DCPtr;
 515 }
 516
 517 void wxDataViewCustomRenderer::RenderText( const wxString &text, int xoffset, wxRect cell, wxDC *dc, int state )
 518 {
 519     wxDataViewCtrl *view = GetOwner()->GetOwner();
 520 //    wxColour col = (state & wxDATAVIEW_CELL_SELECTED) ? wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT) : view->GetForegroundColour();
 521     wxColour col = (state & wxDATAVIEW_CELL_SELECTED) ? *wxWHITE : view->GetForegroundColour();
 522     dc->SetTextForeground(col);
 523     dc->DrawText( text, cell.x + xoffset, cell.y + ((cell.height - dc->GetCharHeight()) / 2));
 524 }
 525
 526 wxDC* wxDataViewCustomRenderer::GetDC()
 527 {
 528   if (m_DCPtr == NULL)
 529   {
 530     if ((GetOwner() == NULL) || (GetOwner()->GetOwner() == NULL))
 531       return NULL;
 532     m_DCPtr = new wxWindowDC(this->GetOwner()->GetOwner());
 533   }
 534   return m_DCPtr;
 535 }
 536
 537 bool wxDataViewCustomRenderer::Render()
 538 {
 539   return true;
 540 }
 541
 542 void wxDataViewCustomRenderer::SetDC(wxDC* newDCPtr)
 543 {
 544   delete m_DCPtr;
 545   m_DCPtr = newDCPtr;
 546 }
 547
 548 WXDataBrowserPropertyType wxDataViewCustomRenderer::GetPropertyType() const
 549 {
 550   return kDataBrowserCustomType;
 551 }
 552
 553 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
 554
 555 // ---------------------------------------------------------
 556 // wxDataViewTextRenderer
 557 // ---------------------------------------------------------
 558 wxDataViewTextRenderer::wxDataViewTextRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
 559                        :wxDataViewRenderer(varianttype,mode,align)
 560 {
 561 }
 562
 563 bool wxDataViewTextRenderer::Render()
 564 {
 565   wxCHECK_MSG(this->GetValue().GetType() == this->GetVariantType(),false,wxString(_("Text renderer cannot render value; value type: ")) << this->GetValue().GetType());
 566
 567   wxCFStringRef cfString(this->GetValue().GetString(),(this->GetView()->GetFont().Ok() ? this->GetView()->GetFont().GetEncoding() : wxLocale::GetSystemEncoding()));
 568   return (::SetDataBrowserItemDataText(this->GetDataReference(),cfString) == noErr);
 569 }
 570
 571 WXDataBrowserPropertyType wxDataViewTextRenderer::GetPropertyType() const
 572 {
 573   return kDataBrowserTextType;
 574 }
 575
 576 IMPLEMENT_CLASS(wxDataViewTextRenderer,wxDataViewRenderer)
 577
 578 // ---------------------------------------------------------
 579 // wxDataViewTextRendererAttr
 580 // ---------------------------------------------------------
 581 wxDataViewTextRendererAttr::wxDataViewTextRendererAttr(wxString const& varianttype, wxDataViewCellMode mode, int align)
 582                            :wxDataViewTextRenderer(varianttype,mode,align)
 583 {
 584 }
 585
 586 IMPLEMENT_CLASS(wxDataViewTextRendererAttr,wxDataViewTextRenderer)
 587
 588 // ---------------------------------------------------------
 589 // wxDataViewBitmapRenderer
 590 // ---------------------------------------------------------
 591 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
 592                          :wxDataViewRenderer(varianttype,mode,align)
 593 {
 594 }
 595
 596 bool wxDataViewBitmapRenderer::Render()
 597  // This method returns 'true' if
 598  //  - the passed bitmap is valid and it could be assigned to the native data browser;
 599  //  - the passed bitmap is invalid (or is not initialized); this case simulates a non-existing bitmap.
 600  // In all other cases the method returns 'false'.
 601 {
 602   wxCHECK_MSG(this->GetValue().GetType() == this->GetVariantType(),false,wxString(_("Bitmap renderer cannot render value; value type: ")) << this->GetValue().GetType());
 603
 604   wxBitmap bitmap;
 605
 606   bitmap << this->GetValue();
 607   if (bitmap.Ok())
 608     return (::SetDataBrowserItemDataIcon(this->GetDataReference(),bitmap.GetIconRef()) == noErr);
 609   else
 610     return true;
 611 }
 612
 613 WXDataBrowserPropertyType wxDataViewBitmapRenderer::GetPropertyType() const
 614 {
 615   return kDataBrowserIconType;
 616 }
 617
 618 IMPLEMENT_CLASS(wxDataViewBitmapRenderer,wxDataViewRenderer)
 619
 620 // ---------------------------------------------------------
 621 // wxDataViewIconTextRenderer
 622 // ---------------------------------------------------------
 623 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
 624                            :wxDataViewRenderer(varianttype,mode)
 625 {
 626 }
 627
 628 bool wxDataViewIconTextRenderer::Render()
 629 {
 630   wxCHECK_MSG(this->GetValue().GetType() == this->GetVariantType(),false,wxString(_("Icon & text renderer cannot render value; value type: ")) << this->GetValue().GetType());
 631
 632   wxDataViewIconText iconText;
 633
 634   iconText << this->GetValue();
 635
 636   wxCFStringRef cfString(iconText.GetText(),(this->GetView()->GetFont().Ok() ? this->GetView()->GetFont().GetEncoding() : wxLocale::GetSystemEncoding()));
 637
 638   if (iconText.GetIcon().IsOk())
 639     if (::SetDataBrowserItemDataIcon(this->GetDataReference(),MAC_WXHICON(iconText.GetIcon().GetHICON())) != noErr)
 640       return false;
 641   return (::SetDataBrowserItemDataText(this->GetDataReference(),cfString) == noErr);
 642 }
 643
 644 WXDataBrowserPropertyType wxDataViewIconTextRenderer::GetPropertyType() const
 645 {
 646   return kDataBrowserIconAndTextType;
 647 }
 648
 649 IMPLEMENT_ABSTRACT_CLASS(wxDataViewIconTextRenderer,wxDataViewRenderer)
 650
 651
 652 // ---------------------------------------------------------
 653 // wxDataViewToggleRenderer
 654 // ---------------------------------------------------------
 655 wxDataViewToggleRenderer::wxDataViewToggleRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
 656                          :wxDataViewRenderer(varianttype,mode)
 657 {
 658 }
 659
 660 bool wxDataViewToggleRenderer::Render()
 661 {
 662   wxCHECK_MSG(this->GetValue().GetType() == this->GetVariantType(),false,wxString(_("Toggle renderer cannot render value; value type: ")) << this->GetValue().GetType());
 663   return (::SetDataBrowserItemDataButtonValue(this->GetDataReference(),this->GetValue().GetBool()) == noErr);
 664 }
 665
 666 WXDataBrowserPropertyType wxDataViewToggleRenderer::GetPropertyType() const
 667 {
 668   return kDataBrowserCheckboxType;
 669 }
 670
 671 IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleRenderer,wxDataViewRenderer)
 672
 673 // ---------------------------------------------------------
 674 // wxDataViewProgressRenderer
 675 // ---------------------------------------------------------
 676 wxDataViewProgressRenderer::wxDataViewProgressRenderer(wxString const& label, wxString const& varianttype, wxDataViewCellMode mode, int align)
 677                            :wxDataViewRenderer(varianttype,mode,align)
 678 {
 679 }
 680
 681 bool wxDataViewProgressRenderer::Render()
 682 {
 683   wxCHECK_MSG(this->GetValue().GetType() == this->GetVariantType(),false,wxString(_("Progress renderer cannot render value type; value type: ")) << this->GetValue().GetType());
 684   return ((::SetDataBrowserItemDataMinimum(this->GetDataReference(),  0)                        == noErr) &&
 685           (::SetDataBrowserItemDataMaximum(this->GetDataReference(),100)                        == noErr) &&
 686           (::SetDataBrowserItemDataValue  (this->GetDataReference(),this->GetValue().GetLong()) == noErr));
 687 }
 688
 689 WXDataBrowserPropertyType wxDataViewProgressRenderer::GetPropertyType() const
 690 {
 691   return kDataBrowserProgressBarType;
 692 }
 693
 694 IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressRenderer,wxDataViewRenderer)
 695
 696 // ---------------------------------------------------------
 697 // wxDataViewDateRenderer
 698 // ---------------------------------------------------------
 699 wxDataViewDateRenderer::wxDataViewDateRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
 700                        :wxDataViewRenderer(varianttype,mode,align)
 701 {
 702 }
 703
 704 bool wxDataViewDateRenderer::Render()
 705 {
 706   wxCHECK_MSG(this->GetValue().GetType() == this->GetVariantType(),false,wxString(_("Date renderer cannot render value; value type: ")) << this->GetValue().GetType());
 707   return (::SetDataBrowserItemDataDateTime(this->GetDataReference(),this->GetValue().GetDateTime().Subtract(wxDateTime(1,wxDateTime::Jan,1904)).GetSeconds().GetLo()) == noErr);
 708 }
 709
 710 WXDataBrowserPropertyType wxDataViewDateRenderer::GetPropertyType() const
 711 {
 712   return kDataBrowserDateTimeType;
 713 }
 714
 715 IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateRenderer,wxDataViewRenderer)
 716
 717 // ---------------------------------------------------------
 718 // wxDataViewColumn
 719 // ---------------------------------------------------------
 720
 721 void wxDataViewColumn::SetAlignment(wxAlignment align)
 722 {
 723   wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
 724
 725
 726   m_alignment = align;
 727   if (dataViewCtrlPtr != NULL)
 728   {
 729     wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
 730
 731     if (macDataViewListCtrlPtr != NULL)
 732     {
 733       DataBrowserListViewHeaderDesc headerDescription;
 734
 735       wxCHECK_RET(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not get header description."));
 736       switch (align)
 737       {
 738         case wxALIGN_CENTER:
 739         case wxALIGN_CENTER_HORIZONTAL:
 740           headerDescription.btnFontStyle.just = teCenter;
 741           break;
 742         case wxALIGN_LEFT:
 743           headerDescription.btnFontStyle.just = teFlushLeft;
 744           break;
 745         case wxALIGN_RIGHT:
 746           headerDescription.btnFontStyle.just = teFlushRight;
 747           break;
 748         default:
 749           headerDescription.btnFontStyle.just = teFlushDefault;
 750       }
 751       wxCHECK_RET(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not set alignment."));
 752     }
 753   }
 754 }
 755
 756 void wxDataViewColumn::SetBitmap(wxBitmap const& bitmap)
 757 {
 758   wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
 759
 760
 761   wxDataViewColumnBase::SetBitmap(bitmap);
 762   if (dataViewCtrlPtr != NULL)
 763   {
 764     wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
 765
 766     if (macDataViewListCtrlPtr != NULL)
 767     {
 768       DataBrowserListViewHeaderDesc headerDescription;
 769
 770       wxCHECK_RET(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not get header description."));
 771       if (this->GetBitmap().Ok())
 772         headerDescription.btnContentInfo.u.iconRef = this->GetBitmap().GetIconRef();
 773       else
 774         headerDescription.btnContentInfo.u.iconRef = NULL;
 775       wxCHECK_RET(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not set icon."));
 776     }
 777   }
 778 }
 779
 780 void wxDataViewColumn::SetMaxWidth(int maxWidth)
 781 {
 782   wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
 783
 784
 785   m_maxWidth = maxWidth;
 786   if (dataViewCtrlPtr != NULL)
 787   {
 788     wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
 789
 790     if (macDataViewListCtrlPtr != NULL)
 791     {
 792       DataBrowserListViewHeaderDesc headerDescription;
 793
 794       wxCHECK_RET(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not get header description."));
 795       headerDescription.maximumWidth = static_cast<UInt16>(maxWidth);
 796       wxCHECK_RET(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not set maximum width."));
 797     }
 798   }
 799 }
 800
 801 void wxDataViewColumn::SetMinWidth(int minWidth)
 802 {
 803   wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
 804
 805
 806   m_minWidth = minWidth;
 807   if (dataViewCtrlPtr != NULL)
 808   {
 809     wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
 810
 811     if (macDataViewListCtrlPtr != NULL)
 812     {
 813       DataBrowserListViewHeaderDesc headerDescription;
 814
 815       wxCHECK_RET(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not get header description."));
 816       headerDescription.minimumWidth = static_cast<UInt16>(minWidth);
 817       wxCHECK_RET(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not set minimum width."));
 818     }
 819   }
 820 }
 821
 822 void wxDataViewColumn::SetReorderable(bool reorderable)
 823 {
 824  // first set the internal flag of the column:
 825   if (reorderable)
 826     m_flags |= wxDATAVIEW_COL_REORDERABLE;
 827   else
 828     m_flags &= ~wxDATAVIEW_COL_REORDERABLE;
 829  // if the column is associated with a control change also immediately the flags of the control:
 830   wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
 831
 832   if (dataViewCtrlPtr != NULL)
 833   {
 834     DataBrowserPropertyFlags                       flags;
 835     wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
 836
 837     wxCHECK_RET(macDataViewListCtrlPtr != NULL,                                                 _("Valid pointer to native data view control does not exist"));
 838     wxCHECK_RET(macDataViewListCtrlPtr->GetPropertyFlags(this->GetPropertyID(),&flags) == noErr,_("Could not get property flags."));
 839     if (reorderable)
 840       flags |= kDataBrowserListViewMovableColumn;
 841     else
 842       flags &= ~kDataBrowserListViewMovableColumn;
 843     wxCHECK_RET(macDataViewListCtrlPtr->SetPropertyFlags(this->GetPropertyID(),flags) == noErr,_("Could not set property flags."));
 844   }
 845 }
 846
 847 void wxDataViewColumn::SetResizeable(bool resizeable)
 848 {
 849  // first set the internal flag of the column:
 850   if (resizeable)
 851     m_flags |= wxDATAVIEW_COL_RESIZABLE;
 852   else
 853     m_flags &= ~wxDATAVIEW_COL_RESIZABLE;
 854  // if the column is associated with a control change also immediately the flags of the control:
 855   wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
 856
 857   if (dataViewCtrlPtr != NULL)
 858   {
 859     wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
 860
 861     if (macDataViewListCtrlPtr != NULL)
 862     {
 863       DataBrowserListViewHeaderDesc headerDescription;
 864
 865       verify_noerr(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription));
 866       if (resizeable) {
 867         headerDescription.minimumWidth = 0;
 868         headerDescription.maximumWidth = 30000;
 869       }
 870       else {
 871         headerDescription.minimumWidth = m_width;
 872         headerDescription.maximumWidth = m_width;
 873       }
 874       verify_noerr(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription));
 875       macDataViewListCtrlPtr->SetSortProperty(this->GetPropertyID());
 876     }
 877   }
 878 }
 879
 880 void wxDataViewColumn::SetSortable(bool sortable)
 881 {
 882  // first set the internal flag of the column:
 883   if (sortable)
 884     m_flags |= wxDATAVIEW_COL_SORTABLE;
 885   else
 886     m_flags &= ~wxDATAVIEW_COL_SORTABLE;
 887  // if the column is associated with a control change also immediately the flags of the control:
 888   wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
 889
 890   if (dataViewCtrlPtr != NULL)
 891   {
 892     DataBrowserPropertyFlags                       flags;
 893     wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
 894
 895     wxCHECK_RET(macDataViewListCtrlPtr != NULL,                                                 _("Valid pointer to native data view control does not exist"));
 896     wxCHECK_RET(macDataViewListCtrlPtr->GetPropertyFlags(this->GetPropertyID(),&flags) == noErr,_("Could not get property flags."));
 897     if (sortable)
 898       flags |= kDataBrowserListViewSortableColumn;
 899     else
 900       flags &= ~kDataBrowserListViewSortableColumn;
 901     wxCHECK_RET(macDataViewListCtrlPtr->SetPropertyFlags(this->GetPropertyID(),flags) == noErr,_("Could not set property flags."));
 902   }
 903 }
 904
 905 void wxDataViewColumn::SetSortOrder(bool ascending)
 906 {
 907   wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
 908
 909
 910   m_ascending = ascending;
 911   if (dataViewCtrlPtr != NULL)
 912   {
 913     wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
 914
 915     if (macDataViewListCtrlPtr != NULL)
 916     {
 917       DataBrowserListViewHeaderDesc headerDescription;
 918
 919       verify_noerr(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription));
 920       if (ascending)
 921         headerDescription.initialOrder = kDataBrowserOrderIncreasing;
 922       else
 923         headerDescription.initialOrder = kDataBrowserOrderDecreasing;
 924       verify_noerr(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription));
 925       macDataViewListCtrlPtr->SetSortProperty(this->GetPropertyID());
 926     }
 927   }
 928 }
 929
 930 void wxDataViewColumn::SetTitle(wxString const& title)
 931 {
 932   wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
 933
 934
 935   m_title = title;
 936   if (dataViewCtrlPtr != NULL)
 937   {
 938     wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
 939
 940     if (macDataViewListCtrlPtr != NULL)
 941     {
 942       DataBrowserListViewHeaderDesc headerDescription;
 943       wxCFStringRef           cfTitle(title,(dataViewCtrlPtr->GetFont().Ok() ? dataViewCtrlPtr->GetFont().GetEncoding() : wxLocale::GetSystemEncoding()));
 944
 945       wxCHECK_RET(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not get header description."));
 946       headerDescription.titleString = cfTitle;
 947       wxCHECK_RET(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not set header description."));
 948     }
 949   }
 950 }
 951
 952 void wxDataViewColumn::SetWidth(int width)
 953 {
 954   wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
 955
 956
 957   if ((width >= m_minWidth) && (width <= m_maxWidth))
 958   {
 959     m_width = width;
 960     if (dataViewCtrlPtr != NULL)
 961     {
 962       wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
 963
 964       if (macDataViewListCtrlPtr != NULL)
 965         wxCHECK_RET(macDataViewListCtrlPtr->SetColumnWidth(this->GetPropertyID(),static_cast<UInt16>(width)) == noErr,_("Could not set column width."));
 966     }
 967   }
 968 }
 969
 970 void wxDataViewColumn::SetAsSortKey(bool WXUNUSED(sort))
 971 {
 972     // see wxGTK native wxDataViewColumn implementation
 973     wxFAIL_MSG( "not implemented" );
 974 }
 975
 976 bool wxDataViewColumn::IsSortKey() const
 977 {
 978     wxDataViewCtrl * const dataViewCtrlPtr(GetOwner());
 979     wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(
 980         dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(
 981             dataViewCtrlPtr->GetPeer()));
 982
 983     DataBrowserPropertyID propertyID;
 984     return macDataViewListCtrlPtr->GetSortProperty(&propertyID) == noErr &&
 985             propertyID == m_propertyID;
 986 }
 987
 988 //-----------------------------------------------------------------------------
 989 // wxDataViewCtrl
 990 //-----------------------------------------------------------------------------
 991
 992
 993 wxDataViewCtrl::~wxDataViewCtrl()
 994 {
 995    ClearColumns();
 996 }
 997
 998 void wxDataViewCtrl::Init()
 999 {
1000   m_CustomRendererPtr = NULL;
1001   m_Deleting          = false;
1002   m_macIsUserPane     = false;
1003   m_cgContext         = NULL;
1004 }
1005
1006 bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator )
1007 {
1008   if (!(this->wxControl::Create(parent,id,pos,size,style & ~(wxHSCROLL | wxVSCROLL),validator)))
1009     return false;
1010
1011 #ifdef __WXMAC__
1012   MacSetClipChildren(true) ;
1013 #endif
1014
1015   m_peer = new wxMacDataViewDataBrowserListViewControl(this,pos,size,style);
1016
1017   if ( style & wxBORDER_NONE )
1018     m_peer->SetData( kControlNoPart, kControlDataBrowserIncludesFrameAndFocusTag, (Boolean) false ) ;
1019
1020   this->MacPostControlCreate(pos,size);
1021   ::SetAutomaticControlDragTrackingEnabledForWindow(::GetControlOwner(m_peer->GetControlRef()),true);
1022
1023   InstallControlEventHandler(m_peer->GetControlRef(),GetwxMacDataViewCtrlEventHandlerUPP(),GetEventTypeCount(eventList),eventList,this,NULL);
1024
1025   ::SetDataBrowserTableViewHiliteStyle( m_peer->GetControlRef(), kDataBrowserTableViewFillHilite );
1026
1027   return true;
1028 }
1029
1030 /*static*/
1031 wxVisualAttributes wxDataViewCtrl::GetClassDefaultAttributes(wxWindowVariant variant)
1032 {
1033     wxVisualAttributes attr;
1034
1035     attr.colFg = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
1036     attr.colBg = wxSystemSettings::GetColour( wxSYS_COLOUR_LISTBOX );
1037     attr.font.MacCreateFromThemeFont(kThemeViewsFont);
1038
1039     return attr;
1040 }
1041
1042 bool wxDataViewCtrl::AssociateModel(wxDataViewModel* model)
1043 {
1044   if (!wxDataViewCtrlBase::AssociateModel(model))
1045     return false;
1046
1047   model->AddNotifier(new wxMacDataViewModelNotifier(dynamic_cast<wxMacDataViewDataBrowserListViewControl*>(m_peer)));
1048
1049   return true;
1050 }
1051
1052 bool wxDataViewCtrl::AppendColumn(wxDataViewColumn* columnPtr)
1053 {
1054    return InsertColumn( kDataBrowserListViewAppendColumn, columnPtr );
1055 }
1056
1057 bool wxDataViewCtrl::PrependColumn(wxDataViewColumn* columnPtr)
1058 {
1059    return InsertColumn( 0, columnPtr );
1060 }
1061
1062 bool wxDataViewCtrl::InsertColumn(unsigned int pos, wxDataViewColumn* columnPtr)
1063 {
1064   DataBrowserListViewColumnDesc columnDescription;
1065
1066   DataBrowserPropertyID NewPropertyID;
1067
1068   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1069
1070   wxCFStringRef title(columnPtr->GetTitle(),m_font.Ok() ? this->GetFont().GetEncoding() : wxLocale::GetSystemEncoding());
1071
1072
1073  // first, some error checking:
1074   wxCHECK_MSG(MacDataViewListCtrlPtr != NULL,                                    false,_("m_peer is not or incorrectly initialized"));
1075   wxCHECK_MSG(columnPtr != NULL,                                                 false,_("Column pointer must not be NULL."));
1076   wxCHECK_MSG(columnPtr->GetRenderer() != NULL,                                  false,_("Column does not have a renderer."));
1077   wxCHECK_MSG(this->GetModel() != NULL,                                          false,_("No model associated with control."));
1078   wxCHECK_MSG((columnPtr->GetModelColumn() >= 0) &&
1079               (columnPtr->GetModelColumn() < this->GetModel()->GetColumnCount()),false,_("Column's model column has no equivalent in the associated model."));
1080
1081  // try to get new ID for the column:
1082   wxCHECK_MSG(MacDataViewListCtrlPtr->GetFreePropertyID(&NewPropertyID) == noErr,false,_("Cannot create new column's ID. Probably max. number of columns reached."));
1083  // full column variable initialization:
1084   columnPtr->SetPropertyID(NewPropertyID);
1085  // add column to wxWidget's internal structure:
1086   wxCHECK_MSG(this->wxDataViewCtrlBase::AppendColumn(columnPtr) &&
1087               m_ColumnPointers.insert(ColumnPointerHashMapType::value_type(NewPropertyID,columnPtr)).second,false,_("Could not add column to internal structures."));
1088  // create a column description and add column to the native control:
1089   wxCHECK_MSG(::InitializeColumnDescription(columnDescription,columnPtr,NewPropertyID,title),                 false,_("Column description could not be initialized."));
1090   wxCHECK_MSG(MacDataViewListCtrlPtr->AddColumn(&columnDescription,pos) == noErr,false,_("Column could not be added."));
1091
1092  // final adjustments for the layout:
1093   wxCHECK_MSG(MacDataViewListCtrlPtr->SetColumnWidth(NewPropertyID,columnPtr->GetWidth()) == noErr,false,_("Column width could not be set."));
1094
1095  // make sure that the data is up-to-date...
1096  // if the newly appended column is the first column add the initial data to the control and mark the column as an expander column,
1097  // otherwise ask the control to 'update' the data in the newly appended column:
1098   if (this->GetColumnCount() == 1)
1099   {
1100     this->SetExpanderColumn(columnPtr);
1101     this->AddChildrenLevel(wxDataViewItem());
1102   }
1103   else
1104     MacDataViewListCtrlPtr->UpdateItems(kDataBrowserNoItem,0,NULL,kDataBrowserItemNoProperty,NewPropertyID);
1105  // done:
1106   return true;
1107 }
1108
1109 bool wxDataViewCtrl::ClearColumns()
1110 {
1111   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1112
1113
1114   while (m_ColumnPointers.begin() != m_ColumnPointers.end())
1115   {
1116     wxCHECK_MSG(MacDataViewListCtrlPtr->RemoveColumnByProperty(m_ColumnPointers.begin()->first) == noErr,false,_("Could not remove column."));
1117     delete m_ColumnPointers.begin()->second;
1118     m_ColumnPointers.erase(m_ColumnPointers.begin());
1119   }
1120   return true;
1121 }
1122
1123 bool wxDataViewCtrl::DeleteColumn(wxDataViewColumn* columnPtr)
1124 {
1125   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1126
1127
1128   if ((MacDataViewListCtrlPtr->RemoveColumnByProperty(columnPtr->GetPropertyID()) == noErr) && (m_ColumnPointers.erase(columnPtr->GetPropertyID()) > 0))
1129   {
1130     delete columnPtr;
1131     return true;
1132   }
1133   else
1134     return false;
1135 }
1136
1137 wxDataViewColumn* wxDataViewCtrl::GetColumn(unsigned int pos) const
1138 {
1139   DataBrowserPropertyID propertyID;
1140
1141   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1142
1143
1144   if (MacDataViewListCtrlPtr->GetPropertyID(pos,&propertyID) == noErr)
1145   {
1146     ColumnPointerHashMapType::const_iterator Result(m_ColumnPointers.find(propertyID));
1147
1148     if (Result != m_ColumnPointers.end())
1149       return Result->second;
1150     else
1151       return NULL;
1152   }
1153   else
1154     return NULL;
1155 }
1156
1157 unsigned int wxDataViewCtrl::GetColumnCount() const
1158 {
1159   return m_ColumnPointers.size();
1160 }
1161
1162 int wxDataViewCtrl::GetColumnPosition(wxDataViewColumn const* columnPtr) const
1163 {
1164   if (columnPtr != NULL)
1165   {
1166     DataBrowserTableViewColumnIndex                Position;
1167     wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1168
1169     wxCHECK_MSG(MacDataViewListCtrlPtr->GetColumnIndex(columnPtr->GetPropertyID(),&Position) == noErr,-1,_("Could not determine column's position"));
1170     return static_cast<int>(Position);
1171   }
1172   else
1173     return wxNOT_FOUND;
1174 }
1175
1176 void wxDataViewCtrl::Collapse(wxDataViewItem const& item)
1177 {
1178   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1179
1180
1181   MacDataViewListCtrlPtr->CloseContainer(reinterpret_cast<DataBrowserItemID>(item.GetID()));
1182 }
1183
1184 void wxDataViewCtrl::EnsureVisible(wxDataViewItem const& item, wxDataViewColumn const* columnPtr)
1185 {
1186   if (item.IsOk())
1187   {
1188     DataBrowserPropertyID propertyID;
1189     wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1190
1191     if (columnPtr != NULL)
1192       propertyID = columnPtr->GetPropertyID();
1193     else
1194       propertyID = kDataBrowserNoItem;
1195     MacDataViewListCtrlPtr->RevealItem(reinterpret_cast<DataBrowserItemID>(item.GetID()),propertyID,kDataBrowserRevealOnly);
1196   }
1197 }
1198
1199 void wxDataViewCtrl::Expand(wxDataViewItem const& item)
1200 {
1201   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1202
1203
1204   MacDataViewListCtrlPtr->OpenContainer(reinterpret_cast<DataBrowserItemID>(item.GetID()));
1205 }
1206
1207 bool wxDataViewCtrl::IsExpanded( const wxDataViewItem & item ) const
1208 {
1209   if (item.IsOk())
1210   {
1211     wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1212
1213     // TODO ???
1214     // This doesn't seem to be supported
1215   }
1216   return false;
1217 }
1218
1219 wxDataViewColumn* wxDataViewCtrl::GetSortingColumn() const
1220 {
1221   DataBrowserPropertyID propertyID;
1222
1223   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1224
1225
1226   if (MacDataViewListCtrlPtr->GetSortProperty(&propertyID) == noErr)
1227     return this->GetColumnPtr(propertyID);
1228   else
1229     return NULL;
1230 }
1231
1232 unsigned int wxDataViewCtrl::GetCount() const
1233 {
1234   ItemCount noOfItems;
1235
1236
1237   wxCHECK_MSG(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer)->GetItemCount(&noOfItems) == noErr,0,_("Could not determine number of items"));
1238   return noOfItems;
1239 }
1240
1241 wxRect wxDataViewCtrl::GetItemRect(wxDataViewItem const& item, wxDataViewColumn const* columnPtr) const
1242 {
1243   if (item.IsOk() && (columnPtr != NULL))
1244   {
1245     Rect                                           MacRectangle;
1246     wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1247
1248     if (MacDataViewListCtrlPtr->GetPartBounds(reinterpret_cast<DataBrowserItemID>(item.GetID()),columnPtr->GetPropertyID(),kDataBrowserPropertyContentPart,&MacRectangle) == noErr)
1249     {
1250       wxRect rectangle;
1251
1252       ::wxMacNativeToRect(&MacRectangle,&rectangle);
1253       return rectangle;
1254     }
1255     else
1256       return wxRect();
1257   }
1258   else
1259     return wxRect();
1260 }
1261
1262 wxDataViewItem wxDataViewCtrl::GetSelection() const
1263 {
1264   wxArrayDataBrowserItemID itemIDs;
1265
1266   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1267
1268
1269   if (MacDataViewListCtrlPtr->GetSelectedItemIDs(itemIDs) > 0)
1270     return wxDataViewItem(reinterpret_cast<void*>(itemIDs[0]));
1271   else
1272     return wxDataViewItem();
1273 }
1274
1275 int wxDataViewCtrl::GetSelections(wxDataViewItemArray& sel) const
1276 {
1277   size_t NoOfSelectedItems;
1278
1279   wxArrayDataBrowserItemID itemIDs;
1280
1281   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1282
1283
1284   NoOfSelectedItems = MacDataViewListCtrlPtr->GetSelectedItemIDs(itemIDs);
1285   sel.Empty();
1286   sel.SetCount(NoOfSelectedItems);
1287   for (size_t i=0; i<NoOfSelectedItems; ++i)
1288     sel[i] = wxDataViewItem(reinterpret_cast<void*>(itemIDs[i]));
1289   return static_cast<int>(NoOfSelectedItems);
1290 }
1291
1292 void wxDataViewCtrl::HitTest(wxPoint const& point, wxDataViewItem& item, wxDataViewColumn*& columnPtr) const
1293 {
1294   item = wxDataViewItem();
1295   columnPtr = NULL;
1296 }
1297
1298 bool wxDataViewCtrl::IsSelected(wxDataViewItem const& item) const
1299 {
1300   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1301
1302
1303   return MacDataViewListCtrlPtr->IsItemSelected(reinterpret_cast<DataBrowserItemID>(item.GetID()));
1304 }
1305
1306 void wxDataViewCtrl::SelectAll()
1307 {
1308   DataBrowserItemID* itemIDPtr;
1309
1310   Handle handle(::NewHandle(0));
1311
1312   size_t NoOfItems;
1313
1314   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1315
1316
1317   wxCHECK_RET(MacDataViewListCtrlPtr->GetItems(kDataBrowserNoItem,true,kDataBrowserItemAnyState,handle) == noErr,_("Could not get items."));
1318   NoOfItems = static_cast<size_t>(::GetHandleSize(handle)/sizeof(DataBrowserItemID));
1319   HLock(handle);
1320   itemIDPtr = (DataBrowserItemID*) (*handle);
1321   MacDataViewListCtrlPtr->SetSelectedItems(NoOfItems,itemIDPtr,kDataBrowserItemsAssign);
1322   HUnlock(handle);
1323   DisposeHandle(handle);
1324 }
1325
1326 void wxDataViewCtrl::Select(wxDataViewItem const& item)
1327 {
1328   if (item.IsOk())
1329   {
1330     DataBrowserItemID                              itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
1331     wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1332
1333     MacDataViewListCtrlPtr->SetSelectedItems(1,&itemID,kDataBrowserItemsAdd);
1334   }
1335 }
1336
1337 void wxDataViewCtrl::SetSelections(wxDataViewItemArray const& sel)
1338 {
1339   size_t const NoOfSelections = sel.GetCount();
1340
1341   DataBrowserItemID* itemIDs;
1342
1343   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1344
1345
1346   itemIDs = new DataBrowserItemID[NoOfSelections];
1347   for (size_t i=0; i<NoOfSelections; ++i)
1348     itemIDs[i] = reinterpret_cast<DataBrowserItemID>(sel[i].GetID());
1349   MacDataViewListCtrlPtr->SetSelectedItems(NoOfSelections,itemIDs,kDataBrowserItemsAssign);
1350   delete[] itemIDs;
1351 }
1352
1353 void wxDataViewCtrl::Unselect(wxDataViewItem const& item)
1354 {
1355   if (item.IsOk())
1356   {
1357     DataBrowserItemID                              itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
1358     wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1359
1360     MacDataViewListCtrlPtr->SetSelectedItems(1,&itemID,kDataBrowserItemsRemove);
1361   }
1362 }
1363
1364 void wxDataViewCtrl::UnselectAll()
1365 {
1366   DataBrowserItemID* itemIDPtr;
1367
1368   Handle handle(::NewHandle(0));
1369
1370   size_t NoOfItems;
1371
1372   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1373
1374
1375   wxCHECK_RET(MacDataViewListCtrlPtr->GetItems(kDataBrowserNoItem,true,kDataBrowserItemAnyState,handle) == noErr,_("Could not get items."));
1376   NoOfItems = static_cast<size_t>(::GetHandleSize(handle)/sizeof(DataBrowserItemID));
1377   HLock(handle);
1378   itemIDPtr = (DataBrowserItemID*) (*handle);
1379   MacDataViewListCtrlPtr->SetSelectedItems(NoOfItems,itemIDPtr,kDataBrowserItemsRemove);
1380   HUnlock(handle);
1381   DisposeHandle(handle);
1382 }
1383
1384 // data handling:
1385 void wxDataViewCtrl::AddChildrenLevel(wxDataViewItem const& parentItem)
1386 {
1387   int NoOfChildren;
1388
1389   wxDataViewItemArray items;
1390
1391
1392   wxCHECK_RET(this->GetModel() != NULL,_("Model pointer not initialized."));
1393   NoOfChildren = this->GetModel()->GetChildren(parentItem,items);
1394 #if 0
1395   for (int i=0; i<NoOfChildren; ++i)
1396     (void) this->GetModel()->ItemAdded(parentItem,items[i]);
1397 #else
1398   (void) this->GetModel()->ItemsAdded(parentItem,items);
1399 #endif
1400 }
1401
1402 void wxDataViewCtrl::FinishCustomItemEditing()
1403 {
1404   if (this->GetCustomRendererItem().IsOk())
1405   {
1406     this->GetCustomRendererPtr()->FinishEditing();
1407     this->SetCustomRendererItem(wxDataViewItem());
1408     this->SetCustomRendererPtr (NULL);
1409   }
1410 }
1411
1412 wxDataViewColumn* wxDataViewCtrl::GetColumnPtr(WXDataBrowserPropertyID propertyID) const
1413 {
1414   ColumnPointerHashMapType::const_iterator Result(m_ColumnPointers.find(propertyID));
1415
1416   if (Result != m_ColumnPointers.end())
1417     return Result->second;
1418   else
1419     return NULL;
1420 }
1421
1422 // inherited methods from wxDataViewCtrlBase
1423 void wxDataViewCtrl::DoSetExpanderColumn()
1424 {
1425   if (this->GetExpanderColumn() != NULL)
1426   {
1427     wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1428
1429     (void) MacDataViewListCtrlPtr->SetDisclosureColumn(this->GetExpanderColumn()->GetPropertyID(),false); // second parameter explicitely passed to ensure that arrow is centered
1430   }
1431 }
1432
1433 void wxDataViewCtrl::DoSetIndent()
1434 {
1435   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1436
1437   (void) MacDataViewListCtrlPtr->SetIndent(static_cast<float>(this->GetIndent()));
1438 }
1439
1440 // event handling:
1441 void wxDataViewCtrl::OnSize(wxSizeEvent& event)
1442 {
1443   unsigned int const NoOfColumns = this->GetColumnCount();
1444
1445
1446   for (unsigned int i=0; i<NoOfColumns; ++i)
1447   {
1448     wxDataViewColumn* dataViewColumnPtr(this->GetColumn(i));
1449
1450     if (dataViewColumnPtr != NULL)
1451     {
1452       wxDataViewCustomRenderer* dataViewCustomRendererPtr(dynamic_cast<wxDataViewCustomRenderer*>(dataViewColumnPtr->GetRenderer()));
1453
1454       if (dataViewCustomRendererPtr != NULL)
1455         dataViewCustomRendererPtr->SetDC(NULL); // reset DC because DC has changed
1456     }
1457   }
1458
1459   wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(m_peer));
1460   ControlRef ref = MacDataViewListCtrlPtr->GetControlRef();
1461   if (NoOfColumns == 1)
1462   {
1463      ::SetDataBrowserHasScrollBars( ref, false, true );
1464      ::AutoSizeDataBrowserListViewColumns( ref );
1465   }
1466   if (NoOfColumns > 1)
1467   {
1468      ::SetDataBrowserHasScrollBars( ref, true, true );
1469   }
1470
1471   event.Skip();
1472 }
1473
1474 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl,wxDataViewCtrlBase)
1475
1476 BEGIN_EVENT_TABLE(wxDataViewCtrl,wxDataViewCtrlBase)
1477   EVT_SIZE(wxDataViewCtrl::OnSize)
1478 END_EVENT_TABLE()
1479
1480 #endif // !wxUSE_GENERICDATAVIEWCTRL
1481
1482 #endif // wxUSE_DATAVIEWCTRL
1483