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