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