src/osx/cocoa/dataview.mm

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/osx/cocoa/dataview.mm
   3 // Purpose:     wxDataView
   4 // Author:
   5 // Modified by:
   6 // Created:     2009-01-31
   7 // RCS-ID:      $Id: dataview.mm$
   8 // Copyright:
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 #include "wx/wxprec.h"
  13
  14 #if (wxUSE_DATAVIEWCTRL == 1) && !defined(wxUSE_GENERICDATAVIEWCTRL)
  15
  16 #ifndef WX_PRECOMP
  17     #include "wx/app.h"
  18     #include "wx/toplevel.h"
  19     #include "wx/font.h"
  20     #include "wx/settings.h"
  21     #include "wx/utils.h"
  22 #endif
  23
  24 #include "wx/osx/cocoa/dataview.h"
  25 #include "wx/osx/private.h"
  26 #include "wx/renderer.h"
  27
  28
  29 // ============================================================================
  30 // Constants used locally
  31 // ============================================================================
  32 #define DataViewPboardType @"OutlineViewItem"
  33
  34 // ============================================================================
  35 // Classes used locally in dataview.mm
  36 // ============================================================================
  37 @interface wxCustomRendererObject : NSObject <NSCopying>
  38 {
  39 @public
  40   wxDataViewCustomRenderer* customRenderer; // not owned by the class
  41 }
  42
  43  //
  44  // initialization
  45  //
  46   -(id) init;
  47   -(id) initWithRenderer:(wxDataViewCustomRenderer*)renderer;
  48
  49 @end
  50
  51 @implementation wxCustomRendererObject
  52 //
  53 // initialization
  54 //
  55 -(id) init
  56 {
  57   self = [super init];
  58   if (self != nil)
  59   {
  60     customRenderer = NULL;
  61   }
  62   return self;
  63 }
  64
  65 -(id) initWithRenderer:(wxDataViewCustomRenderer*)renderer
  66 {
  67   self = [super init];
  68   if (self != nil)
  69   {
  70     customRenderer = renderer;
  71   }
  72   return self;
  73 }
  74
  75 -(id) copyWithZone:(NSZone*)zone
  76 {
  77   wxCustomRendererObject* copy;
  78
  79   copy = [[[self class] allocWithZone:zone] init];
  80   copy->customRenderer = customRenderer;
  81
  82   return copy;
  83 }
  84
  85 @end
  86
  87 // ============================================================================
  88 // Functions used locally in dataview.mm
  89 // ============================================================================
  90 static NSInteger CompareItems(id item1, id item2, void* context)
  91 {
  92   NSArray* const sortDescriptors = (NSArray*) context;
  93
  94   NSUInteger const noOfDescriptors = [sortDescriptors count];
  95
  96   NSInteger result(NSOrderedAscending);
  97
  98
  99   for (NSUInteger i=0; i<noOfDescriptors; ++i)
 100   {
 101    // constant definition for abbreviational purposes:
 102     wxSortDescriptorObject* const sortDescriptor = (wxSortDescriptorObject*)[sortDescriptors objectAtIndex:i];
 103
 104     int wxComparisonResult;
 105
 106     wxComparisonResult = [sortDescriptor modelPtr]->Compare(wxDataViewItem([((wxPointerObject*) item1) pointer]),
 107                                                             wxDataViewItem([((wxPointerObject*) item2) pointer]),
 108                                                             [sortDescriptor columnPtr]->GetModelColumn(),
 109                                                             [sortDescriptor ascending] == YES);
 110     if (wxComparisonResult < 0)
 111     {
 112       result = NSOrderedAscending;
 113       break;
 114     }
 115     else if (wxComparisonResult > 0)
 116     {
 117       result = NSOrderedDescending;
 118       break;
 119     }
 120     else
 121       result = NSOrderedSame;
 122   }
 123   return result;
 124 }
 125
 126 static NSTextAlignment ConvertToNativeHorizontalTextAlignment(int alignment)
 127 {
 128   if (alignment & wxALIGN_CENTER_HORIZONTAL) // center alignment is chosen also if alignment is equal to -1
 129     return NSCenterTextAlignment;
 130   else if (alignment & wxALIGN_RIGHT)
 131     return NSRightTextAlignment;
 132   else
 133     return NSLeftTextAlignment;
 134 }
 135
 136 static NSTableColumn* CreateNativeColumn(wxDataViewColumn const* columnPtr)
 137 {
 138   NSTableColumn* nativeColumn([[NSTableColumn alloc] initWithIdentifier:[[[wxPointerObject alloc] initWithPointer:const_cast<wxDataViewColumn*>(columnPtr)] autorelease]]);
 139
 140
 141  // initialize the native column:
 142   if ((nativeColumn != NULL) && (columnPtr->GetRenderer() != NULL))
 143   {
 144    // setting the size related parameters:
 145     if (columnPtr->IsResizeable())
 146     {
 147       [nativeColumn setResizingMask:NSTableColumnUserResizingMask];
 148       [nativeColumn setMinWidth:columnPtr->GetMinWidth()];
 149       [nativeColumn setMaxWidth:columnPtr->GetMaxWidth()];
 150     }
 151     else
 152     {
 153       [nativeColumn setResizingMask:NSTableColumnNoResizing];
 154       [nativeColumn setMinWidth:columnPtr->GetWidth()];
 155       [nativeColumn setMaxWidth:columnPtr->GetWidth()];
 156     }
 157     [nativeColumn setWidth:columnPtr->GetWidth()];
 158 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
 159    // setting the visibility:
 160     [nativeColumn setHidden:static_cast<BOOL>(columnPtr->IsHidden())];
 161 #endif
 162
 163     wxDataViewRendererNativeData * const
 164         renderData = columnPtr->GetRenderer()->GetNativeData();
 165
 166    // setting the header:
 167     [[nativeColumn headerCell] setAlignment:ConvertToNativeHorizontalTextAlignment(columnPtr->GetAlignment())];
 168     [[nativeColumn headerCell] setStringValue:[[wxCFStringRef(columnPtr->GetTitle()).AsNSString() retain] autorelease]];
 169     renderData->ApplyLineBreakMode([nativeColumn headerCell]);
 170
 171    // setting data cell's properties:
 172     [[nativeColumn dataCell] setWraps:NO];
 173    // setting the default data cell:
 174     [nativeColumn setDataCell:renderData->GetColumnCell()];
 175    // setting the editablility:
 176     bool const dataCellIsEditable = (columnPtr->GetRenderer()->GetMode() == wxDATAVIEW_CELL_EDITABLE);
 177
 178      [nativeColumn           setEditable:dataCellIsEditable];
 179     [[nativeColumn dataCell] setEditable:dataCellIsEditable];
 180   }
 181  // done:
 182   return nativeColumn;
 183 }
 184
 185 // ============================================================================
 186 // Public helper functions for dataview implementation on OSX
 187 // ============================================================================
 188 wxWidgetImplType* CreateDataView(wxWindowMac* wxpeer, wxWindowMac* WXUNUSED(parent),  wxWindowID WXUNUSED(id), wxPoint const& pos, wxSize const& size,
 189                                  long style, long WXUNUSED(extraStyle))
 190 {
 191   return new wxCocoaDataViewControl(wxpeer,pos,size,style);
 192 }
 193
 194 // ============================================================================
 195 // wxPointerObject
 196 // ============================================================================
 197 //
 198 // This is a helper class to store a pointer in an object.
 199 //
 200 @implementation wxPointerObject
 201 //
 202 // object initialization
 203 //
 204 -(id) init
 205 {
 206   self = [super init];
 207   if (self != nil)
 208     self->pointer = NULL;
 209   return self;
 210 }
 211
 212 -(id) initWithPointer:(void*) initPointer
 213 {
 214   self = [super init];
 215   if (self != nil)
 216     self->pointer = initPointer;
 217   return self;
 218 }
 219
 220 //
 221 // inherited methods from NSObject
 222 //
 223 -(BOOL) isEqual:(id)object
 224 {
 225   return (object != nil) && ([object isKindOfClass:[wxPointerObject class]]) && (pointer == [((wxPointerObject*) object) pointer]);
 226 }
 227
 228 -(NSUInteger) hash
 229 {
 230   return (NSUInteger) pointer;
 231 }
 232
 233 //
 234 // access to pointer
 235 //
 236 -(void*) pointer
 237 {
 238   return pointer;
 239 }
 240
 241 -(void) setPointer:(void*) newPointer
 242 {
 243   pointer = newPointer;
 244 }
 245
 246 @end
 247
 248 // ============================================================================
 249 // wxSortDescriptorObject
 250 // ============================================================================
 251 @implementation wxSortDescriptorObject
 252 //
 253 // initialization
 254 //
 255 -(id) init
 256 {
 257   self = [super init];
 258   if (self != nil)
 259   {
 260     columnPtr = NULL;
 261     modelPtr  = NULL;
 262   }
 263   return self;
 264 }
 265
 266 -(id) initWithModelPtr:(wxDataViewModel*)initModelPtr sortingColumnPtr:(wxDataViewColumn*)initColumnPtr ascending:(BOOL)sortAscending
 267 {
 268   self = [super initWithKey:@"dummy" ascending:sortAscending];
 269   if (self != nil)
 270   {
 271     columnPtr = initColumnPtr;
 272     modelPtr  = initModelPtr;
 273   }
 274   return self;
 275 }
 276
 277 -(id) copyWithZone:(NSZone*)zone
 278 {
 279   wxSortDescriptorObject* copy;
 280
 281
 282   copy = [super copyWithZone:zone];
 283   copy->columnPtr = columnPtr;
 284   copy->modelPtr  = modelPtr;
 285
 286   return copy;
 287 }
 288
 289 //
 290 // access to model column's index
 291 //
 292 -(wxDataViewColumn*) columnPtr
 293 {
 294   return columnPtr;
 295 }
 296
 297 -(wxDataViewModel*) modelPtr
 298 {
 299   return modelPtr;
 300 }
 301
 302 -(void) setColumnPtr:(wxDataViewColumn*)newColumnPtr
 303 {
 304   columnPtr = newColumnPtr;
 305 }
 306
 307 -(void) setModelPtr:(wxDataViewModel*)newModelPtr
 308 {
 309   modelPtr = newModelPtr;
 310 }
 311
 312 @end
 313
 314 // ============================================================================
 315 // wxCocoaOutlineDataSource
 316 // ============================================================================
 317 @implementation wxCocoaOutlineDataSource
 318
 319 //
 320 // constructors / destructor
 321 //
 322 -(id) init
 323 {
 324   self = [super init];
 325   if (self != nil)
 326   {
 327     implementation = NULL;
 328     model          = NULL;
 329
 330     currentParentItem = nil;
 331
 332     children = [[NSMutableArray alloc] init];
 333     items    = [[NSMutableSet   alloc] init];
 334   }
 335   return self;
 336 }
 337
 338 -(void) dealloc
 339 {
 340   [currentParentItem release];
 341
 342   [children release];
 343   [items    release];
 344
 345   [super dealloc];
 346 }
 347
 348 //
 349 // methods of informal protocol:
 350 //
 351 -(BOOL) outlineView:(NSOutlineView*)outlineView acceptDrop:(id<NSDraggingInfo>)info item:(id)item childIndex:(NSInteger)index
 352 {
 353   bool dragSuccessful;
 354
 355   NSArray* supportedTypes([NSArray arrayWithObjects:DataViewPboardType,NSStringPboardType,nil]);
 356
 357   NSPasteboard* pasteboard([info draggingPasteboard]);
 358
 359   NSString* bestType([pasteboard availableTypeFromArray:supportedTypes]);
 360
 361
 362   if (bestType != nil)
 363   {
 364     wxDataViewCtrl* const  dataViewCtrlPtr(implementation->GetDataViewCtrl());
 365
 366     wxCHECK_MSG(dataViewCtrlPtr != NULL,            false,_("Pointer to data view control not set correctly."));
 367     wxCHECK_MSG(dataViewCtrlPtr->GetModel() != NULL,false,_("Pointer to model not set correctly."));
 368   // create wxWidget's event:
 369     wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_DROP,dataViewCtrlPtr->GetId());
 370
 371     dataViewEvent.SetEventObject(dataViewCtrlPtr);
 372     dataViewEvent.SetItem(wxDataViewItem([((wxPointerObject*) item) pointer]));
 373     dataViewEvent.SetModel(dataViewCtrlPtr->GetModel());
 374     if ([bestType compare:DataViewPboardType] == NSOrderedSame)
 375     {
 376       NSArray*   dataArray((NSArray*)[pasteboard propertyListForType:DataViewPboardType]);
 377       NSUInteger indexDraggedItem, noOfDraggedItems([dataArray count]);
 378
 379       indexDraggedItem = 0;
 380       while (indexDraggedItem < noOfDraggedItems)
 381       {
 382         wxDataObjectComposite* dataObjects(implementation->GetDnDDataObjects((NSData*)[dataArray objectAtIndex:indexDraggedItem]));
 383
 384         if ((dataObjects != NULL) && (dataObjects->GetFormatCount() > 0))
 385         {
 386           wxMemoryBuffer buffer;
 387
 388          // copy data into data object:
 389           dataViewEvent.SetDataObject(dataObjects);
 390           dataViewEvent.SetDataFormat(implementation->GetDnDDataFormat(dataObjects));
 391          // copy data into buffer:
 392           dataObjects->GetDataHere(dataViewEvent.GetDataFormat().GetType(),buffer.GetWriteBuf(dataViewEvent.GetDataSize()));
 393           buffer.UngetWriteBuf(dataViewEvent.GetDataSize());
 394           dataViewEvent.SetDataBuffer(buffer.GetData());
 395          // finally, send event:
 396           if (dataViewCtrlPtr->HandleWindowEvent(dataViewEvent) && dataViewEvent.IsAllowed())
 397           {
 398             dragSuccessful = true;
 399             ++indexDraggedItem;
 400           }
 401           else
 402           {
 403             dragSuccessful   = true;
 404             indexDraggedItem = noOfDraggedItems; // stop loop
 405           }
 406         }
 407         else
 408         {
 409           dragSuccessful   = false;
 410           indexDraggedItem = noOfDraggedItems; // stop loop
 411         }
 412        // clean-up:
 413         delete dataObjects;
 414       }
 415     }
 416     else
 417     {
 418       CFDataRef              osxData; // needed to convert internally used UTF-16 representation to a UTF-8 representation
 419       wxDataObjectComposite* dataObjects   (new wxDataObjectComposite());
 420       wxTextDataObject*      textDataObject(new wxTextDataObject());
 421
 422       osxData = ::CFStringCreateExternalRepresentation(kCFAllocatorDefault,(CFStringRef)[pasteboard stringForType:NSStringPboardType],kCFStringEncodingUTF8,32);
 423       if (textDataObject->SetData(::CFDataGetLength(osxData),::CFDataGetBytePtr(osxData)))
 424         dataObjects->Add(textDataObject);
 425       else
 426         delete textDataObject;
 427      // send event if data could be copied:
 428       if (dataObjects->GetFormatCount() > 0)
 429       {
 430         dataViewEvent.SetDataObject(dataObjects);
 431         dataViewEvent.SetDataFormat(implementation->GetDnDDataFormat(dataObjects));
 432         if (dataViewCtrlPtr->HandleWindowEvent(dataViewEvent) && dataViewEvent.IsAllowed())
 433           dragSuccessful = true;
 434         else
 435           dragSuccessful = false;
 436       }
 437       else
 438         dragSuccessful = false;
 439      // clean up:
 440       ::CFRelease(osxData);
 441       delete dataObjects;
 442     }
 443   }
 444   else
 445     dragSuccessful = false;
 446   return dragSuccessful;
 447 }
 448
 449 -(id) outlineView:(NSOutlineView*)outlineView child:(NSInteger)index ofItem:(id)item
 450 {
 451   if ((item == currentParentItem) && (index < ((NSInteger) [self getChildCount])))
 452     return [self getChild:index];
 453   else
 454   {
 455     wxDataViewItemArray dataViewChildren;
 456
 457     wxCHECK_MSG(model != NULL,0,_("Valid model in data source does not exist."));
 458     (void) model->GetChildren((item == nil) ? wxDataViewItem() : wxDataViewItem([((wxPointerObject*) item) pointer]),dataViewChildren);
 459     [self bufferItem:item withChildren:&dataViewChildren];
 460     if ([sortDescriptors count] > 0)
 461       [children sortUsingFunction:CompareItems context:sortDescriptors];
 462     return [self getChild:index];
 463   }
 464 }
 465
 466 -(BOOL) outlineView:(NSOutlineView*)outlineView isItemExpandable:(id)item
 467 {
 468   wxCHECK_MSG(model != NULL,0,_("Valid model in data source does not exist."));
 469   return model->IsContainer(wxDataViewItem([((wxPointerObject*) item) pointer]));
 470 }
 471
 472 -(NSInteger) outlineView:(NSOutlineView*)outlineView numberOfChildrenOfItem:(id)item
 473 {
 474   NSInteger noOfChildren;
 475
 476   wxDataViewItemArray dataViewChildren;
 477
 478
 479   wxCHECK_MSG(model != NULL,0,_("Valid model in data source does not exist."));
 480   noOfChildren = model->GetChildren((item == nil) ? wxDataViewItem() : wxDataViewItem([((wxPointerObject*) item) pointer]),dataViewChildren);
 481   [self bufferItem:item withChildren:&dataViewChildren];
 482   if ([sortDescriptors count] > 0)
 483     [children sortUsingFunction:CompareItems context:sortDescriptors];
 484   return noOfChildren;
 485 }
 486
 487 -(id) outlineView:(NSOutlineView*)outlineView objectValueForTableColumn:(NSTableColumn*)tableColumn byItem:(id)item
 488 {
 489   wxDataViewColumn* dataViewColumnPtr(reinterpret_cast<wxDataViewColumn*>([[tableColumn identifier] pointer]));
 490
 491   wxDataViewItem dataViewItem([((wxPointerObject*) item) pointer]);
 492
 493   wxVariant value;
 494
 495
 496   wxCHECK_MSG(model != NULL,0,_("Valid model in data source does not exist."));
 497   model->GetValue(value,dataViewItem,dataViewColumnPtr->GetModelColumn());
 498   dataViewColumnPtr->GetRenderer()->SetValue(value);
 499   return nil;
 500 }
 501
 502 -(void) outlineView:(NSOutlineView*)outlineView setObjectValue:(id)object forTableColumn:(NSTableColumn*)tableColumn byItem:(id)item
 503 {
 504   wxDataViewColumn* dataViewColumnPtr(reinterpret_cast<wxDataViewColumn*>([[tableColumn identifier] pointer]));
 505
 506   wxDataViewItem dataViewItem([((wxPointerObject*) item) pointer]);
 507
 508
 509   if (((dynamic_cast<wxDataViewTextRenderer*>(dataViewColumnPtr->GetRenderer()) != NULL) || (dynamic_cast<wxDataViewIconTextRenderer*>(dataViewColumnPtr->GetRenderer()) != NULL)) &&
 510       ([object isKindOfClass:[NSString class]] == YES))
 511   {
 512     model->SetValue(wxVariant(wxCFStringRef([((NSString*) object) retain]).AsString()),dataViewItem,dataViewColumnPtr->GetModelColumn()); // the string has to be retained before being passed to wxCFStringRef
 513     model->ValueChanged(dataViewItem,dataViewColumnPtr->GetModelColumn());
 514   }
 515   else if (dynamic_cast<wxDataViewChoiceRenderer*>(dataViewColumnPtr->GetRenderer()) != NULL)
 516   {
 517     if ([object isKindOfClass:[NSNumber class]] == YES)
 518     {
 519       model->SetValue(wxVariant(dynamic_cast<wxDataViewChoiceRenderer*>(dataViewColumnPtr->GetRenderer())->GetChoice([((NSNumber*) object) intValue])),
 520                       dataViewItem,dataViewColumnPtr->GetModelColumn());
 521       model->ValueChanged(dataViewItem,dataViewColumnPtr->GetModelColumn());
 522     }
 523     else if ([object isKindOfClass:[NSString class]] == YES) // do not know if this case can occur but initializing using strings works
 524     {
 525       model->SetValue(wxVariant(wxCFStringRef((NSString*) object).AsString()),dataViewItem,dataViewColumnPtr->GetModelColumn());
 526       model->ValueChanged(dataViewItem,dataViewColumnPtr->GetModelColumn());
 527     }
 528   }
 529   else if ((dynamic_cast<wxDataViewDateRenderer*>(dataViewColumnPtr->GetRenderer()) != NULL) && ([object isKindOfClass:[NSDate class]] == YES))
 530   {
 531     wxDateTime wxDateTimeValue(1,wxDateTime::Jan,1970);
 532
 533     wxLongLong seconds;
 534
 535     seconds.Assign([((NSDate*) object) timeIntervalSince1970]); // get the number of seconds since 1970-01-01 UTC and this is
 536                                                                 // the only way to convert a double to a wxLongLong
 537    // the user has entered a date in the local timezone but seconds contains the number of seconds from date in the local timezone since 1970-01-01 UTC;
 538    // therefore, the timezone information has to be transferred to wxWidgets, too:
 539     wxDateTimeValue.Add(wxTimeSpan(0,0,seconds));
 540     wxDateTimeValue.MakeFromTimezone(wxDateTime::UTC);
 541     model->SetValue(wxVariant(wxDateTimeValue),dataViewItem,dataViewColumnPtr->GetModelColumn());
 542     model->ValueChanged(dataViewItem,dataViewColumnPtr->GetModelColumn());
 543   }
 544   else if ((dynamic_cast<wxDataViewToggleRenderer*>(dataViewColumnPtr->GetRenderer()) != NULL) && ([object isKindOfClass:[NSNumber class]] == YES))
 545   {
 546     model->SetValue(wxVariant((bool) [((NSNumber*) object) boolValue]),dataViewItem,dataViewColumnPtr->GetModelColumn());
 547     model->ValueChanged(dataViewItem,dataViewColumnPtr->GetModelColumn());
 548   }
 549 }
 550
 551 -(void) outlineView:(NSOutlineView*)outlineView sortDescriptorsDidChange:(NSArray*)oldDescriptors
 552  // Warning: the new sort descriptors are guaranteed to be only of type NSSortDescriptor! Therefore, the
 553  // sort descriptors for the data source have to be converted.
 554 {
 555   NSArray* newDescriptors;
 556
 557   NSMutableArray* wxSortDescriptors;
 558
 559   NSUInteger noOfDescriptors;
 560
 561   wxDataViewCtrl* const dataViewCtrlPtr = implementation->GetDataViewCtrl();
 562
 563
 564  // convert NSSortDescriptors to wxSortDescriptorObjects:
 565   newDescriptors    = [outlineView sortDescriptors];
 566   noOfDescriptors   = [newDescriptors count];
 567   wxSortDescriptors = [NSMutableArray arrayWithCapacity:noOfDescriptors];
 568   for (NSUInteger i=0; i<noOfDescriptors; ++i)
 569   {
 570    // constant definition for abbreviational purposes:
 571     NSSortDescriptor* const newDescriptor = [newDescriptors objectAtIndex:i];
 572
 573     [wxSortDescriptors addObject:[[[wxSortDescriptorObject alloc] initWithModelPtr:model
 574                                                                   sortingColumnPtr:dataViewCtrlPtr->GetColumn([[newDescriptor key] intValue])
 575                                                                          ascending:[newDescriptor ascending]] autorelease]];
 576   }
 577   [[outlineView dataSource] setSortDescriptors:wxSortDescriptors];
 578
 579  // send first the event to wxWidgets that the sorting has changed so that the program can do special actions before
 580  // the sorting actually starts:
 581   wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_SORTED,dataViewCtrlPtr->GetId()); // variable defintion
 582
 583   dataViewEvent.SetEventObject(dataViewCtrlPtr);
 584   if (noOfDescriptors > 0)
 585   {
 586    // constant definition for abbreviational purposes:
 587     wxDataViewColumn* const dataViewColumnPtr = [[wxSortDescriptors objectAtIndex:0] columnPtr];
 588
 589     dataViewEvent.SetColumn(dataViewCtrlPtr->GetColumnPosition(dataViewColumnPtr));
 590     dataViewEvent.SetDataViewColumn(dataViewColumnPtr);
 591   }
 592   dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
 593
 594  // start re-ordering the data;
 595  // children's buffer must be cleared first because it contains the old order:
 596   [self clearChildren];
 597  // sorting is done while reloading the data:
 598   [outlineView reloadData];
 599 }
 600
 601 -(NSDragOperation) outlineView:(NSOutlineView*)outlineView validateDrop:(id<NSDraggingInfo>)info proposedItem:(id)item proposedChildIndex:(NSInteger)index
 602 {
 603   NSArray* supportedTypes([NSArray arrayWithObjects:DataViewPboardType,NSStringPboardType,nil]);
 604
 605   NSDragOperation dragOperation;
 606
 607   NSPasteboard* pasteboard([info draggingPasteboard]);
 608
 609   NSString* bestType([pasteboard availableTypeFromArray:supportedTypes]);
 610
 611
 612   if (bestType != nil)
 613   {
 614     wxDataViewCtrl* const  dataViewCtrlPtr(implementation->GetDataViewCtrl());
 615
 616     wxCHECK_MSG(dataViewCtrlPtr != NULL,            false,_("Pointer to data view control not set correctly."));
 617     wxCHECK_MSG(dataViewCtrlPtr->GetModel() != NULL,false,_("Pointer to model not set correctly."));
 618   // create wxWidget's event:
 619     wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_DROP_POSSIBLE,dataViewCtrlPtr->GetId());
 620
 621     dataViewEvent.SetEventObject(dataViewCtrlPtr);
 622     dataViewEvent.SetItem(wxDataViewItem([((wxPointerObject*) item) pointer]));
 623     dataViewEvent.SetModel(dataViewCtrlPtr->GetModel());
 624     if ([bestType compare:DataViewPboardType] == NSOrderedSame)
 625     {
 626       NSArray*               dataArray((NSArray*)[pasteboard propertyListForType:DataViewPboardType]);
 627       NSUInteger             indexDraggedItem, noOfDraggedItems([dataArray count]);
 628
 629       indexDraggedItem = 0;
 630       while (indexDraggedItem < noOfDraggedItems)
 631       {
 632         wxDataObjectComposite* dataObjects(implementation->GetDnDDataObjects((NSData*)[dataArray objectAtIndex:indexDraggedItem]));
 633
 634         if ((dataObjects != NULL) && (dataObjects->GetFormatCount() > 0))
 635         {
 636           wxMemoryBuffer buffer;
 637
 638          // copy data into data object:
 639           dataViewEvent.SetDataObject(dataObjects);
 640           dataViewEvent.SetDataFormat(implementation->GetDnDDataFormat(dataObjects));
 641          // copy data into buffer:
 642           dataObjects->GetDataHere(dataViewEvent.GetDataFormat().GetType(),buffer.GetWriteBuf(dataViewEvent.GetDataSize()));
 643           buffer.UngetWriteBuf(dataViewEvent.GetDataSize());
 644           dataViewEvent.SetDataBuffer(buffer.GetData());
 645          // finally, send event:
 646           if (dataViewCtrlPtr->HandleWindowEvent(dataViewEvent) && dataViewEvent.IsAllowed())
 647           {
 648             dragOperation = NSDragOperationEvery;
 649             ++indexDraggedItem;
 650           }
 651           else
 652           {
 653             dragOperation    = NSDragOperationNone;
 654             indexDraggedItem = noOfDraggedItems; // stop loop
 655           }
 656         }
 657         else
 658         {
 659           dragOperation    = NSDragOperationNone;
 660           indexDraggedItem = noOfDraggedItems; // stop loop
 661         }
 662        // clean-up:
 663         delete dataObjects;
 664       }
 665     }
 666     else
 667     {
 668       CFDataRef              osxData; // needed to convert internally used UTF-16 representation to a UTF-8 representation
 669       wxDataObjectComposite* dataObjects   (new wxDataObjectComposite());
 670       wxTextDataObject*      textDataObject(new wxTextDataObject());
 671
 672       osxData = ::CFStringCreateExternalRepresentation(kCFAllocatorDefault,(CFStringRef)[pasteboard stringForType:NSStringPboardType],kCFStringEncodingUTF8,32);
 673       if (textDataObject->SetData(::CFDataGetLength(osxData),::CFDataGetBytePtr(osxData)))
 674         dataObjects->Add(textDataObject);
 675       else
 676         delete textDataObject;
 677      // send event if data could be copied:
 678       if (dataObjects->GetFormatCount() > 0)
 679       {
 680         dataViewEvent.SetDataObject(dataObjects);
 681         dataViewEvent.SetDataFormat(implementation->GetDnDDataFormat(dataObjects));
 682         if (dataViewCtrlPtr->HandleWindowEvent(dataViewEvent) && dataViewEvent.IsAllowed())
 683           dragOperation = NSDragOperationEvery;
 684         else
 685           dragOperation = NSDragOperationNone;
 686       }
 687       else
 688         dragOperation = NSDragOperationNone;
 689      // clean up:
 690       ::CFRelease(osxData);
 691       delete dataObjects;
 692     }
 693   }
 694   else
 695     dragOperation = NSDragOperationNone;
 696   return dragOperation;
 697 }
 698
 699 -(BOOL) outlineView:(NSOutlineView*)outlineView writeItems:(NSArray*)writeItems toPasteboard:(NSPasteboard*)pasteboard
 700  // the pasteboard will be filled up with an array containing the data as returned by the events (including the data type)
 701  // and a concatenation of text (string) data; the text data will only be put onto the pasteboard if for all items a
 702  // string representation exists
 703 {
 704   wxDataViewCtrl* const dataViewCtrlPtr = implementation->GetDataViewCtrl();
 705
 706   wxDataViewItemArray dataViewItems;
 707
 708
 709   wxCHECK_MSG(dataViewCtrlPtr != NULL,            false,_("Pointer to data view control not set correctly."));
 710   wxCHECK_MSG(dataViewCtrlPtr->GetModel() != NULL,false,_("Pointer to model not set correctly."));
 711
 712   if ([writeItems count] > 0)
 713   {
 714     bool            dataStringAvailable(true); // a flag indicating if for all items a data string is available
 715     NSMutableArray* dataArray = [[NSMutableArray arrayWithCapacity:[writeItems count]] retain]; // data of all items
 716     wxString        dataString; // contains the string data of all items
 717
 718    // send a begin drag event for all selected items and proceed with dragging unless the event is vetoed:
 719     wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_BEGIN_DRAG,dataViewCtrlPtr->GetId());
 720
 721     dataViewEvent.SetEventObject(dataViewCtrlPtr);
 722     dataViewEvent.SetModel(dataViewCtrlPtr->GetModel());
 723     for (size_t itemCounter=0; itemCounter<[writeItems count]; ++itemCounter)
 724     {
 725       bool                   itemStringAvailable(false);              // a flag indicating if for the current item a string is available
 726       wxDataObjectComposite* itemObject(new wxDataObjectComposite()); // data object for current item
 727       wxString               itemString;                              // contains the TAB concatenated data of an item
 728
 729       dataViewEvent.SetItem(wxDataViewItem([((wxPointerObject*) [writeItems objectAtIndex:itemCounter]) pointer]));
 730       itemString = ::ConcatenateDataViewItemValues(dataViewCtrlPtr,dataViewEvent.GetItem());
 731       itemObject->Add(new wxTextDataObject(itemString));
 732       dataViewEvent.SetDataObject(itemObject);
 733      // check if event has not been vetoed:
 734       if (dataViewCtrlPtr->HandleWindowEvent(dataViewEvent) && dataViewEvent.IsAllowed() && (dataViewEvent.GetDataObject()->GetFormatCount() > 0))
 735       {
 736        // constant definition for abbreviational purposes:
 737         size_t const noOfFormats = dataViewEvent.GetDataObject()->GetFormatCount();
 738        // variable definition and initialization:
 739         wxDataFormat* dataFormats(new wxDataFormat[noOfFormats]);
 740
 741         dataViewEvent.GetDataObject()->GetAllFormats(dataFormats,wxDataObject::Get);
 742         for (size_t formatCounter=0; formatCounter<noOfFormats; ++formatCounter)
 743         {
 744          // constant definitions for abbreviational purposes:
 745           wxDataFormatId const idDataFormat = dataFormats[formatCounter].GetType();
 746           size_t const dataSize       = dataViewEvent.GetDataObject()->GetDataSize(idDataFormat);
 747           size_t const dataBufferSize = sizeof(wxDataFormatId)+dataSize;
 748          // variable definitions (used in all case statements):
 749           wxMemoryBuffer dataBuffer(dataBufferSize);
 750
 751           dataBuffer.AppendData(&idDataFormat,sizeof(wxDataFormatId));
 752           switch (idDataFormat)
 753           {
 754             case wxDF_TEXT:
 755               if (!itemStringAvailable) // otherwise wxDF_UNICODETEXT already filled up the string; and the UNICODE representation has priority
 756               {
 757                 dataViewEvent.GetDataObject()->GetDataHere(wxDF_TEXT,dataBuffer.GetAppendBuf(dataSize));
 758                 dataBuffer.UngetAppendBuf(dataSize);
 759                 [dataArray addObject:[NSData dataWithBytes:dataBuffer.GetData() length:dataBufferSize]];
 760                 itemString = wxString(reinterpret_cast<char const*>(dataBuffer.GetData())+sizeof(wxDataFormatId),wxConvLocal);
 761                 itemStringAvailable = true;
 762               }
 763               break;
 764             case wxDF_UNICODETEXT:
 765               {
 766                 dataViewEvent.GetDataObject()->GetDataHere(wxDF_UNICODETEXT,dataBuffer.GetAppendBuf(dataSize));
 767                 dataBuffer.UngetAppendBuf(dataSize);
 768                 if (itemStringAvailable) // does an object already exist as an ASCII text (see wxDF_TEXT case statement)?
 769                   [dataArray replaceObjectAtIndex:itemCounter withObject:[NSData dataWithBytes:dataBuffer.GetData() length:dataBufferSize]];
 770                 else
 771                   [dataArray addObject:[NSData dataWithBytes:dataBuffer.GetData() length:dataBufferSize]];
 772                 itemString = wxString::FromUTF8(reinterpret_cast<char const*>(dataBuffer.GetData())+sizeof(wxDataFormatId),dataSize);
 773                 itemStringAvailable = true;
 774               } /* block */
 775               break;
 776             default:
 777               wxFAIL_MSG(_("Data object has invalid or unsupported data format"));
 778               [dataArray release];
 779               return NO;
 780           }
 781         }
 782         delete[] dataFormats;
 783         delete itemObject;
 784         if (dataStringAvailable)
 785           if (itemStringAvailable)
 786           {
 787             if (itemCounter > 0)
 788               dataString << wxT('\n');
 789             dataString << itemString;
 790           }
 791           else
 792             dataStringAvailable = false;
 793       }
 794       else
 795       {
 796         [dataArray release];
 797         delete itemObject;
 798         return NO; // dragging was vetoed or no data available
 799       }
 800     }
 801     if (dataStringAvailable)
 802     {
 803       wxCFStringRef osxString(dataString);
 804
 805       [pasteboard declareTypes:[NSArray arrayWithObjects:DataViewPboardType,NSStringPboardType,nil] owner:nil];
 806       [pasteboard setPropertyList:dataArray forType:DataViewPboardType];
 807       [pasteboard setString:osxString.AsNSString() forType:NSStringPboardType];
 808     }
 809     else
 810     {
 811       [pasteboard declareTypes:[NSArray arrayWithObject:DataViewPboardType] owner:nil];
 812       [pasteboard setPropertyList:dataArray forType:DataViewPboardType];
 813     }
 814     return YES;
 815   }
 816   else
 817     return NO; // no items to drag (should never occur)
 818 }
 819
 820 //
 821 // buffer handling
 822 //
 823 -(void) addToBuffer:(wxPointerObject*)item
 824 {
 825   [items addObject:item];
 826 }
 827
 828 -(void) clearBuffer
 829 {
 830   [items removeAllObjects];
 831 }
 832
 833 -(wxPointerObject*) getDataViewItemFromBuffer:(wxDataViewItem const&)item
 834 {
 835   return [items member:[[[wxPointerObject alloc] initWithPointer:item.GetID()] autorelease]];
 836 }
 837
 838 -(wxPointerObject*) getItemFromBuffer:(wxPointerObject*)item
 839 {
 840   return [items member:item];
 841 }
 842
 843 -(BOOL) isInBuffer:(wxPointerObject*)item
 844 {
 845   return [items containsObject:item];
 846 }
 847
 848 -(void) removeFromBuffer:(wxPointerObject*)item
 849 {
 850   [items removeObject:item];
 851 }
 852
 853 //
 854 // children handling
 855 //
 856 -(void) appendChild:(wxPointerObject*)item
 857 {
 858   [children addObject:item];
 859 }
 860
 861 -(void) clearChildren
 862 {
 863   [children removeAllObjects];
 864 }
 865
 866 -(wxPointerObject*) getChild:(NSUInteger)index
 867 {
 868   return [children objectAtIndex:index];
 869 }
 870
 871 -(NSUInteger) getChildCount
 872 {
 873   return [children count];
 874 }
 875
 876 -(void) removeChild:(NSUInteger)index
 877 {
 878   [children removeObjectAtIndex:index];
 879 }
 880
 881 //
 882 // buffer handling
 883 //
 884 -(void) clearBuffers
 885 {
 886   [self clearBuffer];
 887   [self clearChildren];
 888   [self setCurrentParentItem:nil];
 889 }
 890
 891 //
 892 // sorting
 893 //
 894 -(NSArray*) sortDescriptors
 895 {
 896   return sortDescriptors;
 897 }
 898
 899 -(void) setSortDescriptors:(NSArray*)newSortDescriptors
 900 {
 901   [newSortDescriptors retain];
 902   [sortDescriptors release];
 903   sortDescriptors = newSortDescriptors;
 904 }
 905
 906 //
 907 // access to wxWidget's implementation
 908 //
 909 -(wxPointerObject*) currentParentItem
 910 {
 911   return currentParentItem;
 912 }
 913
 914 -(wxCocoaDataViewControl*) implementation
 915 {
 916   return implementation;
 917 }
 918
 919 -(wxDataViewModel*) model
 920 {
 921   return model;
 922 }
 923
 924 -(void) setCurrentParentItem:(wxPointerObject*)newCurrentParentItem
 925 {
 926   [newCurrentParentItem retain];
 927   [currentParentItem release];
 928   currentParentItem = newCurrentParentItem;
 929 }
 930
 931 -(void) setImplementation:(wxCocoaDataViewControl*) newImplementation
 932 {
 933   implementation = newImplementation;
 934 }
 935
 936 -(void) setModel:(wxDataViewModel*) newModel
 937 {
 938   model = newModel;
 939 }
 940
 941 //
 942 // other methods
 943 //
 944 -(void) bufferItem:(wxPointerObject*)parentItem withChildren:(wxDataViewItemArray*)dataViewChildrenPtr
 945 {
 946   NSInteger const noOfChildren = (*dataViewChildrenPtr).GetCount();
 947
 948   [self setCurrentParentItem:parentItem];
 949   [self clearChildren];
 950   for (NSInteger indexChild=0; indexChild<noOfChildren; ++indexChild)
 951   {
 952     wxPointerObject* bufferedPointerObject;
 953     wxPointerObject* newPointerObject([[wxPointerObject alloc] initWithPointer:(*dataViewChildrenPtr)[indexChild].GetID()]);
 954
 955    // The next statement and test looks strange but there is unfortunately no workaround:
 956    // due to the fact that two pointer objects are identical if their pointers are identical - because the method isEqual
 957    // has been overloaded - the set operation will only add a new pointer object if there is not already one in the set
 958    // having the same pointer. On the other side the children's array would always add the new pointer object. This means
 959    // that different pointer objects are stored in the set and array. This will finally lead to a crash as objects diverge.
 960    // To solve this issue it is first tested if the child already exists in the set and if it is the case the sets object
 961    // is going to be appended to the array, otheriwse the new pointer object is added to the set and array:
 962     bufferedPointerObject = [self getItemFromBuffer:newPointerObject];
 963     if (bufferedPointerObject == nil)
 964     {
 965       [items    addObject:newPointerObject];
 966       [children addObject:newPointerObject];
 967     }
 968     else
 969       [children addObject:bufferedPointerObject];
 970     [newPointerObject release];
 971   }
 972 }
 973
 974 @end
 975
 976 // ============================================================================
 977 // wxCustomCell
 978 // ============================================================================
 979
 980 @implementation wxCustomCell
 981
 982 -(NSSize) cellSize
 983 {
 984     wxCustomRendererObject * const
 985         obj = static_cast<wxCustomRendererObject *>([self objectValue]);
 986
 987
 988     const wxSize size = obj->customRenderer->GetSize();
 989     return NSMakeSize(size.x, size.y);
 990 }
 991
 992 //
 993 // implementations
 994 //
 995 -(void) drawWithFrame:(NSRect)cellFrame inView:(NSView*)controlView
 996 {
 997     wxCustomRendererObject * const
 998         obj = static_cast<wxCustomRendererObject *>([self objectValue]);
 999     wxDataViewCustomRenderer * const renderer = obj->customRenderer;
1000
1001     // draw its own background:
1002     [[self backgroundColor] set];
1003     NSRectFill(cellFrame);
1004
1005     // TODO: attributes support
1006     renderer->Render(wxFromNSRect(controlView, cellFrame), renderer->GetDC(), 0);
1007     renderer->SetDC(NULL);
1008 }
1009
1010 -(NSRect) imageRectForBounds:(NSRect)cellFrame
1011 {
1012   return cellFrame;
1013 }
1014
1015 -(NSRect) titleRectForBounds:(NSRect)cellFrame
1016 {
1017    return cellFrame;
1018 }
1019
1020 @end
1021
1022 // ============================================================================
1023 // wxImageTextCell
1024 // ============================================================================
1025 @implementation wxImageTextCell
1026 //
1027 // initialization
1028 //
1029 -(id) init
1030 {
1031   self = [super init];
1032   if (self != nil)
1033   {
1034    // initializing the text part:
1035     [self setSelectable:YES];
1036    // initializing the image part:
1037     image       = nil;
1038     imageSize   = NSMakeSize(16,16);
1039     spaceImageText = 5.0;
1040     xImageShift    = 5.0;
1041   }
1042   return self;
1043 }
1044
1045 -(id) copyWithZone:(NSZone*)zone
1046 {
1047   wxImageTextCell* cell;
1048
1049
1050   cell = (wxImageTextCell*) [super copyWithZone:zone];
1051   cell->image          = [image retain];
1052   cell->imageSize      = imageSize;
1053   cell->spaceImageText = spaceImageText;
1054   cell->xImageShift    = xImageShift;
1055
1056   return cell;
1057 }
1058
1059 -(void) dealloc
1060 {
1061   [image release];
1062
1063   [super dealloc];
1064 }
1065
1066 //
1067 // alignment
1068 //
1069 -(NSTextAlignment) alignment
1070 {
1071   return cellAlignment;
1072 }
1073
1074 -(void) setAlignment:(NSTextAlignment)newAlignment
1075 {
1076   cellAlignment = newAlignment;
1077   switch (newAlignment)
1078   {
1079     case NSCenterTextAlignment:
1080     case NSLeftTextAlignment:
1081     case NSJustifiedTextAlignment:
1082     case NSNaturalTextAlignment:
1083       [super setAlignment:NSLeftTextAlignment];
1084       break;
1085     case NSRightTextAlignment:
1086       [super setAlignment:NSRightTextAlignment];
1087       break;
1088     default:
1089       wxFAIL_MSG(_("Unknown alignment type."));
1090   }
1091 }
1092
1093 //
1094 // image access
1095 //
1096 -(NSImage*) image
1097 {
1098   return image;
1099 }
1100
1101 -(void) setImage:(NSImage*)newImage
1102 {
1103   [newImage retain];
1104   [image release];
1105   image = newImage;
1106 }
1107
1108 -(NSSize) imageSize
1109 {
1110   return imageSize;
1111 }
1112
1113 -(void) setImageSize:(NSSize) newImageSize
1114 {
1115   imageSize = newImageSize;
1116 }
1117
1118 //
1119 // other methods
1120 //
1121 -(NSSize) cellImageSize
1122 {
1123   return NSMakeSize(imageSize.width+xImageShift+spaceImageText,imageSize.height);
1124 }
1125
1126 -(NSSize) cellSize
1127 {
1128   NSSize cellSize([super cellSize]);
1129
1130
1131   if (imageSize.height > cellSize.height)
1132     cellSize.height = imageSize.height;
1133   cellSize.width += imageSize.width+xImageShift+spaceImageText;
1134
1135   return cellSize;
1136 }
1137
1138 -(NSSize) cellTextSize
1139 {
1140   return [super cellSize];
1141 }
1142
1143 //
1144 // implementations
1145 //
1146 -(void) determineCellParts:(NSRect)cellFrame imagePart:(NSRect*)imageFrame textPart:(NSRect*)textFrame
1147 {
1148   switch (cellAlignment)
1149   {
1150     case NSCenterTextAlignment:
1151       {
1152         CGFloat const cellSpace = cellFrame.size.width-[self cellSize].width;
1153
1154         if (cellSpace <= 0) // if the cell's frame is smaller than its contents (at least in x-direction) make sure that the image is visible:
1155           NSDivideRect(cellFrame,imageFrame,textFrame,xImageShift+imageSize.width+spaceImageText,NSMinXEdge);
1156         else // otherwise center the image and text in the cell's frame
1157           NSDivideRect(cellFrame,imageFrame,textFrame,xImageShift+imageSize.width+spaceImageText+0.5*cellSpace,NSMinXEdge);
1158       }
1159       break;
1160     case NSJustifiedTextAlignment:
1161     case NSLeftTextAlignment:
1162     case NSNaturalTextAlignment: // how to determine the natural writing direction? TODO
1163       NSDivideRect(cellFrame,imageFrame,textFrame,xImageShift+imageSize.width+spaceImageText,NSMinXEdge);
1164       break;
1165     case NSRightTextAlignment:
1166       {
1167         CGFloat const cellSpace = cellFrame.size.width-[self cellSize].width;
1168
1169         if (cellSpace <= 0) // if the cell's frame is smaller than its contents (at least in x-direction) make sure that the image is visible:
1170           NSDivideRect(cellFrame,imageFrame,textFrame,xImageShift+imageSize.width+spaceImageText,NSMinXEdge);
1171         else // otherwise right align the image and text in the cell's frame
1172           NSDivideRect(cellFrame,imageFrame,textFrame,xImageShift+imageSize.width+spaceImageText+cellSpace,NSMinXEdge);
1173       }
1174       break;
1175     default:
1176       *imageFrame = NSZeroRect;
1177       *textFrame  = NSZeroRect;
1178       wxFAIL_MSG(_("Unhandled alignment type."));
1179   }
1180 }
1181
1182 -(void) drawWithFrame:(NSRect)cellFrame inView:(NSView*)controlView
1183 {
1184   NSRect textFrame, imageFrame;
1185
1186
1187   [self determineCellParts:cellFrame imagePart:&imageFrame textPart:&textFrame];
1188 // draw the image part by ourselves;
1189  // check if the cell has to draw its own background (checking is done by the parameter of the textfield's cell):
1190   if ([self drawsBackground])
1191   {
1192     [[self backgroundColor] set];
1193     NSRectFill(imageFrame);
1194   }
1195   if (image != nil)
1196   {
1197    // the image is slightly shifted (xImageShift) and has a fixed size but the image's frame might be larger and starts
1198    // currently on the left side of the cell's frame; therefore, the origin and the image's frame size have to be adjusted:
1199     if (imageFrame.size.width >= xImageShift+imageSize.width+spaceImageText)
1200     {
1201       imageFrame.origin.x += imageFrame.size.width-imageSize.width-spaceImageText;
1202       imageFrame.size.width = imageSize.width;
1203     }
1204     else
1205     {
1206       imageFrame.origin.x   += xImageShift;
1207       imageFrame.size.width -= xImageShift+spaceImageText;
1208     }
1209    // ...and the image has to be centered in the y-direction:
1210     if (imageFrame.size.height > imageSize.height)
1211       imageFrame.size.height = imageSize.height;
1212     imageFrame.origin.y += ceil(0.5*(cellFrame.size.height-imageFrame.size.height));
1213
1214    // according to the documentation the coordinate system should be flipped for NSTableViews (y-coordinate goes from top to bottom);
1215    // to draw an image correctly the coordinate system has to be transformed to a bottom-top coordinate system, otherwise the image's
1216    // content is flipped:
1217     NSAffineTransform* coordinateTransform([NSAffineTransform transform]);
1218
1219     if ([controlView isFlipped])
1220     {
1221       [coordinateTransform scaleXBy: 1.0 yBy:-1.0]; // first the coordinate system is brought back to bottom-top orientation
1222       [coordinateTransform translateXBy:0.0 yBy:(-2.0)*imageFrame.origin.y-imageFrame.size.height]; // the coordinate system has to be moved to compensate for the
1223       [coordinateTransform concat];                                                                 // other orientation and the position of the image's frame
1224     }
1225     [image drawInRect:imageFrame fromRect:NSZeroRect operation:NSCompositeSourceOver fraction:1.0]; // suggested method to draw the image
1226                                                                                                     // instead of compositeToPoint:operation:
1227    // take back previous transformation (if the view is not flipped the coordinate transformation matrix contains the identity matrix
1228    // and the next two operations do not change the content's transformation matrix):
1229     [coordinateTransform invert];
1230     [coordinateTransform concat];
1231   }
1232  // let the textfield cell draw the text part:
1233   if (textFrame.size.width > [self cellTextSize].width) // for unknown reasons the alignment of the text cell is ignored; therefore change the size so that
1234     textFrame.size.width = [self cellTextSize].width;   // alignment does not influence the visualization anymore
1235   [super drawWithFrame:textFrame inView:controlView];
1236 }
1237
1238 -(void) editWithFrame:(NSRect)aRect inView:(NSView*)controlView editor:(NSText*)textObj delegate:(id)anObject event:(NSEvent*)theEvent
1239 {
1240   NSRect textFrame, imageFrame;
1241
1242
1243   [self determineCellParts:aRect imagePart:&imageFrame textPart:&textFrame];
1244   [super editWithFrame:textFrame inView:controlView editor:textObj delegate:anObject event:theEvent];
1245 }
1246
1247 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
1248 -(NSUInteger) hitTestForEvent:(NSEvent*)event inRect:(NSRect)cellFrame ofView:(NSView*)controlView
1249 {
1250   NSPoint point = [controlView convertPoint:[event locationInWindow] fromView:nil];
1251
1252   NSRect imageFrame, textFrame;
1253
1254
1255   [self determineCellParts:cellFrame imagePart:&imageFrame textPart:&textFrame];
1256   if (image != nil)
1257   {
1258    // the image is shifted...
1259     if (imageFrame.size.width >= xImageShift+imageSize.width+spaceImageText)
1260     {
1261       imageFrame.origin.x += imageFrame.size.width-imageSize.width-spaceImageText;
1262       imageFrame.size.width = imageSize.width;
1263     }
1264     else
1265     {
1266       imageFrame.origin.x   += xImageShift;
1267       imageFrame.size.width -= xImageShift+spaceImageText;
1268     }
1269    // ...and centered:
1270     if (imageFrame.size.height > imageSize.height)
1271       imageFrame.size.height = imageSize.height;
1272     imageFrame.origin.y += ceil(0.5*(cellFrame.size.height-imageFrame.size.height));
1273     // If the point is in the image rect, then it is a content hit (see documentation for hitTestForEvent:inRect:ofView):
1274     if (NSMouseInRect(point, imageFrame, [controlView isFlipped]))
1275       return NSCellHitContentArea;
1276   }
1277  // if the image was not hit let's try the text part:
1278   if (textFrame.size.width > [self cellTextSize].width) // for unknown reasons the alignment of the text cell is ignored; therefore change the size so that
1279     textFrame.size.width = [self cellTextSize].width;   // alignment does not influence the visualization anymore
1280   return [super hitTestForEvent:event inRect:textFrame ofView:controlView];
1281 }
1282 #endif
1283
1284 -(NSRect) imageRectForBounds:(NSRect)cellFrame
1285 {
1286   NSRect textFrame, imageFrame;
1287
1288
1289   [self determineCellParts:cellFrame imagePart:&imageFrame textPart:&textFrame];
1290   if (imageFrame.size.width >= xImageShift+imageSize.width+spaceImageText)
1291   {
1292     imageFrame.origin.x += imageFrame.size.width-imageSize.width-spaceImageText;
1293     imageFrame.size.width = imageSize.width;
1294   }
1295   else
1296   {
1297     imageFrame.origin.x   += xImageShift;
1298     imageFrame.size.width -= xImageShift+spaceImageText;
1299   }
1300  // ...and centered:
1301   if (imageFrame.size.height > imageSize.height)
1302     imageFrame.size.height = imageSize.height;
1303   imageFrame.origin.y += ceil(0.5*(cellFrame.size.height-imageFrame.size.height));
1304
1305   return imageFrame;
1306 }
1307
1308 -(void) selectWithFrame:(NSRect)aRect inView:(NSView*)controlView editor:(NSText*)textObj delegate:(id)anObject start:(NSInteger)selStart length:(NSInteger)selLength
1309 {
1310   NSRect textFrame, imageFrame;
1311
1312
1313   [self determineCellParts:aRect imagePart:&imageFrame textPart:&textFrame];
1314   [super selectWithFrame:textFrame inView:controlView editor:textObj delegate:anObject start:selStart length:selLength];
1315 }
1316
1317 -(NSRect) titleRectForBounds:(NSRect)cellFrame
1318 {
1319   NSRect textFrame, imageFrame;
1320
1321
1322   [self determineCellParts:cellFrame imagePart:&imageFrame textPart:&textFrame];
1323    return textFrame;
1324 }
1325
1326 @end
1327
1328 // ============================================================================
1329 // wxCocoaOutlineView
1330 // ============================================================================
1331 @implementation wxCocoaOutlineView
1332
1333 //
1334 // initializers / destructor
1335 //
1336 -(id) init
1337 {
1338   self = [super init];
1339   if (self != nil)
1340   {
1341     currentlyEditedColumn =
1342     currentlyEditedRow = -1;
1343
1344     [self registerForDraggedTypes:[NSArray arrayWithObjects:DataViewPboardType,NSStringPboardType,nil]];
1345     [self setDelegate:self];
1346     [self setDoubleAction:@selector(actionDoubleClick:)];
1347     [self setDraggingSourceOperationMask:NSDragOperationEvery forLocal:NO];
1348     [self setDraggingSourceOperationMask:NSDragOperationEvery forLocal:YES];
1349     [self setTarget:self];
1350   }
1351   return self;
1352 }
1353
1354 //
1355 // access to wxWidget's implementation
1356 //
1357 -(wxCocoaDataViewControl*) implementation
1358 {
1359   return implementation;
1360 }
1361
1362 -(void) setImplementation:(wxCocoaDataViewControl*) newImplementation
1363 {
1364   implementation = newImplementation;
1365 }
1366
1367 //
1368 // actions
1369 //
1370 -(void) actionDoubleClick:(id)sender
1371  // actually the documentation (NSTableView 2007-10-31) for doubleAction: and setDoubleAction: seems to be wrong as this action message is always sent
1372  // whether the cell is editable or not
1373 {
1374   wxDataViewCtrl* const dataViewCtrlPtr = implementation->GetDataViewCtrl();
1375
1376   wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED,dataViewCtrlPtr->GetId()); // variable definition
1377
1378
1379   dataViewEvent.SetEventObject(dataViewCtrlPtr);
1380   dataViewEvent.SetItem(wxDataViewItem([((wxPointerObject*) [self itemAtRow:[self clickedRow]]) pointer]));
1381   dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
1382 }
1383
1384
1385 //
1386 // contextual menus
1387 //
1388 -(NSMenu*) menuForEvent:(NSEvent*)theEvent
1389  // this method does not do any special menu event handling but only sends an event message; therefore, the user
1390  // has full control if a context menu should be shown or not
1391 {
1392   wxDataViewCtrl* const dataViewCtrlPtr = implementation->GetDataViewCtrl();
1393
1394   wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU,dataViewCtrlPtr->GetId());
1395
1396   wxDataViewItemArray selectedItems;
1397
1398
1399   dataViewEvent.SetEventObject(dataViewCtrlPtr);
1400   dataViewEvent.SetModel(dataViewCtrlPtr->GetModel());
1401  // get the item information;
1402  // theoretically more than one ID can be returned but the event can only handle one item, therefore only the first
1403  // item of the array is returned:
1404   if (dataViewCtrlPtr->GetSelections(selectedItems) > 0)
1405     dataViewEvent.SetItem(selectedItems[0]);
1406   dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
1407  // nothing is done:
1408   return nil;
1409 }
1410
1411 //
1412 // delegate methods
1413 //
1414 -(void) outlineView:(NSOutlineView*)outlineView mouseDownInHeaderOfTableColumn:(NSTableColumn*)tableColumn
1415 {
1416   wxDataViewColumn* const dataViewColumnPtr(reinterpret_cast<wxDataViewColumn*>([[tableColumn identifier] pointer]));
1417
1418   wxDataViewCtrl* const dataViewCtrlPtr = implementation->GetDataViewCtrl();
1419
1420   wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK,dataViewCtrlPtr->GetId());
1421
1422
1423  // first, send an event that the user clicked into a column's header:
1424   dataViewEvent.SetEventObject(dataViewCtrlPtr);
1425   dataViewEvent.SetColumn(dataViewCtrlPtr->GetColumnPosition(dataViewColumnPtr));
1426   dataViewEvent.SetDataViewColumn(dataViewColumnPtr);
1427   dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
1428
1429  // now, check if the click may have had an influence on sorting, too;
1430  // the sorting setup has to be done only if the clicked table column is sortable and has not been used for
1431  // sorting before the click; if the column is already responsible for sorting the native control changes
1432  // the sorting direction automatically and informs the data source via outlineView:sortDescriptorsDidChange:
1433   if (dataViewColumnPtr->IsSortable() && ([tableColumn sortDescriptorPrototype] == nil))
1434   {
1435    // remove the sort order from the previously sorted column table (it can also be that
1436    // no sorted column table exists):
1437     UInt32 const noOfColumns = [outlineView numberOfColumns];
1438
1439     for (UInt32 i=0; i<noOfColumns; ++i)
1440       [[[outlineView tableColumns] objectAtIndex:i] setSortDescriptorPrototype:nil];
1441    // make column table sortable:
1442     NSArray*          sortDescriptors;
1443     NSSortDescriptor* sortDescriptor;
1444
1445     sortDescriptor = [[NSSortDescriptor alloc] initWithKey:[NSString stringWithFormat:@"%d",[outlineView columnWithIdentifier:[tableColumn identifier]]]
1446                                                  ascending:YES];
1447     sortDescriptors = [NSArray arrayWithObject:sortDescriptor];
1448     [tableColumn setSortDescriptorPrototype:sortDescriptor];
1449     [outlineView setSortDescriptors:sortDescriptors];
1450     [sortDescriptor release];
1451   }
1452 }
1453
1454 -(BOOL) outlineView:(NSOutlineView*)outlineView shouldCollapseItem:(id)item
1455 {
1456   wxDataViewCtrl* const dataViewCtrlPtr = implementation->GetDataViewCtrl();
1457
1458   wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING,dataViewCtrlPtr->GetId()); // variable definition
1459
1460
1461   dataViewEvent.SetEventObject(dataViewCtrlPtr);
1462   dataViewEvent.SetItem       (wxDataViewItem([((wxPointerObject*) item) pointer]));
1463   dataViewEvent.SetModel      (dataViewCtrlPtr->GetModel());
1464  // finally send the equivalent wxWidget event:
1465   dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
1466  // opening the container is allowed if not vetoed:
1467   return dataViewEvent.IsAllowed();
1468 }
1469
1470 -(BOOL) outlineView:(NSOutlineView*)outlineView shouldExpandItem:(id)item
1471 {
1472   wxDataViewCtrl* const dataViewCtrlPtr = implementation->GetDataViewCtrl();
1473
1474   wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING,dataViewCtrlPtr->GetId()); // variable definition
1475
1476
1477   dataViewEvent.SetEventObject(dataViewCtrlPtr);
1478   dataViewEvent.SetItem       (wxDataViewItem([((wxPointerObject*) item) pointer]));
1479   dataViewEvent.SetModel      (dataViewCtrlPtr->GetModel());
1480  // finally send the equivalent wxWidget event:
1481   dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
1482  // opening the container is allowed if not vetoed:
1483   return dataViewEvent.IsAllowed();
1484 }
1485
1486 -(BOOL) outlineView:(NSOutlineView*)outlineView shouldSelectTableColumn:(NSTableColumn*)tableColumn
1487 {
1488   return NO;
1489 }
1490
1491 -(void) outlineView:(wxCocoaOutlineView*)outlineView
1492         willDisplayCell:(id)cell
1493         forTableColumn:(NSTableColumn*)tableColumn
1494         item:(id)item
1495 {
1496     wxDataViewCtrl * const dvc = implementation->GetDataViewCtrl();
1497     wxDataViewModel * const model = dvc->GetModel();
1498
1499     wxDataViewColumn * const
1500         dvCol(reinterpret_cast<wxDataViewColumn*>(
1501                 [[tableColumn identifier] pointer]
1502             )
1503         );
1504
1505     wxDataViewRenderer * const renderer = dvCol->GetRenderer();
1506     wxDataViewRendererNativeData * const data = renderer->GetNativeData();
1507
1508     wxDataViewItem dvItem([static_cast<wxPointerObject *>(item) pointer]);
1509
1510     // set the font and text colour to use: we need to do it if we had ever
1511     // changed them before, even if this item itself doesn't have any special
1512     // attributes as otherwise it would reuse the attributes from the previous
1513     // cell rendered using the same renderer
1514     NSFont *font = NULL;
1515     NSColor *colText = NULL;
1516
1517     wxDataViewItemAttr attr;
1518     if ( model && model->GetAttr(dvItem, dvCol->GetModelColumn(), attr) )
1519     {
1520         if ( attr.HasFont() )
1521         {
1522             font = data->GetOriginalFont();
1523             if ( !font )
1524             {
1525                 // this is the first time we're setting the font, remember the
1526                 // original one before changing it
1527                 font = [cell font];
1528                 data->SaveOriginalFont(font);
1529             }
1530
1531             if ( font )
1532             {
1533                 // FIXME: using wxFont methods here doesn't work for some reason
1534                 NSFontManager * const fm = [NSFontManager sharedFontManager];
1535                 if ( attr.GetBold() )
1536                     font = [fm convertFont:font toHaveTrait:NSBoldFontMask];
1537                 if ( attr.GetItalic() )
1538                     font = [fm convertFont:font toHaveTrait:NSItalicFontMask];
1539             }
1540             //else: can't change font if the cell doesn't have any
1541         }
1542
1543         if ( attr.HasColour() )
1544         {
1545             // we can set font for any cell but only NSTextFieldCell provides
1546             // a method for setting text colour so check that this method is
1547             // available before using it
1548             if ( [cell respondsToSelector:@selector(setTextColor:)] &&
1549                     [cell respondsToSelector:@selector(textColor)] )
1550             {
1551                 if ( !data->GetOriginalTextColour() )
1552                 {
1553                     data->SaveOriginalTextColour([cell textColor]);
1554                 }
1555
1556                 const wxColour& c = attr.GetColour();
1557                 colText = [NSColor colorWithDeviceRed:c.Red() / 255.
1558                                                   green:c.Green() / 255.
1559                                                   blue:c.Blue() / 255.
1560                                                   alpha:c.Alpha() / 255.];
1561             }
1562         }
1563     }
1564
1565     if ( !font )
1566         font = data->GetOriginalFont();
1567     if ( !colText )
1568         colText = data->GetOriginalTextColour();
1569
1570     if ( font )
1571         [cell setFont:font];
1572
1573     if ( colText )
1574         [cell setTextColor:colText];
1575
1576
1577     data->SetColumnPtr(tableColumn);
1578     data->SetItem(item);
1579     data->SetItemCell(cell);
1580
1581     renderer->MacRender();
1582 }
1583
1584 //
1585 // notifications
1586 //
1587 -(void) outlineViewColumnDidMove:(NSNotification*)notification
1588 {
1589   int const newColumnPosition = [[[notification userInfo] objectForKey:@"NSNewColumn"] intValue];
1590
1591   wxDataViewColumn* const dataViewColumnPtr(reinterpret_cast<wxDataViewColumn*>([[[[self tableColumns] objectAtIndex:newColumnPosition] identifier] pointer]));
1592
1593   wxDataViewCtrl* const dataViewCtrlPtr = implementation->GetDataViewCtrl();
1594
1595   wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_REORDERED,dataViewCtrlPtr->GetId());
1596
1597
1598   dataViewEvent.SetEventObject(dataViewCtrlPtr);
1599   dataViewEvent.SetColumn(dataViewCtrlPtr->GetColumnPosition(dataViewColumnPtr));
1600   dataViewEvent.SetDataViewColumn(dataViewColumnPtr);
1601   dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
1602 }
1603
1604 -(void) outlineViewItemDidCollapse:(NSNotification*)notification
1605 {
1606   wxDataViewCtrl* const dataViewCtrlPtr = implementation->GetDataViewCtrl();
1607
1608   wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED,dataViewCtrlPtr->GetId());
1609
1610
1611   dataViewEvent.SetEventObject(dataViewCtrlPtr);
1612   dataViewEvent.SetItem(wxDataViewItem([((wxPointerObject*) [[notification userInfo] objectForKey:@"NSObject"]) pointer]));
1613   dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
1614 }
1615
1616 -(void) outlineViewItemDidExpand:(NSNotification*)notification
1617 {
1618   wxDataViewCtrl* const dataViewCtrlPtr = implementation->GetDataViewCtrl();
1619
1620   wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED,dataViewCtrlPtr->GetId());
1621
1622
1623   dataViewEvent.SetEventObject(dataViewCtrlPtr);
1624   dataViewEvent.SetItem(wxDataViewItem([((wxPointerObject*) [[notification userInfo] objectForKey:@"NSObject"]) pointer]));
1625   dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
1626 }
1627
1628 -(void) outlineViewSelectionDidChange:(NSNotification*)notification
1629 {
1630   wxDataViewCtrl* const dataViewCtrlPtr = implementation->GetDataViewCtrl();
1631
1632   wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED,dataViewCtrlPtr->GetId()); // variable definition
1633
1634
1635   dataViewEvent.SetEventObject(dataViewCtrlPtr);
1636   dataViewEvent.SetModel      (dataViewCtrlPtr->GetModel());
1637  // finally send the equivalent wxWidget event:
1638   dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
1639 }
1640
1641 -(void) textDidBeginEditing:(NSNotification*)notification
1642  // this notification is only sent if the user started modifying the cell (not when the user clicked into the cell
1643  // and the cell's editor is called!)
1644 {
1645  // call method of superclass (otherwise editing does not work correctly - the outline data source class is not
1646  // informed about a change of data):
1647   [super textDidBeginEditing:notification];
1648
1649   // remember the column being edited, it will be used in textDidEndEditing:
1650   currentlyEditedColumn = [self editedColumn];
1651   currentlyEditedRow = [self editedRow];
1652
1653   wxDataViewColumn* const dataViewColumnPtr =
1654       static_cast<wxDataViewColumn*>(
1655         [[[[self tableColumns] objectAtIndex:currentlyEditedColumn] identifier] pointer]);
1656
1657   wxDataViewCtrl* const dataViewCtrlPtr = implementation->GetDataViewCtrl();
1658
1659
1660  // stop editing of a custom item first (if necessary)
1661   dataViewCtrlPtr->FinishCustomItemEditing();
1662
1663  // now, send the event:
1664   wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED,dataViewCtrlPtr->GetId()); // variable definition
1665
1666   dataViewEvent.SetEventObject(dataViewCtrlPtr);
1667   dataViewEvent.SetItem(
1668         wxDataViewItem([((wxPointerObject*) [self itemAtRow:currentlyEditedRow]) pointer]));
1669   dataViewEvent.SetColumn(dataViewCtrlPtr->GetColumnPosition(dataViewColumnPtr));
1670   dataViewEvent.SetDataViewColumn(dataViewColumnPtr);
1671   dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
1672 }
1673
1674 -(void) textDidEndEditing:(NSNotification*)notification
1675 {
1676  // call method of superclass (otherwise editing does not work correctly - the outline data source class is not
1677  // informed about a change of data):
1678   [super textDidEndEditing:notification];
1679
1680  // under OSX an event indicating the end of an editing session can be sent even if no event indicating a start of an
1681  // editing session has been sent (see Documentation for NSControl controlTextDidEndEditing:); this is not expected by a user
1682  // of the wxWidgets library and therefore an wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE event is only sent if a corresponding
1683  // wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED has been sent before; to check if a wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED
1684  // has been sent the last edited column/row are valid:
1685   if ( currentlyEditedColumn != -1 && currentlyEditedRow != -1 )
1686   {
1687     wxDataViewColumn* const dataViewColumnPtr =
1688         static_cast<wxDataViewColumn*>(
1689             [[[[self tableColumns] objectAtIndex:currentlyEditedColumn] identifier] pointer]);
1690
1691     wxDataViewCtrl* const dataViewCtrlPtr = implementation->GetDataViewCtrl();
1692
1693    // send event to wxWidgets:
1694     wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE,dataViewCtrlPtr->GetId()); // variable definition
1695
1696     dataViewEvent.SetEventObject(dataViewCtrlPtr);
1697     dataViewEvent.SetItem(
1698         wxDataViewItem([((wxPointerObject*) [self itemAtRow:currentlyEditedRow]) pointer]));
1699     dataViewEvent.SetColumn(dataViewCtrlPtr->GetColumnPosition(dataViewColumnPtr));
1700     dataViewEvent.SetDataViewColumn(dataViewColumnPtr);
1701     dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
1702
1703
1704     // we're not editing any more
1705     currentlyEditedColumn =
1706     currentlyEditedRow = -1;
1707   }
1708 }
1709
1710 @end
1711 // ============================================================================
1712 // wxCocoaDataViewControl
1713 // ============================================================================
1714 //
1715 // constructors / destructor
1716 //
1717 wxCocoaDataViewControl::wxCocoaDataViewControl(wxWindow* peer, wxPoint const& pos, wxSize const& size, long style)
1718                        :wxWidgetCocoaImpl(peer,[[NSScrollView alloc] initWithFrame:wxOSXGetFrameForControl(peer,pos,size)]),
1719                         m_DataSource(NULL), m_OutlineView([[wxCocoaOutlineView alloc] init])
1720 {
1721  // initialize scrollview (the outline view is part of a scrollview):
1722   NSScrollView* scrollview = (NSScrollView*) GetWXWidget(); // definition for abbreviational purposes
1723
1724
1725   [scrollview setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
1726   [scrollview setBorderType:NSNoBorder];
1727   [scrollview setHasVerticalScroller:YES];
1728   [scrollview setHasHorizontalScroller:YES];
1729   [scrollview setAutohidesScrollers:YES];
1730   [scrollview setDocumentView:m_OutlineView];
1731
1732  // setting up the native control itself
1733   NSUInteger maskGridStyle(NSTableViewGridNone);
1734
1735   [m_OutlineView setImplementation:this];
1736   [m_OutlineView setColumnAutoresizingStyle:NSTableViewSequentialColumnAutoresizingStyle];
1737   [m_OutlineView setIndentationPerLevel:GetDataViewCtrl()->GetIndent()];
1738   if (style & wxDV_HORIZ_RULES)
1739     maskGridStyle |= NSTableViewSolidHorizontalGridLineMask;
1740   if (style & wxDV_VERT_RULES)
1741     maskGridStyle |= NSTableViewSolidVerticalGridLineMask;
1742   [m_OutlineView setGridStyleMask:maskGridStyle];
1743   [m_OutlineView setAllowsMultipleSelection:           (style & wxDV_MULTIPLE)  != 0];
1744   [m_OutlineView setUsesAlternatingRowBackgroundColors:(style & wxDV_ROW_LINES) != 0];
1745 }
1746
1747 wxCocoaDataViewControl::~wxCocoaDataViewControl()
1748 {
1749   [m_DataSource  release];
1750   [m_OutlineView release];
1751 }
1752
1753 //
1754 // column related methods (inherited from wxDataViewWidgetImpl)
1755 //
1756 bool wxCocoaDataViewControl::ClearColumns()
1757 {
1758   bool const bufAllowsMultipleSelection = [m_OutlineView allowsMultipleSelection];
1759
1760
1761  // as there is a bug in NSOutlineView version (OSX 10.5.6 #6555162) the columns cannot be deleted if there is an outline column in the view;
1762  // therefore, the whole view is deleted and newly constructed:
1763   [m_OutlineView release];
1764   m_OutlineView = [[wxCocoaOutlineView alloc] init];
1765   [((NSScrollView*) GetWXWidget()) setDocumentView:m_OutlineView];
1766
1767  // setting up the native control itself
1768   [m_OutlineView setImplementation:this];
1769   [m_OutlineView setColumnAutoresizingStyle:NSTableViewSequentialColumnAutoresizingStyle];
1770   [m_OutlineView setIndentationPerLevel:GetDataViewCtrl()->GetIndent()];
1771   if (bufAllowsMultipleSelection)
1772     [m_OutlineView setAllowsMultipleSelection:YES];
1773   [m_OutlineView setDataSource:m_DataSource];
1774  // done:
1775   return true;
1776 }
1777
1778 bool wxCocoaDataViewControl::DeleteColumn(wxDataViewColumn* columnPtr)
1779 {
1780   if ([m_OutlineView outlineTableColumn] == columnPtr->GetNativeData()->GetNativeColumnPtr())
1781     [m_OutlineView setOutlineTableColumn:nil]; // due to a bug this does not work
1782   [m_OutlineView removeTableColumn:columnPtr->GetNativeData()->GetNativeColumnPtr()]; // due to a confirmed bug #6555162 the deletion does not work for
1783                                                                                             // outline table columns (... and there is no workaround)
1784   return (([m_OutlineView columnWithIdentifier:[[[wxPointerObject alloc] initWithPointer:columnPtr] autorelease]]) == -1);
1785 }
1786
1787 void wxCocoaDataViewControl::DoSetExpanderColumn(wxDataViewColumn const* columnPtr)
1788 {
1789   [m_OutlineView setOutlineTableColumn:columnPtr->GetNativeData()->GetNativeColumnPtr()];
1790 }
1791
1792 wxDataViewColumn* wxCocoaDataViewControl::GetColumn(unsigned int pos) const
1793 {
1794   return reinterpret_cast<wxDataViewColumn*>([[[[m_OutlineView tableColumns] objectAtIndex:pos] identifier] pointer]);
1795 }
1796
1797 int wxCocoaDataViewControl::GetColumnPosition(wxDataViewColumn const* columnPtr) const
1798 {
1799   return [m_OutlineView columnWithIdentifier:[[[wxPointerObject alloc] initWithPointer:const_cast<wxDataViewColumn*>(columnPtr)] autorelease]];
1800 }
1801
1802 bool wxCocoaDataViewControl::InsertColumn(unsigned int pos, wxDataViewColumn* columnPtr)
1803 {
1804   NSTableColumn* nativeColumn;
1805
1806
1807  // create column and set the native data of the dataview column:
1808   nativeColumn = ::CreateNativeColumn(columnPtr);
1809   columnPtr->GetNativeData()->SetNativeColumnPtr(nativeColumn);
1810  // as the native control does not allow the insertion of a column at a specified position the column is first appended and
1811  // - if necessary - moved to its final position:
1812   [m_OutlineView addTableColumn:nativeColumn];
1813   if (pos != static_cast<unsigned int>([m_OutlineView numberOfColumns]-1))
1814     [m_OutlineView moveColumn:[m_OutlineView numberOfColumns]-1 toColumn:pos];
1815  // done:
1816   return true;
1817 }
1818
1819 //
1820 // item related methods (inherited from wxDataViewWidgetImpl)
1821 //
1822 bool wxCocoaDataViewControl::Add(wxDataViewItem const& parent, wxDataViewItem const& WXUNUSED(item))
1823 {
1824   if (parent.IsOk())
1825     [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:parent] reloadChildren:YES];
1826   else
1827     [m_OutlineView reloadData];
1828   return true;
1829 }
1830
1831 bool wxCocoaDataViewControl::Add(wxDataViewItem const& parent, wxDataViewItemArray const& WXUNUSED(items))
1832 {
1833   if (parent.IsOk())
1834     [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:parent] reloadChildren:YES];
1835   else
1836     [m_OutlineView reloadData];
1837   return true;
1838 }
1839
1840 void wxCocoaDataViewControl::Collapse(wxDataViewItem const& item)
1841 {
1842   [m_OutlineView collapseItem:[m_DataSource getDataViewItemFromBuffer:item]];
1843 }
1844
1845 void wxCocoaDataViewControl::EnsureVisible(wxDataViewItem const& item, wxDataViewColumn const* columnPtr)
1846 {
1847   if (item.IsOk())
1848   {
1849     [m_OutlineView scrollRowToVisible:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]];
1850     if (columnPtr != NULL)
1851       [m_OutlineView scrollColumnToVisible:GetColumnPosition(columnPtr)];
1852   }
1853 }
1854
1855 void wxCocoaDataViewControl::Expand(wxDataViewItem const& item)
1856 {
1857   [m_OutlineView expandItem:[m_DataSource getDataViewItemFromBuffer:item]];
1858 }
1859
1860 unsigned int wxCocoaDataViewControl::GetCount() const
1861 {
1862   return [m_OutlineView numberOfRows];
1863 }
1864
1865 wxRect wxCocoaDataViewControl::GetRectangle(wxDataViewItem const& item, wxDataViewColumn const* columnPtr)
1866 {
1867   return wxFromNSRect([m_osxView superview],[m_OutlineView frameOfCellAtColumn:GetColumnPosition(columnPtr)
1868                                              row:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]]);
1869 }
1870
1871 bool wxCocoaDataViewControl::IsExpanded(wxDataViewItem const& item) const
1872 {
1873   return [m_OutlineView isItemExpanded:[m_DataSource getDataViewItemFromBuffer:item]];
1874 }
1875
1876 bool wxCocoaDataViewControl::Reload()
1877 {
1878   [m_DataSource clearBuffers];
1879   [m_OutlineView scrollColumnToVisible:0];
1880   [m_OutlineView scrollRowToVisible:0];
1881   [m_OutlineView reloadData];
1882   return true;
1883 }
1884
1885 bool wxCocoaDataViewControl::Remove(wxDataViewItem const& parent, wxDataViewItem const& WXUNUSED(item))
1886 {
1887   if (parent.IsOk())
1888     [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:parent] reloadChildren:YES];
1889   else
1890     [m_OutlineView reloadData];
1891   return true;
1892 }
1893
1894 bool wxCocoaDataViewControl::Remove(wxDataViewItem const& parent, wxDataViewItemArray const& WXUNUSED(item))
1895 {
1896   if (parent.IsOk())
1897     [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:parent] reloadChildren:YES];
1898   else
1899     [m_OutlineView reloadData];
1900   return true;
1901 }
1902
1903 bool wxCocoaDataViewControl::Update(wxDataViewColumn const* columnPtr)
1904 {
1905   return false;
1906 }
1907
1908 bool wxCocoaDataViewControl::Update(wxDataViewItem const& WXUNUSED(parent), wxDataViewItem const& item)
1909 {
1910   [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:item]];
1911   return true;
1912 }
1913
1914 bool wxCocoaDataViewControl::Update(wxDataViewItem const& WXUNUSED(parent), wxDataViewItemArray const& items)
1915 {
1916   for (size_t i=0; i<items.GetCount(); ++i)
1917     [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:items[i]]];
1918   return true;
1919 }
1920
1921 //
1922 // model related methods
1923 //
1924 bool wxCocoaDataViewControl::AssociateModel(wxDataViewModel* model)
1925 {
1926   [m_DataSource release];
1927   if (model != NULL)
1928   {
1929     m_DataSource = [[wxCocoaOutlineDataSource alloc] init];
1930     [m_DataSource setImplementation:this];
1931     [m_DataSource setModel:model];
1932   }
1933   else
1934     m_DataSource = NULL;
1935   [m_OutlineView setDataSource:m_DataSource]; // if there is a data source the data is immediately going to be requested
1936   return true;
1937 }
1938
1939 //
1940 // selection related methods (inherited from wxDataViewWidgetImpl)
1941 //
1942 int wxCocoaDataViewControl::GetSelections(wxDataViewItemArray& sel) const
1943 {
1944   NSIndexSet* selectedRowIndexes([m_OutlineView selectedRowIndexes]);
1945
1946   NSUInteger indexRow;
1947
1948
1949   sel.Empty();
1950   sel.Alloc([selectedRowIndexes count]);
1951   indexRow = [selectedRowIndexes firstIndex];
1952   while (indexRow != NSNotFound)
1953   {
1954     sel.Add(wxDataViewItem([[m_OutlineView itemAtRow:indexRow] pointer]));
1955     indexRow = [selectedRowIndexes indexGreaterThanIndex:indexRow];
1956   }
1957   return sel.GetCount();
1958 }
1959
1960 bool wxCocoaDataViewControl::IsSelected(wxDataViewItem const& item) const
1961 {
1962   return [m_OutlineView isRowSelected:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]];
1963 }
1964
1965 void wxCocoaDataViewControl::Select(wxDataViewItem const& item)
1966 {
1967   if (item.IsOk())
1968     [m_OutlineView selectRowIndexes:[NSIndexSet indexSetWithIndex:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]]
1969                         byExtendingSelection:NO];
1970 }
1971
1972 void wxCocoaDataViewControl::SelectAll()
1973 {
1974   [m_OutlineView selectAll:m_OutlineView];
1975 }
1976
1977 void wxCocoaDataViewControl::Unselect(wxDataViewItem const& item)
1978 {
1979   if (item.IsOk())
1980     [m_OutlineView deselectRow:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]];
1981 }
1982
1983 void wxCocoaDataViewControl::UnselectAll()
1984 {
1985   [m_OutlineView deselectAll:m_OutlineView];
1986 }
1987
1988 //
1989 // sorting related methods
1990 //
1991 wxDataViewColumn* wxCocoaDataViewControl::GetSortingColumn() const
1992 {
1993   NSArray* const columns = [m_OutlineView tableColumns];
1994
1995   UInt32 const noOfColumns = [columns count];
1996
1997
1998   for (UInt32 i=0; i<noOfColumns; ++i)
1999     if ([[columns objectAtIndex:i] sortDescriptorPrototype] != nil)
2000       return reinterpret_cast<wxDataViewColumn*>([[[columns objectAtIndex:i] identifier] pointer]);
2001   return NULL;
2002 }
2003
2004 void wxCocoaDataViewControl::Resort()
2005 {
2006   [m_DataSource clearChildren];
2007   [m_OutlineView reloadData];
2008 }
2009
2010 //
2011 // other methods (inherited from wxDataViewWidgetImpl)
2012 //
2013 void wxCocoaDataViewControl::DoSetIndent(int indent)
2014 {
2015   [m_OutlineView setIndentationPerLevel:static_cast<CGFloat>(indent)];
2016 }
2017
2018 void wxCocoaDataViewControl::HitTest(wxPoint const& point, wxDataViewItem& item, wxDataViewColumn*& columnPtr) const
2019 {
2020   NSPoint const nativePoint = wxToNSPoint((NSScrollView*) GetWXWidget(),point);
2021
2022   int indexColumn;
2023   int indexRow;
2024
2025
2026   indexColumn = [m_OutlineView columnAtPoint:nativePoint];
2027   indexRow    = [m_OutlineView rowAtPoint:   nativePoint];
2028   if ((indexColumn >= 0) && (indexRow >= 0))
2029   {
2030     columnPtr = reinterpret_cast<wxDataViewColumn*>([[[[m_OutlineView tableColumns] objectAtIndex:indexColumn] identifier] pointer]);
2031     item      = wxDataViewItem([[m_OutlineView itemAtRow:indexRow] pointer]);
2032   }
2033   else
2034   {
2035     columnPtr = NULL;
2036     item      = wxDataViewItem();
2037   }
2038 }
2039
2040 void wxCocoaDataViewControl::SetRowHeight(wxDataViewItem const& WXUNUSED(item), unsigned int WXUNUSED(height))
2041  // Not supported by the native control
2042 {
2043 }
2044
2045 void wxCocoaDataViewControl::OnSize()
2046 {
2047   if ([m_OutlineView numberOfColumns] == 1)
2048     [m_OutlineView sizeLastColumnToFit];
2049 }
2050
2051 //
2052 // drag & drop helper methods
2053 //
2054 wxDataFormat wxCocoaDataViewControl::GetDnDDataFormat(wxDataObjectComposite* dataObjects)
2055 {
2056   wxDataFormat resultFormat;
2057
2058
2059   if (dataObjects != NULL)
2060   {
2061     bool compatible(true);
2062
2063     size_t const noOfFormats = dataObjects->GetFormatCount();
2064     size_t       indexFormat;
2065
2066     wxDataFormat* formats;
2067
2068    // get all formats and check afterwards if the formats are compatible; if they are compatible the preferred format is returned otherwise
2069    // wxDF_INVALID is returned;
2070    // currently compatible types (ordered by priority are):
2071    //  - wxDF_UNICODETEXT - wxDF_TEXT
2072     formats = new wxDataFormat[noOfFormats];
2073     dataObjects->GetAllFormats(formats);
2074     indexFormat = 0;
2075     while ((indexFormat < noOfFormats) && compatible)
2076     {
2077       switch (resultFormat.GetType())
2078       {
2079         case wxDF_INVALID:
2080           resultFormat.SetType(formats[indexFormat].GetType()); // first format (should only be reached if indexFormat == 0)
2081           break;
2082         case wxDF_TEXT:
2083           if (formats[indexFormat].GetType() == wxDF_UNICODETEXT)
2084             resultFormat.SetType(wxDF_UNICODETEXT);
2085           else // incompatible
2086           {
2087             resultFormat.SetType(wxDF_INVALID);
2088             compatible = false;
2089           }
2090           break;
2091         case wxDF_UNICODETEXT:
2092           if (formats[indexFormat].GetType() != wxDF_TEXT)
2093           {
2094             resultFormat.SetType(wxDF_INVALID);
2095             compatible = false;
2096           }
2097           break;
2098         default:
2099           resultFormat.SetType(wxDF_INVALID); // not (yet) supported format
2100           compatible = false;
2101       }
2102       ++indexFormat;
2103     } /* while */
2104    // clean up:
2105     delete[] formats;
2106   }
2107   return resultFormat;
2108 }
2109
2110 wxDataObjectComposite* wxCocoaDataViewControl::GetDnDDataObjects(NSData* dataObject) const
2111 {
2112   wxDataFormatId dataFormatID;
2113
2114
2115   [dataObject getBytes:&dataFormatID length:sizeof(wxDataFormatId)];
2116   switch (dataFormatID)
2117   {
2118     case wxDF_TEXT:
2119     case wxDF_UNICODETEXT:
2120       {
2121         wxTextDataObject* textDataObject(new wxTextDataObject());
2122
2123         if (textDataObject->SetData(wxDataFormat(dataFormatID),[dataObject length]-sizeof(wxDataFormatId),reinterpret_cast<char const*>([dataObject bytes])+sizeof(wxDataFormatId)))
2124         {
2125           wxDataObjectComposite* dataObjectComposite(new wxDataObjectComposite());
2126
2127           dataObjectComposite->Add(textDataObject);
2128           return dataObjectComposite;
2129         }
2130         else
2131         {
2132           delete textDataObject;
2133           return NULL;
2134         }
2135       }
2136       break;
2137     default:
2138       return NULL;
2139   }
2140 }
2141
2142 // ----------------------------------------------------------------------------
2143 // wxDataViewRendererNativeData
2144 // ----------------------------------------------------------------------------
2145
2146 void wxDataViewRendererNativeData::Init()
2147 {
2148     m_origFont = NULL;
2149     m_origTextColour = NULL;
2150     m_ellipsizeMode = wxELLIPSIZE_MIDDLE;
2151
2152     if ( m_ColumnCell )
2153         ApplyLineBreakMode(m_ColumnCell);
2154 }
2155
2156 void wxDataViewRendererNativeData::ApplyLineBreakMode(NSCell *cell)
2157 {
2158     NSLineBreakMode nsMode = NSLineBreakByWordWrapping;
2159     switch ( m_ellipsizeMode )
2160     {
2161         case wxELLIPSIZE_NONE:
2162             nsMode = NSLineBreakByClipping;
2163             break;
2164
2165         case wxELLIPSIZE_START:
2166             nsMode = NSLineBreakByTruncatingHead;
2167             break;
2168
2169         case wxELLIPSIZE_MIDDLE:
2170             nsMode = NSLineBreakByTruncatingMiddle;
2171             break;
2172
2173         case wxELLIPSIZE_END:
2174             nsMode = NSLineBreakByTruncatingTail;
2175             break;
2176     }
2177
2178     wxASSERT_MSG( nsMode != NSLineBreakByWordWrapping, "unknown wxEllipsizeMode" );
2179
2180     [cell setLineBreakMode: nsMode];
2181 }
2182
2183 // ---------------------------------------------------------
2184 // wxDataViewRenderer
2185 // ---------------------------------------------------------
2186 wxDataViewRenderer::wxDataViewRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
2187                    :wxDataViewRendererBase(varianttype,mode,align), m_alignment(align), m_mode(mode), m_NativeDataPtr(NULL)
2188 {
2189 }
2190
2191 wxDataViewRenderer::~wxDataViewRenderer()
2192 {
2193   delete m_NativeDataPtr;
2194 }
2195
2196 void wxDataViewRenderer::SetAlignment(int align)
2197 {
2198   m_alignment = align;
2199   [GetNativeData()->GetColumnCell() setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2200 }
2201
2202 void wxDataViewRenderer::SetMode(wxDataViewCellMode mode)
2203 {
2204   m_mode = mode;
2205   if (GetOwner() != NULL)
2206     [GetOwner()->GetNativeData()->GetNativeColumnPtr() setEditable:(mode == wxDATAVIEW_CELL_EDITABLE)];
2207 }
2208
2209 void wxDataViewRenderer::SetNativeData(wxDataViewRendererNativeData* newNativeDataPtr)
2210 {
2211   delete m_NativeDataPtr;
2212   m_NativeDataPtr = newNativeDataPtr;
2213 }
2214
2215 void wxDataViewRenderer::EnableEllipsize(wxEllipsizeMode mode)
2216 {
2217     // we need to store this value to apply it to the columns headerCell in
2218     // CreateNativeColumn()
2219     GetNativeData()->SetEllipsizeMode(mode);
2220
2221     // but we may already apply it to the column cell which will be used for
2222     // this column
2223     GetNativeData()->ApplyLineBreakMode(GetNativeData()->GetColumnCell());
2224 }
2225
2226 wxEllipsizeMode wxDataViewRenderer::GetEllipsizeMode() const
2227 {
2228     return GetNativeData()->GetEllipsizeMode();
2229 }
2230
2231 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer,wxDataViewRendererBase)
2232
2233 // ---------------------------------------------------------
2234 // wxDataViewCustomRenderer
2235 // ---------------------------------------------------------
2236 wxDataViewCustomRenderer::wxDataViewCustomRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
2237                          :wxDataViewRenderer(varianttype,mode,align), m_editorCtrlPtr(NULL), m_DCPtr(NULL)
2238 {
2239   SetNativeData(new wxDataViewRendererNativeData([[wxCustomCell alloc] init]));
2240 }
2241
2242 bool wxDataViewCustomRenderer::MacRender()
2243 {
2244   [GetNativeData()->GetItemCell() setObjectValue:[[[wxCustomRendererObject alloc] initWithRenderer:this] autorelease]];
2245   return true;
2246 }
2247
2248 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
2249
2250 // ---------------------------------------------------------
2251 // wxDataViewTextRenderer
2252 // ---------------------------------------------------------
2253 wxDataViewTextRenderer::wxDataViewTextRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
2254                        :wxDataViewRenderer(varianttype,mode,align)
2255 {
2256   NSTextFieldCell* cell;
2257
2258
2259   cell = [[NSTextFieldCell alloc] init];
2260   [cell setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2261   SetNativeData(new wxDataViewRendererNativeData(cell));
2262   [cell release];
2263 }
2264
2265 bool wxDataViewTextRenderer::MacRender()
2266 {
2267   if (GetValue().GetType() == GetVariantType())
2268   {
2269     [GetNativeData()->GetItemCell() setObjectValue:wxCFStringRef(GetValue().GetString()).AsNSString()];
2270     return true;
2271   }
2272   else
2273   {
2274     wxFAIL_MSG(wxString(_("Text renderer cannot render value because of wrong value type; value type: ")) << GetValue().GetType());
2275     return false;
2276   }
2277 }
2278
2279 IMPLEMENT_CLASS(wxDataViewTextRenderer,wxDataViewRenderer)
2280
2281 // ---------------------------------------------------------
2282 // wxDataViewBitmapRenderer
2283 // ---------------------------------------------------------
2284 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
2285                          :wxDataViewRenderer(varianttype,mode,align)
2286 {
2287   NSImageCell* cell;
2288
2289
2290   cell = [[NSImageCell alloc] init];
2291   SetNativeData(new wxDataViewRendererNativeData(cell));
2292   [cell release];
2293 }
2294
2295 bool wxDataViewBitmapRenderer::MacRender()
2296  // This method returns 'true' if
2297  //  - the passed bitmap is valid and it could be assigned to the native data browser;
2298  //  - the passed bitmap is invalid (or is not initialized); this case simulates a non-existing bitmap.
2299  // In all other cases the method returns 'false'.
2300 {
2301   wxCHECK_MSG(GetValue().GetType() == GetVariantType(),false,wxString(_("Bitmap renderer cannot render value; value type: ")) << GetValue().GetType());
2302
2303   wxBitmap bitmap;
2304
2305   bitmap << GetValue();
2306   if (bitmap.IsOk())
2307     [GetNativeData()->GetItemCell() setObjectValue:[[bitmap.GetNSImage() retain] autorelease]];
2308   return true;
2309 }
2310
2311 IMPLEMENT_CLASS(wxDataViewBitmapRenderer,wxDataViewRenderer)
2312
2313 // -------------------------------------
2314 // wxDataViewChoiceRenderer
2315 // -------------------------------------
2316 wxDataViewChoiceRenderer::wxDataViewChoiceRenderer(wxArrayString const& choices, wxDataViewCellMode mode, int alignment)
2317                          :wxDataViewRenderer(wxT("string"),mode,alignment), m_Choices(choices)
2318 {
2319   NSPopUpButtonCell* cell;
2320
2321
2322   cell = [[NSPopUpButtonCell alloc] init];
2323   [cell setControlSize:NSMiniControlSize];
2324   [cell setFont:[[NSFont fontWithName:[[cell font] fontName] size:[NSFont systemFontSizeForControlSize:NSMiniControlSize]] autorelease]];
2325   for (size_t i=0; i<choices.GetCount(); ++i)
2326     [cell addItemWithTitle:[[wxCFStringRef(choices[i]).AsNSString() retain] autorelease]];
2327   SetNativeData(new wxDataViewRendererNativeData(cell));
2328   [cell release];
2329 }
2330
2331 bool wxDataViewChoiceRenderer::MacRender()
2332 {
2333   if (GetValue().GetType() == GetVariantType())
2334   {
2335     [((NSPopUpButtonCell*) GetNativeData()->GetItemCell()) selectItemWithTitle:[[wxCFStringRef(GetValue().GetString()).AsNSString() retain] autorelease]];
2336     return true;
2337   }
2338   else
2339   {
2340     wxFAIL_MSG(wxString(_("Choice renderer cannot render value because of wrong value type; value type: ")) << GetValue().GetType());
2341     return false;
2342   }
2343 }
2344
2345 IMPLEMENT_CLASS(wxDataViewChoiceRenderer,wxDataViewRenderer)
2346
2347 // ---------------------------------------------------------
2348 // wxDataViewDateRenderer
2349 // ---------------------------------------------------------
2350 wxDataViewDateRenderer::wxDataViewDateRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
2351                        :wxDataViewRenderer(varianttype,mode,align)
2352 {
2353   NSTextFieldCell* cell;
2354
2355   NSDateFormatter* dateFormatter;
2356
2357
2358   dateFormatter = [[NSDateFormatter alloc] init];
2359   [dateFormatter setFormatterBehavior:NSDateFormatterBehavior10_4];
2360   [dateFormatter setDateStyle:NSDateFormatterShortStyle];
2361   cell = [[NSTextFieldCell alloc] init];
2362   [cell setFormatter:dateFormatter];
2363   SetNativeData(new wxDataViewRendererNativeData(cell,[NSDate dateWithString:@"2000-12-30 20:00:00 +0000"]));
2364   [cell          release];
2365   [dateFormatter release];
2366 }
2367
2368 bool wxDataViewDateRenderer::MacRender()
2369 {
2370   if (GetValue().GetType() == GetVariantType())
2371   {
2372     if (GetValue().GetDateTime().IsValid())
2373     {
2374      // -- find best fitting style to show the date --
2375      // as the style should be identical for all cells a reference date instead of the actual cell's date
2376      // value is used for all cells; this reference date is stored in the renderer's native data section
2377      // for speed purposes; otherwise, the reference date's string has to be recalculated for each item that
2378      // may become timewise long if a lot of rows using dates exist;
2379      // the algorithm has the preference to display as much information as possible in the first instance;
2380      // but as this is often impossible due to space restrictions the style is shortened per loop; finally,
2381      // if the shortest time and date format does not fit into the cell the time part is dropped;
2382      // remark: the time part itself is not modified per iteration loop and only uses the short style,
2383      //         means that only the hours and minutes are being shown
2384       [GetNativeData()->GetItemCell() setObjectValue:GetNativeData()->GetObject()]; // GetObject() returns a date for testing the size of a date object
2385       [[GetNativeData()->GetItemCell() formatter] setTimeStyle:NSDateFormatterShortStyle];
2386       for (int dateFormatterStyle=4; dateFormatterStyle>0; --dateFormatterStyle)
2387       {
2388         [[GetNativeData()->GetItemCell() formatter] setDateStyle:(NSDateFormatterStyle)dateFormatterStyle];
2389         if (dateFormatterStyle == 1)
2390         {
2391          // if the shortest style for displaying the date and time is too long to be fully visible remove the time part of the date:
2392           if ([GetNativeData()->GetItemCell() cellSize].width > [GetNativeData()->GetColumnPtr() width])
2393             [[GetNativeData()->GetItemCell() formatter] setTimeStyle:NSDateFormatterNoStyle];
2394           break; // basically not necessary as the loop would end anyway but let's save the last comparison
2395         }
2396         else if ([GetNativeData()->GetItemCell() cellSize].width <= [GetNativeData()->GetColumnPtr() width])
2397           break;
2398       }
2399      // set data (the style is set by the previous loop);
2400      // on OSX the date has to be specified with respect to UTC; in wxWidgets the date is always entered in the local timezone; so, we have to do a conversion
2401      // from the local to UTC timezone when adding the seconds to 1970-01-01 UTC:
2402       [GetNativeData()->GetItemCell() setObjectValue:[NSDate dateWithTimeIntervalSince1970:GetValue().GetDateTime().ToUTC().Subtract(wxDateTime(1,wxDateTime::Jan,1970)).GetSeconds().ToDouble()]];
2403     }
2404     return true;
2405   }
2406   else
2407   {
2408     wxFAIL_MSG(wxString(_("Date renderer cannot render value because of wrong value type; value type: ")) << GetValue().GetType());
2409     return false;
2410   }
2411 }
2412
2413 IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateRenderer,wxDataViewRenderer)
2414
2415 // ---------------------------------------------------------
2416 // wxDataViewIconTextRenderer
2417 // ---------------------------------------------------------
2418 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
2419                            :wxDataViewRenderer(varianttype,mode)
2420 {
2421   wxImageTextCell* cell;
2422
2423
2424   cell = [[wxImageTextCell alloc] init];
2425   [cell setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2426   SetNativeData(new wxDataViewRendererNativeData(cell));
2427   [cell release];
2428 }
2429
2430 bool wxDataViewIconTextRenderer::MacRender()
2431 {
2432   if (GetValue().GetType() == GetVariantType())
2433   {
2434     wxDataViewIconText iconText;
2435
2436     wxImageTextCell* cell;
2437
2438     cell = (wxImageTextCell*) GetNativeData()->GetItemCell();
2439     iconText << GetValue();
2440     if (iconText.GetIcon().IsOk())
2441       [cell setImage:[[wxBitmap(iconText.GetIcon()).GetNSImage() retain] autorelease]];
2442     [cell setStringValue:[[wxCFStringRef(iconText.GetText()).AsNSString() retain] autorelease]];
2443     return true;
2444   }
2445   else
2446   {
2447     wxFAIL_MSG(wxString(_("Icon & text renderer cannot render value because of wrong value type; value type: ")) << GetValue().GetType());
2448     return false;
2449   }
2450 }
2451
2452 IMPLEMENT_ABSTRACT_CLASS(wxDataViewIconTextRenderer,wxDataViewRenderer)
2453
2454 // ---------------------------------------------------------
2455 // wxDataViewToggleRenderer
2456 // ---------------------------------------------------------
2457 wxDataViewToggleRenderer::wxDataViewToggleRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
2458                          :wxDataViewRenderer(varianttype,mode)
2459 {
2460   NSButtonCell* cell;
2461
2462
2463   cell = [[NSButtonCell alloc] init];
2464   [cell setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2465   [cell setButtonType:NSSwitchButton];
2466   [cell setImagePosition:NSImageOnly];
2467   SetNativeData(new wxDataViewRendererNativeData(cell));
2468   [cell release];
2469 }
2470
2471 bool wxDataViewToggleRenderer::MacRender()
2472 {
2473   if (GetValue().GetType() == GetVariantType())
2474   {
2475     [GetNativeData()->GetItemCell() setIntValue:GetValue().GetLong()];
2476     return true;
2477   }
2478   else
2479   {
2480     wxFAIL_MSG(wxString(_("Toggle renderer cannot render value because of wrong value type; value type: ")) << GetValue().GetType());
2481     return false;
2482   }
2483 }
2484
2485 IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleRenderer,wxDataViewRenderer)
2486
2487 // ---------------------------------------------------------
2488 // wxDataViewProgressRenderer
2489 // ---------------------------------------------------------
2490 wxDataViewProgressRenderer::wxDataViewProgressRenderer(wxString const& label, wxString const& varianttype, wxDataViewCellMode mode, int align)
2491                            :wxDataViewRenderer(varianttype,mode,align)
2492 {
2493   NSLevelIndicatorCell* cell;
2494
2495
2496   cell = [[NSLevelIndicatorCell alloc] initWithLevelIndicatorStyle:NSContinuousCapacityLevelIndicatorStyle];
2497   [cell setMinValue:0];
2498   [cell setMaxValue:100];
2499   SetNativeData(new wxDataViewRendererNativeData(cell));
2500   [cell release];
2501 }
2502
2503 bool wxDataViewProgressRenderer::MacRender()
2504 {
2505   if (GetValue().GetType() == GetVariantType())
2506   {
2507     [GetNativeData()->GetItemCell() setIntValue:GetValue().GetLong()];
2508     return true;
2509   }
2510   else
2511   {
2512     wxFAIL_MSG(wxString(_("Progress renderer cannot render value because of wrong value type; value type: ")) << GetValue().GetType());
2513     return false;
2514   }
2515 }
2516
2517 IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressRenderer,wxDataViewRenderer)
2518
2519 // ---------------------------------------------------------
2520 // wxDataViewColumn
2521 // ---------------------------------------------------------
2522 wxDataViewColumn::wxDataViewColumn(const wxString& title, wxDataViewRenderer* renderer, unsigned int model_column, int width, wxAlignment align, int flags)
2523                  :wxDataViewColumnBase(renderer, model_column), m_NativeDataPtr(new wxDataViewColumnNativeData()), m_title(title)
2524 {
2525   InitCommon(width, align, flags);
2526   if ((renderer != NULL) && (renderer->GetAlignment() == wxDVR_DEFAULT_ALIGNMENT))
2527     renderer->SetAlignment(align);
2528 }
2529
2530 wxDataViewColumn::wxDataViewColumn(const wxBitmap& bitmap, wxDataViewRenderer* renderer, unsigned int model_column, int width, wxAlignment align, int flags)
2531                  :wxDataViewColumnBase(bitmap, renderer, model_column), m_NativeDataPtr(new wxDataViewColumnNativeData())
2532 {
2533   InitCommon(width, align, flags);
2534   if ((renderer != NULL) && (renderer->GetAlignment() == wxDVR_DEFAULT_ALIGNMENT))
2535     renderer->SetAlignment(align);
2536 }
2537
2538 wxDataViewColumn::~wxDataViewColumn()
2539 {
2540   delete m_NativeDataPtr;
2541 }
2542
2543 bool wxDataViewColumn::IsSortKey() const
2544 {
2545   return ((GetNativeData()->GetNativeColumnPtr() != NULL) && ([GetNativeData()->GetNativeColumnPtr() sortDescriptorPrototype] != nil));
2546 }
2547
2548 void wxDataViewColumn::SetAlignment(wxAlignment align)
2549 {
2550   m_alignment = align;
2551   [[m_NativeDataPtr->GetNativeColumnPtr() headerCell] setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2552   if ((m_renderer != NULL) && (m_renderer->GetAlignment() == wxDVR_DEFAULT_ALIGNMENT))
2553     m_renderer->SetAlignment(align);
2554 }
2555
2556 void wxDataViewColumn::SetBitmap(wxBitmap const& bitmap)
2557 {
2558  // bitmaps and titles cannot exist at the same time - if the bitmap is set the title is removed:
2559   m_title = wxEmptyString;
2560   wxDataViewColumnBase::SetBitmap(bitmap);
2561   [[m_NativeDataPtr->GetNativeColumnPtr() headerCell] setImage:[[bitmap.GetNSImage() retain] autorelease]];
2562 }
2563
2564 void wxDataViewColumn::SetMaxWidth(int maxWidth)
2565 {
2566   m_maxWidth = maxWidth;
2567   [m_NativeDataPtr->GetNativeColumnPtr() setMaxWidth:maxWidth];
2568 }
2569
2570 void wxDataViewColumn::SetMinWidth(int minWidth)
2571 {
2572   m_minWidth = minWidth;
2573   [m_NativeDataPtr->GetNativeColumnPtr() setMinWidth:minWidth];
2574 }
2575
2576 void wxDataViewColumn::SetReorderable(bool reorderable)
2577 {
2578 }
2579
2580 void wxDataViewColumn::SetResizeable(bool resizeable)
2581 {
2582   wxDataViewColumnBase::SetResizeable(resizeable);
2583   if (resizeable)
2584     [m_NativeDataPtr->GetNativeColumnPtr() setResizingMask:NSTableColumnUserResizingMask];
2585   else
2586     [m_NativeDataPtr->GetNativeColumnPtr() setResizingMask:NSTableColumnNoResizing];
2587 }
2588
2589 void wxDataViewColumn::SetSortable(bool sortable)
2590 {
2591   wxDataViewColumnBase::SetSortable(sortable);
2592 }
2593
2594 void wxDataViewColumn::SetSortOrder(bool ascending)
2595 {
2596   if (m_ascending != ascending)
2597   {
2598     m_ascending = ascending;
2599     if (IsSortKey())
2600     {
2601      // change sorting order:
2602       NSArray*          sortDescriptors;
2603       NSSortDescriptor* sortDescriptor;
2604       NSTableColumn*    tableColumn;
2605
2606       tableColumn     = m_NativeDataPtr->GetNativeColumnPtr();
2607       sortDescriptor  = [[NSSortDescriptor alloc] initWithKey:[[tableColumn sortDescriptorPrototype] key] ascending:m_ascending];
2608       sortDescriptors = [NSArray arrayWithObject:sortDescriptor];
2609       [tableColumn setSortDescriptorPrototype:sortDescriptor];
2610       [[tableColumn tableView] setSortDescriptors:sortDescriptors];
2611       [sortDescriptor release];
2612     }
2613   }
2614 }
2615
2616 void wxDataViewColumn::SetTitle(wxString const& title)
2617 {
2618  // bitmaps and titles cannot exist at the same time - if the title is set the bitmap is removed:
2619   wxDataViewColumnBase::SetBitmap(wxBitmap());
2620   m_title = title;
2621   [[m_NativeDataPtr->GetNativeColumnPtr() headerCell] setStringValue:[[wxCFStringRef(title).AsNSString() retain] autorelease]];
2622 }
2623
2624 void wxDataViewColumn::SetWidth(int width)
2625 {
2626   [m_NativeDataPtr->GetNativeColumnPtr() setWidth:width];
2627   m_width = width;
2628 }
2629
2630 void wxDataViewColumn::SetAsSortKey(bool WXUNUSED(sort))
2631 {
2632  // see wxGTK native wxDataViewColumn implementation
2633   wxFAIL_MSG(_("not implemented"));
2634 }
2635
2636 void wxDataViewColumn::SetNativeData(wxDataViewColumnNativeData* newNativeDataPtr)
2637 {
2638   delete m_NativeDataPtr;
2639   m_NativeDataPtr = newNativeDataPtr;
2640 }
2641 #endif // (wxUSE_DATAVIEWCTRL == 1) && !defined(wxUSE_GENERICDATAVIEWCTRL)