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