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 = false;
 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 = NSDragOperationNone;
 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]]; // 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     // if this method is called everything is already setup correctly,
1169     CGContextRef context = (CGContextRef) [[NSGraphicsContext currentContext] graphicsPort];
1170     CGContextSaveGState( context );
1171
1172     if ( ![controlView isFlipped] )
1173     {
1174         CGContextTranslateCTM( context, 0,  [controlView bounds].size.height );
1175         CGContextScaleCTM( context, 1, -1 );
1176     }
1177
1178     wxGCDC dc;
1179     wxGraphicsContext* gc = wxGraphicsContext::CreateFromNative(context);
1180     dc.SetGraphicsContext(gc);
1181
1182     int state = 0;
1183     if ( [self isHighlighted] )
1184         state |= wxDATAVIEW_CELL_SELECTED;
1185
1186     renderer->WXCallRender(wxFromNSRect(controlView, cellFrame), &dc, state);
1187
1188     CGContextRestoreGState( context );
1189 }
1190
1191 -(NSRect) imageRectForBounds:(NSRect)cellFrame
1192 {
1193     return cellFrame;
1194 }
1195
1196 -(NSRect) titleRectForBounds:(NSRect)cellFrame
1197 {
1198     return cellFrame;
1199 }
1200
1201 @end
1202
1203 // ============================================================================
1204 // wxImageTextCell
1205 // ============================================================================
1206 @implementation wxImageTextCell
1207 //
1208 // initialization
1209 //
1210 -(id) init
1211 {
1212     self = [super init];
1213     if (self != nil)
1214     {
1215         // initializing the text part:
1216         [self setSelectable:YES];
1217         // initializing the image part:
1218         image       = nil;
1219         imageSize   = NSMakeSize(16,16);
1220         spaceImageText = 5.0;
1221         xImageShift    = 5.0;
1222     }
1223     return self;
1224 }
1225
1226 -(id) copyWithZone:(NSZone*)zone
1227 {
1228     wxImageTextCell* cell;
1229
1230
1231     cell = (wxImageTextCell*) [super copyWithZone:zone];
1232     cell->image          = [image retain];
1233     cell->imageSize      = imageSize;
1234     cell->spaceImageText = spaceImageText;
1235     cell->xImageShift    = xImageShift;
1236
1237     return cell;
1238 }
1239
1240 -(void) dealloc
1241 {
1242     [image release];
1243
1244     [super dealloc];
1245 }
1246
1247 //
1248 // alignment
1249 //
1250 -(NSTextAlignment) alignment
1251 {
1252     return cellAlignment;
1253 }
1254
1255 -(void) setAlignment:(NSTextAlignment)newAlignment
1256 {
1257     cellAlignment = newAlignment;
1258     switch (newAlignment)
1259     {
1260         case NSCenterTextAlignment:
1261         case NSLeftTextAlignment:
1262         case NSJustifiedTextAlignment:
1263         case NSNaturalTextAlignment:
1264             [super setAlignment:NSLeftTextAlignment];
1265             break;
1266         case NSRightTextAlignment:
1267             [super setAlignment:NSRightTextAlignment];
1268             break;
1269         default:
1270             wxFAIL_MSG("Unknown alignment type.");
1271     }
1272 }
1273
1274 //
1275 // image access
1276 //
1277 -(NSImage*) image
1278 {
1279     return image;
1280 }
1281
1282 -(void) setImage:(NSImage*)newImage
1283 {
1284     [newImage retain];
1285     [image release];
1286     image = newImage;
1287 }
1288
1289 -(NSSize) imageSize
1290 {
1291     return imageSize;
1292 }
1293
1294 -(void) setImageSize:(NSSize) newImageSize
1295 {
1296     imageSize = newImageSize;
1297 }
1298
1299 //
1300 // other methods
1301 //
1302 -(NSSize) cellImageSize
1303 {
1304     return NSMakeSize(imageSize.width+xImageShift+spaceImageText,imageSize.height);
1305 }
1306
1307 -(NSSize) cellSize
1308 {
1309     NSSize cellSize([super cellSize]);
1310
1311
1312     if (imageSize.height > cellSize.height)
1313         cellSize.height = imageSize.height;
1314     cellSize.width += imageSize.width+xImageShift+spaceImageText;
1315
1316     return cellSize;
1317 }
1318
1319 -(NSSize) cellTextSize
1320 {
1321     return [super cellSize];
1322 }
1323
1324 //
1325 // implementations
1326 //
1327 -(void) determineCellParts:(NSRect)cellFrame imagePart:(NSRect*)imageFrame textPart:(NSRect*)textFrame
1328 {
1329     switch (cellAlignment)
1330     {
1331         case NSCenterTextAlignment:
1332             {
1333                 CGFloat const cellSpace = cellFrame.size.width-[self cellSize].width;
1334
1335                 // if the cell's frame is smaller than its contents (at least
1336                 // in x-direction) make sure that the image is visible:
1337                 if (cellSpace <= 0)
1338                     NSDivideRect(cellFrame,imageFrame,textFrame,xImageShift+imageSize.width+spaceImageText,NSMinXEdge);
1339                 else // otherwise center the image and text in the cell's frame
1340                     NSDivideRect(cellFrame,imageFrame,textFrame,xImageShift+imageSize.width+spaceImageText+0.5*cellSpace,NSMinXEdge);
1341             }
1342             break;
1343         case NSJustifiedTextAlignment:
1344         case NSLeftTextAlignment:
1345         case NSNaturalTextAlignment: // how to determine the natural writing direction? TODO
1346             NSDivideRect(cellFrame,imageFrame,textFrame,xImageShift+imageSize.width+spaceImageText,NSMinXEdge);
1347             break;
1348         case NSRightTextAlignment:
1349             {
1350                 CGFloat const cellSpace = cellFrame.size.width-[self cellSize].width;
1351
1352                 // if the cell's frame is smaller than its contents (at least
1353                 // in x-direction) make sure that the image is visible:
1354                 if (cellSpace <= 0)
1355                     NSDivideRect(cellFrame,imageFrame,textFrame,xImageShift+imageSize.width+spaceImageText,NSMinXEdge);
1356                 else // otherwise right align the image and text in the cell's frame
1357                     NSDivideRect(cellFrame,imageFrame,textFrame,xImageShift+imageSize.width+spaceImageText+cellSpace,NSMinXEdge);
1358             }
1359             break;
1360         default:
1361             *imageFrame = NSZeroRect;
1362             *textFrame  = NSZeroRect;
1363             wxFAIL_MSG("Unhandled alignment type.");
1364     }
1365 }
1366
1367 -(void) drawWithFrame:(NSRect)cellFrame inView:(NSView*)controlView
1368 {
1369     NSRect textFrame, imageFrame;
1370
1371
1372     [self determineCellParts:cellFrame imagePart:&imageFrame textPart:&textFrame];
1373     // draw the image part by ourselves;
1374     // check if the cell has to draw its own background (checking is done by
1375     // the parameter of the textfield's cell):
1376     if ([self drawsBackground])
1377     {
1378         [[self backgroundColor] set];
1379         NSRectFill(imageFrame);
1380     }
1381     if (image != nil)
1382     {
1383         // the image is slightly shifted (xImageShift) and has a fixed size
1384         // but the image's frame might be larger and starts currently on the
1385         // left side of the cell's frame; therefore, the origin and the
1386         // image's frame size have to be adjusted:
1387         if (imageFrame.size.width >= xImageShift+imageSize.width+spaceImageText)
1388         {
1389             imageFrame.origin.x += imageFrame.size.width-imageSize.width-spaceImageText;
1390             imageFrame.size.width = imageSize.width;
1391         }
1392         else
1393         {
1394             imageFrame.origin.x   += xImageShift;
1395             imageFrame.size.width -= xImageShift+spaceImageText;
1396         }
1397         // ...and the image has to be centered in the y-direction:
1398         if (imageFrame.size.height > imageSize.height)
1399             imageFrame.size.height = imageSize.height;
1400         imageFrame.origin.y += ceil(0.5*(cellFrame.size.height-imageFrame.size.height));
1401
1402         // according to the documentation the coordinate system should be
1403         // flipped for NSTableViews (y-coordinate goes from top to bottom); to
1404         // draw an image correctly the coordinate system has to be transformed
1405         // to a bottom-top coordinate system, otherwise the image's
1406         // content is flipped:
1407         NSAffineTransform* coordinateTransform([NSAffineTransform transform]);
1408
1409         if ([controlView isFlipped])
1410         {
1411             [coordinateTransform scaleXBy: 1.0 yBy:-1.0]; // first the coordinate system is brought back to bottom-top orientation
1412             [coordinateTransform translateXBy:0.0 yBy:(-2.0)*imageFrame.origin.y-imageFrame.size.height]; // the coordinate system has to be moved to compensate for the
1413             [coordinateTransform concat];                                                                 // other orientation and the position of the image's frame
1414         }
1415         [image drawInRect:imageFrame fromRect:NSZeroRect operation:NSCompositeSourceOver fraction:1.0]; // suggested method to draw the image
1416         // instead of compositeToPoint:operation:
1417         // take back previous transformation (if the view is not flipped the
1418         // coordinate transformation matrix contains the identity matrix and
1419         // the next two operations do not change the content's transformation
1420         // matrix):
1421         [coordinateTransform invert];
1422         [coordinateTransform concat];
1423     }
1424     // let the textfield cell draw the text part:
1425     if (textFrame.size.width > [self cellTextSize].width)
1426     {
1427         // for unknown reasons the alignment of the text cell is ignored;
1428         // therefore change the size so that alignment does not influence the
1429         // visualization anymore
1430         textFrame.size.width = [self cellTextSize].width;
1431     }
1432     [super drawWithFrame:textFrame inView:controlView];
1433 }
1434
1435 -(void) editWithFrame:(NSRect)aRect inView:(NSView*)controlView editor:(NSText*)textObj delegate:(id)anObject event:(NSEvent*)theEvent
1436 {
1437     NSRect textFrame, imageFrame;
1438
1439
1440     [self determineCellParts:aRect imagePart:&imageFrame textPart:&textFrame];
1441     [super editWithFrame:textFrame inView:controlView editor:textObj delegate:anObject event:theEvent];
1442 }
1443
1444 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5
1445 -(NSUInteger) hitTestForEvent:(NSEvent*)event inRect:(NSRect)cellFrame ofView:(NSView*)controlView
1446 {
1447     NSPoint point = [controlView convertPoint:[event locationInWindow] fromView:nil];
1448
1449     NSRect imageFrame, textFrame;
1450
1451
1452     [self determineCellParts:cellFrame imagePart:&imageFrame textPart:&textFrame];
1453     if (image != nil)
1454     {
1455         // the image is shifted...
1456         if (imageFrame.size.width >= xImageShift+imageSize.width+spaceImageText)
1457         {
1458             imageFrame.origin.x += imageFrame.size.width-imageSize.width-spaceImageText;
1459             imageFrame.size.width = imageSize.width;
1460         }
1461         else
1462         {
1463             imageFrame.origin.x   += xImageShift;
1464             imageFrame.size.width -= xImageShift+spaceImageText;
1465         }
1466         // ...and centered:
1467         if (imageFrame.size.height > imageSize.height)
1468             imageFrame.size.height = imageSize.height;
1469         imageFrame.origin.y += ceil(0.5*(cellFrame.size.height-imageFrame.size.height));
1470         // If the point is in the image rect, then it is a content hit (see
1471         // documentation for hitTestForEvent:inRect:ofView):
1472         if (NSMouseInRect(point, imageFrame, [controlView isFlipped]))
1473             return NSCellHitContentArea;
1474     }
1475     // if the image was not hit let's try the text part:
1476     if (textFrame.size.width > [self cellTextSize].width)
1477     {
1478         // for unknown reasons the alignment of the text cell is ignored;
1479         // therefore change the size so that alignment does not influence the
1480         // visualization anymore
1481         textFrame.size.width = [self cellTextSize].width;
1482     }
1483
1484     return [super hitTestForEvent:event inRect:textFrame ofView:controlView];
1485 }
1486 #endif
1487
1488 -(NSRect) imageRectForBounds:(NSRect)cellFrame
1489 {
1490     NSRect textFrame, imageFrame;
1491
1492
1493     [self determineCellParts:cellFrame imagePart:&imageFrame textPart:&textFrame];
1494     if (imageFrame.size.width >= xImageShift+imageSize.width+spaceImageText)
1495     {
1496         imageFrame.origin.x += imageFrame.size.width-imageSize.width-spaceImageText;
1497         imageFrame.size.width = imageSize.width;
1498     }
1499     else
1500     {
1501         imageFrame.origin.x   += xImageShift;
1502         imageFrame.size.width -= xImageShift+spaceImageText;
1503     }
1504     // ...and centered:
1505     if (imageFrame.size.height > imageSize.height)
1506         imageFrame.size.height = imageSize.height;
1507     imageFrame.origin.y += ceil(0.5*(cellFrame.size.height-imageFrame.size.height));
1508
1509     return imageFrame;
1510 }
1511
1512 -(void) selectWithFrame:(NSRect)aRect inView:(NSView*)controlView editor:(NSText*)textObj delegate:(id)anObject start:(NSInteger)selStart length:(NSInteger)selLength
1513 {
1514     NSRect textFrame, imageFrame;
1515
1516
1517     [self determineCellParts:aRect imagePart:&imageFrame textPart:&textFrame];
1518     [super selectWithFrame:textFrame inView:controlView editor:textObj delegate:anObject start:selStart length:selLength];
1519 }
1520
1521 -(NSRect) titleRectForBounds:(NSRect)cellFrame
1522 {
1523     NSRect textFrame, imageFrame;
1524
1525
1526     [self determineCellParts:cellFrame imagePart:&imageFrame textPart:&textFrame];
1527     return textFrame;
1528 }
1529
1530 @end
1531
1532 // ============================================================================
1533 // wxCocoaOutlineView
1534 // ============================================================================
1535 @implementation wxCocoaOutlineView
1536
1537 //
1538 // initializers / destructor
1539 //
1540 -(id) init
1541 {
1542     self = [super init];
1543     if (self != nil)
1544     {
1545         currentlyEditedColumn =
1546             currentlyEditedRow = -1;
1547
1548         [self registerForDraggedTypes:[NSArray arrayWithObjects:DataViewPboardType,NSStringPboardType,nil]];
1549         [self setDelegate:self];
1550         [self setDoubleAction:@selector(actionDoubleClick:)];
1551         [self setDraggingSourceOperationMask:NSDragOperationEvery forLocal:NO];
1552         [self setDraggingSourceOperationMask:NSDragOperationEvery forLocal:YES];
1553         [self setTarget:self];
1554     }
1555     return self;
1556 }
1557
1558 //
1559 // access to wxWidget's implementation
1560 //
1561 -(wxCocoaDataViewControl*) implementation
1562 {
1563     return implementation;
1564 }
1565
1566 -(void) setImplementation:(wxCocoaDataViewControl*) newImplementation
1567 {
1568     implementation = newImplementation;
1569 }
1570
1571 //
1572 // actions
1573 //
1574 -(void) actionDoubleClick:(id)sender
1575 {
1576     wxUnusedVar(sender);
1577
1578     // actually the documentation (NSTableView 2007-10-31) for doubleAction:
1579     // and setDoubleAction: seems to be wrong as this action message is always
1580     // sent whether the cell is editable or not
1581     wxDataViewCtrl* const dvc = implementation->GetDataViewCtrl();
1582
1583     wxDataViewEvent event(wxEVT_COMMAND_DATAVIEW_ITEM_ACTIVATED,dvc->GetId());
1584
1585
1586     event.SetEventObject(dvc);
1587     event.SetItem(wxDataViewItemFromItem([self itemAtRow:[self clickedRow]]));
1588     dvc->GetEventHandler()->ProcessEvent(event);
1589 }
1590
1591
1592 //
1593 // contextual menus
1594 //
1595 -(NSMenu*) menuForEvent:(NSEvent*)theEvent
1596 {
1597     wxUnusedVar(theEvent);
1598
1599     // this method does not do any special menu event handling but only sends
1600     // an event message; therefore, the user has full control if a context
1601     // menu should be shown or not
1602     wxDataViewCtrl* const dvc = implementation->GetDataViewCtrl();
1603
1604     wxDataViewEvent event(wxEVT_COMMAND_DATAVIEW_ITEM_CONTEXT_MENU,dvc->GetId());
1605
1606     wxDataViewItemArray selectedItems;
1607
1608
1609     event.SetEventObject(dvc);
1610     event.SetModel(dvc->GetModel());
1611     // get the item information;
1612     // theoretically more than one ID can be returned but the event can only
1613     // handle one item, therefore only the first item of the array is
1614     // returned:
1615     if (dvc->GetSelections(selectedItems) > 0)
1616         event.SetItem(selectedItems[0]);
1617     dvc->GetEventHandler()->ProcessEvent(event);
1618     // nothing is done:
1619     return nil;
1620 }
1621
1622 //
1623 // delegate methods
1624 //
1625 -(void) outlineView:(NSOutlineView*)outlineView mouseDownInHeaderOfTableColumn:(NSTableColumn*)tableColumn
1626 {
1627     wxDataViewColumn* const col(static_cast<wxDataViewColumn*>([[tableColumn identifier] pointer]));
1628
1629     wxDataViewCtrl* const dvc = implementation->GetDataViewCtrl();
1630
1631     wxDataViewEvent
1632         event(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK,dvc->GetId());
1633
1634
1635     // first, send an event that the user clicked into a column's header:
1636     event.SetEventObject(dvc);
1637     event.SetColumn(dvc->GetColumnPosition(col));
1638     event.SetDataViewColumn(col);
1639     dvc->HandleWindowEvent(event);
1640
1641     // now, check if the click may have had an influence on sorting, too;
1642     // the sorting setup has to be done only if the clicked table column is
1643     // sortable and has not been used for sorting before the click; if the
1644     // column is already responsible for sorting the native control changes
1645     // the sorting direction automatically and informs the data source via
1646     // outlineView:sortDescriptorsDidChange:
1647     if (col->IsSortable() && ([tableColumn sortDescriptorPrototype] == nil))
1648     {
1649         // remove the sort order from the previously sorted column table (it
1650         // can also be that no sorted column table exists):
1651         UInt32 const noOfColumns = [outlineView numberOfColumns];
1652
1653         for (UInt32 i=0; i<noOfColumns; ++i)
1654             [[[outlineView tableColumns] objectAtIndex:i] setSortDescriptorPrototype:nil];
1655         // make column table sortable:
1656         NSArray*          sortDescriptors;
1657         NSSortDescriptor* sortDescriptor;
1658
1659         sortDescriptor = [[NSSortDescriptor alloc] initWithKey:[NSString stringWithFormat:@"%d",[outlineView columnWithIdentifier:[tableColumn identifier]]]
1660             ascending:YES];
1661         sortDescriptors = [NSArray arrayWithObject:sortDescriptor];
1662         [tableColumn setSortDescriptorPrototype:sortDescriptor];
1663         [outlineView setSortDescriptors:sortDescriptors];
1664         [sortDescriptor release];
1665     }
1666 }
1667
1668 -(BOOL) outlineView:(NSOutlineView*)outlineView shouldCollapseItem:(id)item
1669 {
1670     wxUnusedVar(outlineView);
1671
1672     wxDataViewCtrl* const dvc = implementation->GetDataViewCtrl();
1673
1674     wxDataViewEvent event(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSING,dvc->GetId());
1675
1676
1677     event.SetEventObject(dvc);
1678     event.SetItem       (wxDataViewItemFromItem(item));
1679     event.SetModel      (dvc->GetModel());
1680     // finally send the equivalent wxWidget event:
1681     dvc->GetEventHandler()->ProcessEvent(event);
1682     // opening the container is allowed if not vetoed:
1683     return event.IsAllowed();
1684 }
1685
1686 -(BOOL) outlineView:(NSOutlineView*)outlineView shouldExpandItem:(id)item
1687 {
1688     wxUnusedVar(outlineView);
1689
1690     wxDataViewCtrl* const dvc = implementation->GetDataViewCtrl();
1691
1692     wxDataViewEvent event(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDING,dvc->GetId());
1693
1694
1695     event.SetEventObject(dvc);
1696     event.SetItem       (wxDataViewItemFromItem(item));
1697     event.SetModel      (dvc->GetModel());
1698     // finally send the equivalent wxWidget event:
1699     dvc->GetEventHandler()->ProcessEvent(event);
1700     // opening the container is allowed if not vetoed:
1701     return event.IsAllowed();
1702 }
1703
1704 -(BOOL) outlineView:(NSOutlineView*)outlineView shouldSelectTableColumn:(NSTableColumn*)tableColumn
1705 {
1706     wxUnusedVar(tableColumn);
1707     wxUnusedVar(outlineView);
1708
1709     return NO;
1710 }
1711
1712 -(void) outlineView:(wxCocoaOutlineView*)outlineView
1713     willDisplayCell:(id)cell
1714     forTableColumn:(NSTableColumn*)tableColumn
1715     item:(id)item
1716 {
1717     wxUnusedVar(outlineView);
1718
1719     wxDataViewCtrl * const dvc = implementation->GetDataViewCtrl();
1720     wxDataViewModel * const model = dvc->GetModel();
1721
1722     wxDataViewColumn * const
1723         dvCol(static_cast<wxDataViewColumn*>(
1724                     [[tableColumn identifier] pointer]
1725                     )
1726              );
1727     const unsigned colIdx = dvCol->GetModelColumn();
1728
1729     wxDataViewItem dvItem(wxDataViewItemFromItem(item));
1730
1731     if ( !model->HasValue(dvItem, colIdx) )
1732         return;
1733
1734     wxDataViewRenderer * const renderer = dvCol->GetRenderer();
1735     wxDataViewRendererNativeData * const data = renderer->GetNativeData();
1736
1737     // let the renderer know about what it's going to render next
1738     data->SetColumnPtr(tableColumn);
1739     data->SetItem(item);
1740     data->SetItemCell(cell);
1741
1742     // use the attributes: notice that we need to do this whether we have them
1743     // or not as even if this cell doesn't have any attributes, the previous
1744     // one might have had some and then we need to reset them back to default
1745     wxDataViewItemAttr attr;
1746     model->GetAttr(dvItem, colIdx, attr);
1747     renderer->OSXApplyAttr(attr);
1748
1749     // set the state (enabled/disabled) of the item
1750     renderer->OSXApplyEnabled(model->IsEnabled(dvItem, colIdx));
1751
1752     // and finally do draw it
1753     renderer->MacRender();
1754 }
1755
1756 //
1757 // notifications
1758 //
1759 -(void) outlineViewColumnDidMove:(NSNotification*)notification
1760 {
1761     int const newColumnPosition = [[[notification userInfo] objectForKey:@"NSNewColumn"] intValue];
1762
1763     wxDataViewColumn* const col(static_cast<wxDataViewColumn*>([[[[self tableColumns] objectAtIndex:newColumnPosition] identifier] pointer]));
1764
1765     wxDataViewCtrl* const dvc = implementation->GetDataViewCtrl();
1766
1767     wxDataViewEvent event(wxEVT_COMMAND_DATAVIEW_COLUMN_REORDERED,dvc->GetId());
1768
1769
1770     event.SetEventObject(dvc);
1771     event.SetColumn(dvc->GetColumnPosition(col));
1772     event.SetDataViewColumn(col);
1773     dvc->GetEventHandler()->ProcessEvent(event);
1774 }
1775
1776 -(void) outlineViewItemDidCollapse:(NSNotification*)notification
1777 {
1778     wxDataViewCtrl* const dvc = implementation->GetDataViewCtrl();
1779
1780     wxDataViewEvent event(wxEVT_COMMAND_DATAVIEW_ITEM_COLLAPSED,dvc->GetId());
1781
1782
1783     event.SetEventObject(dvc);
1784     event.SetItem(wxDataViewItemFromItem(
1785                     [[notification userInfo] objectForKey:@"NSObject"]));
1786     dvc->GetEventHandler()->ProcessEvent(event);
1787 }
1788
1789 -(void) outlineViewItemDidExpand:(NSNotification*)notification
1790 {
1791     wxDataViewCtrl* const dvc = implementation->GetDataViewCtrl();
1792
1793     wxDataViewEvent event(wxEVT_COMMAND_DATAVIEW_ITEM_EXPANDED,dvc->GetId());
1794
1795
1796     event.SetEventObject(dvc);
1797     event.SetItem(wxDataViewItemFromItem(
1798                     [[notification userInfo] objectForKey:@"NSObject"]));
1799     dvc->GetEventHandler()->ProcessEvent(event);
1800 }
1801
1802 -(void) outlineViewSelectionDidChange:(NSNotification*)notification
1803 {
1804     wxUnusedVar(notification);
1805
1806     wxDataViewCtrl* const dvc = implementation->GetDataViewCtrl();
1807
1808     wxDataViewEvent event(wxEVT_COMMAND_DATAVIEW_SELECTION_CHANGED,dvc->GetId());
1809
1810     event.SetEventObject(dvc);
1811     event.SetModel(dvc->GetModel());
1812     event.SetItem(dvc->GetSelection());
1813     dvc->GetEventHandler()->ProcessEvent(event);
1814 }
1815
1816 -(void) textDidBeginEditing:(NSNotification*)notification
1817 {
1818     // this notification is only sent if the user started modifying the cell
1819     // (not when the user clicked into the cell and the cell's editor is
1820     // called!)
1821
1822     // call method of superclass (otherwise editing does not work correctly -
1823     // the outline data source class is not informed about a change of data):
1824     [super textDidBeginEditing:notification];
1825
1826     // remember the column being edited, it will be used in textDidEndEditing:
1827     currentlyEditedColumn = [self editedColumn];
1828     currentlyEditedRow = [self editedRow];
1829
1830     wxDataViewColumn* const col =
1831         static_cast<wxDataViewColumn*>(
1832                 [[[[self tableColumns] objectAtIndex:currentlyEditedColumn] identifier] pointer]);
1833
1834     wxDataViewCtrl* const dvc = implementation->GetDataViewCtrl();
1835
1836
1837     // stop editing of a custom item first (if necessary)
1838     dvc->FinishCustomItemEditing();
1839
1840     // now, send the event:
1841     wxDataViewEvent
1842         event(wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED,dvc->GetId());
1843
1844     event.SetEventObject(dvc);
1845     event.SetItem(
1846             wxDataViewItemFromItem([self itemAtRow:currentlyEditedRow]));
1847     event.SetColumn(dvc->GetColumnPosition(col));
1848     event.SetDataViewColumn(col);
1849     dvc->GetEventHandler()->ProcessEvent(event);
1850 }
1851
1852 -(void) textDidEndEditing:(NSNotification*)notification
1853 {
1854     // call method of superclass (otherwise editing does not work correctly -
1855     // the outline data source class is not informed about a change of data):
1856     [super textDidEndEditing:notification];
1857
1858     // under OSX an event indicating the end of an editing session can be sent
1859     // even if no event indicating a start of an editing session has been sent
1860     // (see Documentation for NSControl controlTextDidEndEditing:); this is
1861     // not expected by a user of the wxWidgets library and therefore an
1862     // wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE event is only sent if a
1863     // corresponding wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED has been sent
1864     // before; to check if a wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_STARTED has
1865     // been sent the last edited column/row are valid:
1866     if ( currentlyEditedColumn != -1 && currentlyEditedRow != -1 )
1867     {
1868         wxDataViewColumn* const col =
1869             static_cast<wxDataViewColumn*>(
1870                     [[[[self tableColumns] objectAtIndex:currentlyEditedColumn] identifier] pointer]);
1871
1872         wxDataViewCtrl* const dvc = implementation->GetDataViewCtrl();
1873
1874         // send event to wxWidgets:
1875         wxDataViewEvent
1876             event(wxEVT_COMMAND_DATAVIEW_ITEM_EDITING_DONE,dvc->GetId());
1877
1878         event.SetEventObject(dvc);
1879         event.SetItem(
1880                 wxDataViewItemFromItem([self itemAtRow:currentlyEditedRow]));
1881         event.SetColumn(dvc->GetColumnPosition(col));
1882         event.SetDataViewColumn(col);
1883         dvc->GetEventHandler()->ProcessEvent(event);
1884
1885
1886         // we're not editing any more
1887         currentlyEditedColumn =
1888             currentlyEditedRow = -1;
1889     }
1890 }
1891
1892 @end
1893
1894 // ============================================================================
1895 // wxCocoaDataViewControl
1896 // ============================================================================
1897
1898 wxCocoaDataViewControl::wxCocoaDataViewControl(wxWindow* peer,
1899                                                const wxPoint& pos,
1900                                                const wxSize& size,
1901                                                long style)
1902     : wxWidgetCocoaImpl
1903       (
1904         peer,
1905         [[NSScrollView alloc] initWithFrame:wxOSXGetFrameForControl(peer,pos,size)]
1906       ),
1907       m_DataSource(NULL),
1908       m_OutlineView([[wxCocoaOutlineView alloc] init])
1909 {
1910     // initialize scrollview (the outline view is part of a scrollview):
1911     NSScrollView* scrollview = (NSScrollView*) GetWXWidget();
1912
1913     [scrollview setAutoresizingMask:NSViewWidthSizable | NSViewHeightSizable];
1914     [scrollview setBorderType:NSNoBorder];
1915     [scrollview setHasVerticalScroller:YES];
1916     [scrollview setHasHorizontalScroller:YES];
1917     [scrollview setAutohidesScrollers:YES];
1918     [scrollview setDocumentView:m_OutlineView];
1919
1920     // initialize the native control itself too
1921     InitOutlineView(style);
1922 }
1923
1924 void wxCocoaDataViewControl::InitOutlineView(long style)
1925 {
1926     [m_OutlineView setImplementation:this];
1927     [m_OutlineView setColumnAutoresizingStyle:NSTableViewSequentialColumnAutoresizingStyle];
1928     [m_OutlineView setIndentationPerLevel:GetDataViewCtrl()->GetIndent()];
1929     NSUInteger maskGridStyle(NSTableViewGridNone);
1930     if (style & wxDV_HORIZ_RULES)
1931         maskGridStyle |= NSTableViewSolidHorizontalGridLineMask;
1932     if (style & wxDV_VERT_RULES)
1933         maskGridStyle |= NSTableViewSolidVerticalGridLineMask;
1934     [m_OutlineView setGridStyleMask:maskGridStyle];
1935     [m_OutlineView setAllowsMultipleSelection:           (style & wxDV_MULTIPLE)  != 0];
1936     [m_OutlineView setUsesAlternatingRowBackgroundColors:(style & wxDV_ROW_LINES) != 0];
1937
1938     if ( style & wxDV_NO_HEADER )
1939         [m_OutlineView setHeaderView:nil];
1940 }
1941
1942 wxCocoaDataViewControl::~wxCocoaDataViewControl()
1943 {
1944     [m_DataSource  release];
1945     [m_OutlineView release];
1946 }
1947
1948 //
1949 // column related methods (inherited from wxDataViewWidgetImpl)
1950 //
1951 bool wxCocoaDataViewControl::ClearColumns()
1952 {
1953     // as there is a bug in NSOutlineView version (OSX 10.5.6 #6555162) the
1954     // columns cannot be deleted if there is an outline column in the view;
1955     // therefore, the whole view is deleted and newly constructed:
1956     [m_OutlineView release];
1957     m_OutlineView = [[wxCocoaOutlineView alloc] init];
1958     [((NSScrollView*) GetWXWidget()) setDocumentView:m_OutlineView];
1959     [m_OutlineView setDataSource:m_DataSource];
1960
1961     InitOutlineView(GetDataViewCtrl()->GetWindowStyle());
1962
1963     return true;
1964 }
1965
1966 bool wxCocoaDataViewControl::DeleteColumn(wxDataViewColumn* columnPtr)
1967 {
1968     if ([m_OutlineView outlineTableColumn] == columnPtr->GetNativeData()->GetNativeColumnPtr())
1969         [m_OutlineView setOutlineTableColumn:nil]; // due to a bug this does not work
1970     [m_OutlineView removeTableColumn:columnPtr->GetNativeData()->GetNativeColumnPtr()]; // due to a confirmed bug #6555162 the deletion does not work for
1971     // outline table columns (... and there is no workaround)
1972     return (([m_OutlineView columnWithIdentifier:[[[wxPointerObject alloc] initWithPointer:columnPtr] autorelease]]) == -1);
1973 }
1974
1975 void wxCocoaDataViewControl::DoSetExpanderColumn(const wxDataViewColumn *columnPtr)
1976 {
1977     [m_OutlineView setOutlineTableColumn:columnPtr->GetNativeData()->GetNativeColumnPtr()];
1978 }
1979
1980 wxDataViewColumn* wxCocoaDataViewControl::GetColumn(unsigned int pos) const
1981 {
1982     return static_cast<wxDataViewColumn*>([[[[m_OutlineView tableColumns] objectAtIndex:pos] identifier] pointer]);
1983 }
1984
1985 int wxCocoaDataViewControl::GetColumnPosition(const wxDataViewColumn *columnPtr) const
1986 {
1987     return [m_OutlineView columnWithIdentifier:[[[wxPointerObject alloc] initWithPointer:const_cast<wxDataViewColumn*>(columnPtr)] autorelease]];
1988 }
1989
1990 bool wxCocoaDataViewControl::InsertColumn(unsigned int pos, wxDataViewColumn* columnPtr)
1991 {
1992     // create column and set the native data of the dataview column:
1993     NSTableColumn *nativeColumn = ::CreateNativeColumn(columnPtr);
1994     columnPtr->GetNativeData()->SetNativeColumnPtr(nativeColumn);
1995     // as the native control does not allow the insertion of a column at a
1996     // specified position the column is first appended and - if necessary -
1997     // moved to its final position:
1998     [m_OutlineView addTableColumn:nativeColumn];
1999     if (pos != static_cast<unsigned int>([m_OutlineView numberOfColumns]-1))
2000         [m_OutlineView moveColumn:[m_OutlineView numberOfColumns]-1 toColumn:pos];
2001
2002     // set columns width now that it can be computed even for autosized columns:
2003     columnPtr->SetWidth(columnPtr->GetWidthVariable());
2004
2005     // done:
2006     return true;
2007 }
2008
2009 void wxCocoaDataViewControl::FitColumnWidthToContent(unsigned int pos)
2010 {
2011 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
2012     const int count = GetCount();
2013     NSTableColumn *column = GetColumn(pos)->GetNativeData()->GetNativeColumnPtr();
2014
2015     class MaxWidthCalculator
2016     {
2017     public:
2018         MaxWidthCalculator(wxCocoaOutlineView *view,
2019                            NSTableColumn *column, unsigned columnIndex)
2020             : m_width(0),
2021               m_view(view),
2022               m_column(columnIndex),
2023               m_indent(0)
2024         {
2025             // account for indentation in the column with expander
2026             if ( column == [m_view outlineTableColumn] )
2027                 m_indent = [m_view indentationPerLevel];
2028         }
2029
2030         void UpdateWithWidth(int width)
2031         {
2032             m_width = wxMax(m_width, width);
2033         }
2034
2035         void UpdateWithRow(int row)
2036         {
2037             NSCell *cell = [m_view preparedCellAtColumn:m_column row:row];
2038             unsigned cellWidth = [cell cellSize].width + 1/*round the float up*/;
2039
2040             if ( m_indent )
2041                 cellWidth += m_indent * ([m_view levelForRow:row] + 1);
2042
2043             m_width = wxMax(m_width, cellWidth);
2044         }
2045
2046         int GetMaxWidth() const { return m_width; }
2047
2048     private:
2049         int m_width;
2050         wxCocoaOutlineView *m_view;
2051         unsigned m_column;
2052         int m_indent;
2053     };
2054
2055     MaxWidthCalculator calculator(m_OutlineView, column, pos);
2056
2057     if ( [column headerCell] )
2058     {
2059         calculator.UpdateWithWidth([[column headerCell] cellSize].width + 1/*round the float up*/);
2060     }
2061
2062     // The code below deserves some explanation. For very large controls, we
2063     // simply can't afford to calculate sizes for all items, it takes too
2064     // long. So the best we can do is to check the first and the last N/2
2065     // items in the control for some sufficiently large N and calculate best
2066     // sizes from that. That can result in the calculated best width being too
2067     // small for some outliers, but it's better to get slightly imperfect
2068     // result than to wait several seconds after every update. To avoid highly
2069     // visible miscalculations, we also include all currently visible items
2070     // no matter what.  Finally, the value of N is determined dynamically by
2071     // measuring how much time we spent on the determining item widths so far.
2072
2073 #if wxUSE_STOPWATCH
2074     int top_part_end = count;
2075     static const long CALC_TIMEOUT = 20/*ms*/;
2076     // don't call wxStopWatch::Time() too often
2077     static const unsigned CALC_CHECK_FREQ = 100;
2078     wxStopWatch timer;
2079 #else
2080     // use some hard-coded limit, that's the best we can do without timer
2081     int top_part_end = wxMin(500, count);
2082 #endif // wxUSE_STOPWATCH/!wxUSE_STOPWATCH
2083
2084     int row = 0;
2085
2086     for ( row = 0; row < top_part_end; row++ )
2087     {
2088 #if wxUSE_STOPWATCH
2089         if ( row % CALC_CHECK_FREQ == CALC_CHECK_FREQ-1 &&
2090              timer.Time() > CALC_TIMEOUT )
2091             break;
2092 #endif // wxUSE_STOPWATCH
2093         calculator.UpdateWithRow(row);
2094     }
2095
2096     // row is the first unmeasured item now; that's our value of N/2
2097
2098     if ( row < count )
2099     {
2100         top_part_end = row;
2101
2102         // add bottom N/2 items now:
2103         const int bottom_part_start = wxMax(row, count - row);
2104         for ( row = bottom_part_start; row < count; row++ )
2105             calculator.UpdateWithRow(row);
2106
2107         // finally, include currently visible items in the calculation:
2108         const NSRange visible = [m_OutlineView rowsInRect:[m_OutlineView visibleRect]];
2109         const int first_visible = wxMax(visible.location, top_part_end);
2110         const int last_visible = wxMin(first_visible + visible.length, bottom_part_start);
2111
2112         for ( row = first_visible; row < last_visible; row++ )
2113             calculator.UpdateWithRow(row);
2114
2115         wxLogTrace("dataview",
2116                    "determined best size from %d top, %d bottom plus %d more visible items out of %d total",
2117                    top_part_end,
2118                    count - bottom_part_start,
2119                    wxMax(0, last_visible - first_visible),
2120                    count);
2121     }
2122
2123     [column setWidth:calculator.GetMaxWidth()];
2124 #endif // MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
2125 }
2126
2127 //
2128 // item related methods (inherited from wxDataViewWidgetImpl)
2129 //
2130 bool wxCocoaDataViewControl::Add(const wxDataViewItem& parent, const wxDataViewItem& WXUNUSED(item))
2131 {
2132     if (parent.IsOk())
2133         [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:parent] reloadChildren:YES];
2134     else
2135         [m_OutlineView reloadData];
2136     return true;
2137 }
2138
2139 bool wxCocoaDataViewControl::Add(const wxDataViewItem& parent, const wxDataViewItemArray& WXUNUSED(items))
2140 {
2141     if (parent.IsOk())
2142         [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:parent] reloadChildren:YES];
2143     else
2144         [m_OutlineView reloadData];
2145     return true;
2146 }
2147
2148 void wxCocoaDataViewControl::Collapse(const wxDataViewItem& item)
2149 {
2150     [m_OutlineView collapseItem:[m_DataSource getDataViewItemFromBuffer:item]];
2151 }
2152
2153 void wxCocoaDataViewControl::EnsureVisible(const wxDataViewItem& item, const wxDataViewColumn *columnPtr)
2154 {
2155     if (item.IsOk())
2156     {
2157         [m_OutlineView scrollRowToVisible:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]];
2158         if (columnPtr)
2159             [m_OutlineView scrollColumnToVisible:GetColumnPosition(columnPtr)];
2160     }
2161 }
2162
2163 void wxCocoaDataViewControl::Expand(const wxDataViewItem& item)
2164 {
2165     [m_OutlineView expandItem:[m_DataSource getDataViewItemFromBuffer:item]];
2166 }
2167
2168 unsigned int wxCocoaDataViewControl::GetCount() const
2169 {
2170     return [m_OutlineView numberOfRows];
2171 }
2172
2173 wxRect wxCocoaDataViewControl::GetRectangle(const wxDataViewItem& item, const wxDataViewColumn *columnPtr)
2174 {
2175     return wxFromNSRect([m_osxView superview],[m_OutlineView frameOfCellAtColumn:GetColumnPosition(columnPtr)
2176             row:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]]);
2177 }
2178
2179 bool wxCocoaDataViewControl::IsExpanded(const wxDataViewItem& item) const
2180 {
2181     return [m_OutlineView isItemExpanded:[m_DataSource getDataViewItemFromBuffer:item]];
2182 }
2183
2184 bool wxCocoaDataViewControl::Reload()
2185 {
2186     [m_DataSource clearBuffers];
2187     [m_OutlineView reloadData];
2188     [m_OutlineView scrollColumnToVisible:0];
2189     [m_OutlineView scrollRowToVisible:0];
2190     return true;
2191 }
2192
2193 bool wxCocoaDataViewControl::Remove(const wxDataViewItem& parent, const wxDataViewItem& WXUNUSED(item))
2194 {
2195     if (parent.IsOk())
2196         [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:parent] reloadChildren:YES];
2197     else
2198         [m_OutlineView reloadData];
2199     return true;
2200 }
2201
2202 bool wxCocoaDataViewControl::Remove(const wxDataViewItem& parent, const wxDataViewItemArray& WXUNUSED(item))
2203 {
2204     if (parent.IsOk())
2205         [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:parent] reloadChildren:YES];
2206     else
2207         [m_OutlineView reloadData];
2208     return true;
2209 }
2210
2211 bool wxCocoaDataViewControl::Update(const wxDataViewColumn *columnPtr)
2212 {
2213     wxUnusedVar(columnPtr);
2214
2215     return false;
2216 }
2217
2218 bool wxCocoaDataViewControl::Update(const wxDataViewItem& WXUNUSED(parent), const wxDataViewItem& item)
2219 {
2220     [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:item]];
2221     return true;
2222 }
2223
2224 bool wxCocoaDataViewControl::Update(const wxDataViewItem& WXUNUSED(parent), const wxDataViewItemArray& items)
2225 {
2226     for (size_t i=0; i<items.GetCount(); ++i)
2227         [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:items[i]]];
2228     return true;
2229 }
2230
2231 //
2232 // model related methods
2233 //
2234 bool wxCocoaDataViewControl::AssociateModel(wxDataViewModel* model)
2235 {
2236     [m_DataSource release];
2237     if (model)
2238     {
2239         m_DataSource = [[wxCocoaOutlineDataSource alloc] init];
2240         [m_DataSource setImplementation:this];
2241         [m_DataSource setModel:model];
2242     }
2243     else
2244         m_DataSource = NULL;
2245     [m_OutlineView setDataSource:m_DataSource]; // if there is a data source the data is immediately going to be requested
2246     return true;
2247 }
2248
2249 //
2250 // selection related methods (inherited from wxDataViewWidgetImpl)
2251 //
2252
2253 wxDataViewItem wxCocoaDataViewControl::GetCurrentItem() const
2254 {
2255     return wxDataViewItem([[m_OutlineView itemAtRow:[m_OutlineView selectedRow]] pointer]);
2256 }
2257
2258 void wxCocoaDataViewControl::SetCurrentItem(const wxDataViewItem& item)
2259 {
2260     // We can't have unselected current item in a NSTableView, as the
2261     // documentation of its deselectRow method explains, the control will
2262     // automatically change the current item to the closest still selected item
2263     // if the current item is deselected. So we have no choice but to select
2264     // the item in the same time as making it current.
2265     Select(item);
2266 }
2267
2268 int wxCocoaDataViewControl::GetSelectedItemsCount() const
2269 {
2270     return [m_OutlineView numberOfSelectedRows];
2271 }
2272
2273 int wxCocoaDataViewControl::GetSelections(wxDataViewItemArray& sel) const
2274 {
2275     NSIndexSet* selectedRowIndexes([m_OutlineView selectedRowIndexes]);
2276
2277     NSUInteger indexRow;
2278
2279
2280     sel.Empty();
2281     sel.Alloc([selectedRowIndexes count]);
2282     indexRow = [selectedRowIndexes firstIndex];
2283     while (indexRow != NSNotFound)
2284     {
2285         sel.Add(wxDataViewItem([[m_OutlineView itemAtRow:indexRow] pointer]));
2286         indexRow = [selectedRowIndexes indexGreaterThanIndex:indexRow];
2287     }
2288     return sel.GetCount();
2289 }
2290
2291 bool wxCocoaDataViewControl::IsSelected(const wxDataViewItem& item) const
2292 {
2293     return [m_OutlineView isRowSelected:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]];
2294 }
2295
2296 void wxCocoaDataViewControl::Select(const wxDataViewItem& item)
2297 {
2298     if (item.IsOk())
2299         [m_OutlineView selectRowIndexes:[NSIndexSet indexSetWithIndex:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]]
2300             byExtendingSelection:GetDataViewCtrl()->HasFlag(wxDV_MULTIPLE) ? YES : NO];
2301 }
2302
2303 void wxCocoaDataViewControl::SelectAll()
2304 {
2305     [m_OutlineView selectAll:m_OutlineView];
2306 }
2307
2308 void wxCocoaDataViewControl::Unselect(const wxDataViewItem& item)
2309 {
2310     if (item.IsOk())
2311         [m_OutlineView deselectRow:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]];
2312 }
2313
2314 void wxCocoaDataViewControl::UnselectAll()
2315 {
2316     [m_OutlineView deselectAll:m_OutlineView];
2317 }
2318
2319 //
2320 // sorting related methods
2321 //
2322 wxDataViewColumn* wxCocoaDataViewControl::GetSortingColumn() const
2323 {
2324     NSArray* const columns = [m_OutlineView tableColumns];
2325
2326     UInt32 const noOfColumns = [columns count];
2327
2328
2329     for (UInt32 i=0; i<noOfColumns; ++i)
2330         if ([[columns objectAtIndex:i] sortDescriptorPrototype] != nil)
2331             return static_cast<wxDataViewColumn*>([[[columns objectAtIndex:i] identifier] pointer]);
2332     return NULL;
2333 }
2334
2335 void wxCocoaDataViewControl::Resort()
2336 {
2337     [m_DataSource clearChildren];
2338     [m_OutlineView reloadData];
2339 }
2340
2341 void wxCocoaDataViewControl::StartEditor( const wxDataViewItem & item, unsigned int column )
2342 {
2343     [m_OutlineView editColumn:column row:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]] withEvent:nil select:YES];
2344 }
2345
2346 //
2347 // other methods (inherited from wxDataViewWidgetImpl)
2348 //
2349 void wxCocoaDataViewControl::DoSetIndent(int indent)
2350 {
2351     [m_OutlineView setIndentationPerLevel:static_cast<CGFloat>(indent)];
2352 }
2353
2354 void wxCocoaDataViewControl::HitTest(const wxPoint& point, wxDataViewItem& item, wxDataViewColumn*& columnPtr) const
2355 {
2356     NSPoint const nativePoint = wxToNSPoint((NSScrollView*) GetWXWidget(),point);
2357
2358     int indexColumn;
2359     int indexRow;
2360
2361
2362     indexColumn = [m_OutlineView columnAtPoint:nativePoint];
2363     indexRow    = [m_OutlineView rowAtPoint:   nativePoint];
2364     if ((indexColumn >= 0) && (indexRow >= 0))
2365     {
2366         columnPtr = static_cast<wxDataViewColumn*>([[[[m_OutlineView tableColumns] objectAtIndex:indexColumn] identifier] pointer]);
2367         item      = wxDataViewItem([[m_OutlineView itemAtRow:indexRow] pointer]);
2368     }
2369     else
2370     {
2371         columnPtr = NULL;
2372         item      = wxDataViewItem();
2373     }
2374 }
2375
2376 void wxCocoaDataViewControl::SetRowHeight(const wxDataViewItem& WXUNUSED(item), unsigned int WXUNUSED(height))
2377     // Not supported by the native control
2378 {
2379 }
2380
2381 void wxCocoaDataViewControl::OnSize()
2382 {
2383     if ([m_OutlineView numberOfColumns] == 1)
2384         [m_OutlineView sizeLastColumnToFit];
2385 }
2386
2387 //
2388 // drag & drop helper methods
2389 //
2390 wxDataFormat wxCocoaDataViewControl::GetDnDDataFormat(wxDataObjectComposite* dataObjects)
2391 {
2392     wxDataFormat resultFormat;
2393     if ( !dataObjects )
2394         return resultFormat;
2395
2396     bool compatible(true);
2397
2398     size_t const noOfFormats = dataObjects->GetFormatCount();
2399     size_t       indexFormat;
2400
2401     wxDataFormat* formats;
2402
2403     // get all formats and check afterwards if the formats are compatible; if
2404     // they are compatible the preferred format is returned otherwise
2405     // wxDF_INVALID is returned;
2406     // currently compatible types (ordered by priority are):
2407     //  - wxDF_UNICODETEXT - wxDF_TEXT
2408     formats = new wxDataFormat[noOfFormats];
2409     dataObjects->GetAllFormats(formats);
2410     indexFormat = 0;
2411     while ((indexFormat < noOfFormats) && compatible)
2412     {
2413         switch (resultFormat.GetType())
2414         {
2415             case wxDF_INVALID:
2416                 resultFormat.SetType(formats[indexFormat].GetType()); // first format (should only be reached if indexFormat == 0)
2417                 break;
2418             case wxDF_TEXT:
2419                 if (formats[indexFormat].GetType() == wxDF_UNICODETEXT)
2420                     resultFormat.SetType(wxDF_UNICODETEXT);
2421                 else // incompatible
2422                 {
2423                     resultFormat.SetType(wxDF_INVALID);
2424                     compatible = false;
2425                 }
2426                 break;
2427             case wxDF_UNICODETEXT:
2428                 if (formats[indexFormat].GetType() != wxDF_TEXT)
2429                 {
2430                     resultFormat.SetType(wxDF_INVALID);
2431                     compatible = false;
2432                 }
2433                 break;
2434             default:
2435                 resultFormat.SetType(wxDF_INVALID); // not (yet) supported format
2436                 compatible = false;
2437         }
2438         ++indexFormat;
2439     }
2440
2441     delete[] formats;
2442
2443     return resultFormat;
2444 }
2445
2446 wxDataObjectComposite* wxCocoaDataViewControl::GetDnDDataObjects(NSData* dataObject) const
2447 {
2448     wxDataFormatId dataFormatID;
2449
2450
2451     [dataObject getBytes:&dataFormatID length:sizeof(wxDataFormatId)];
2452     switch (dataFormatID)
2453     {
2454         case wxDF_TEXT:
2455         case wxDF_UNICODETEXT:
2456             {
2457                 wxTextDataObject* textDataObject(new wxTextDataObject());
2458
2459                 if (textDataObject->SetData(wxDataFormat(dataFormatID),[dataObject length]-sizeof(wxDataFormatId),static_cast<char const*>([dataObject bytes])+sizeof(wxDataFormatId)))
2460                 {
2461                     wxDataObjectComposite* dataObjectComposite(new wxDataObjectComposite());
2462
2463                     dataObjectComposite->Add(textDataObject);
2464                     return dataObjectComposite;
2465                 }
2466                 else
2467                 {
2468                     delete textDataObject;
2469                     return NULL;
2470                 }
2471             }
2472             break;
2473         default:
2474             return NULL;
2475     }
2476 }
2477
2478 id wxCocoaDataViewControl::GetItemAtRow(int row) const
2479 {
2480     return [m_OutlineView itemAtRow:row];
2481 }
2482
2483 // ----------------------------------------------------------------------------
2484 // wxDataViewRendererNativeData
2485 // ----------------------------------------------------------------------------
2486
2487 void wxDataViewRendererNativeData::Init()
2488 {
2489     m_origFont = NULL;
2490     m_origTextColour = NULL;
2491     m_ellipsizeMode = wxELLIPSIZE_MIDDLE;
2492
2493     if ( m_ColumnCell )
2494         ApplyLineBreakMode(m_ColumnCell);
2495 }
2496
2497 void wxDataViewRendererNativeData::ApplyLineBreakMode(NSCell *cell)
2498 {
2499     NSLineBreakMode nsMode = NSLineBreakByWordWrapping;
2500     switch ( m_ellipsizeMode )
2501     {
2502         case wxELLIPSIZE_NONE:
2503             nsMode = NSLineBreakByClipping;
2504             break;
2505
2506         case wxELLIPSIZE_START:
2507             nsMode = NSLineBreakByTruncatingHead;
2508             break;
2509
2510         case wxELLIPSIZE_MIDDLE:
2511             nsMode = NSLineBreakByTruncatingMiddle;
2512             break;
2513
2514         case wxELLIPSIZE_END:
2515             nsMode = NSLineBreakByTruncatingTail;
2516             break;
2517     }
2518
2519     wxASSERT_MSG( nsMode != NSLineBreakByWordWrapping, "unknown wxEllipsizeMode" );
2520
2521     [cell setLineBreakMode: nsMode];
2522 }
2523
2524 // ---------------------------------------------------------
2525 // wxDataViewRenderer
2526 // ---------------------------------------------------------
2527
2528 wxDataViewRenderer::wxDataViewRenderer(const wxString& varianttype,
2529                                        wxDataViewCellMode mode,
2530                                        int align)
2531     : wxDataViewRendererBase(varianttype, mode, align),
2532       m_alignment(align),
2533       m_mode(mode),
2534       m_NativeDataPtr(NULL)
2535 {
2536 }
2537
2538 wxDataViewRenderer::~wxDataViewRenderer()
2539 {
2540     delete m_NativeDataPtr;
2541 }
2542
2543 void wxDataViewRenderer::SetAlignment(int align)
2544 {
2545     m_alignment = align;
2546     [GetNativeData()->GetColumnCell() setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2547 }
2548
2549 void wxDataViewRenderer::SetMode(wxDataViewCellMode mode)
2550 {
2551     m_mode = mode;
2552     if ( GetOwner() )
2553         [GetOwner()->GetNativeData()->GetNativeColumnPtr() setEditable:(mode == wxDATAVIEW_CELL_EDITABLE)];
2554 }
2555
2556 void wxDataViewRenderer::SetNativeData(wxDataViewRendererNativeData* newNativeDataPtr)
2557 {
2558     delete m_NativeDataPtr;
2559     m_NativeDataPtr = newNativeDataPtr;
2560 }
2561
2562 void wxDataViewRenderer::EnableEllipsize(wxEllipsizeMode mode)
2563 {
2564     // we need to store this value to apply it to the columns headerCell in
2565     // CreateNativeColumn()
2566     GetNativeData()->SetEllipsizeMode(mode);
2567
2568     // but we may already apply it to the column cell which will be used for
2569     // this column
2570     GetNativeData()->ApplyLineBreakMode(GetNativeData()->GetColumnCell());
2571 }
2572
2573 wxEllipsizeMode wxDataViewRenderer::GetEllipsizeMode() const
2574 {
2575     return GetNativeData()->GetEllipsizeMode();
2576 }
2577
2578 void
2579 wxDataViewRenderer::OSXOnCellChanged(NSObject *object,
2580                                      const wxDataViewItem& item,
2581                                      unsigned col)
2582 {
2583     // TODO: we probably should get rid of this code entirely and make this
2584     //       function pure virtual, but currently we still have some native
2585     //       renderers (wxDataViewChoiceRenderer) which don't override it and
2586     //       there is also wxDataViewCustomRenderer for which it's not obvious
2587     //       how it should be implemented so keep this "auto-deduction" of
2588     //       variant type from NSObject for now
2589
2590     wxVariant value;
2591     if ( [object isKindOfClass:[NSString class]] )
2592         value = ObjectToString(object);
2593     else if ( [object isKindOfClass:[NSNumber class]] )
2594         value = ObjectToLong(object);
2595     else if ( [object isKindOfClass:[NSDate class]] )
2596         value = ObjectToDate(object);
2597     else
2598     {
2599         wxFAIL_MSG( wxString::Format
2600                     (
2601                      "unknown value type %s",
2602                      wxCFStringRef::AsString([object className])
2603                     ));
2604         return;
2605     }
2606
2607     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
2608     model->ChangeValue(value, item, col);
2609 }
2610
2611 void wxDataViewRenderer::OSXApplyAttr(const wxDataViewItemAttr& attr)
2612 {
2613     wxDataViewRendererNativeData * const data = GetNativeData();
2614     NSCell * const cell = data->GetItemCell();
2615
2616     // set the font and text colour to use: we need to do it if we had ever
2617     // changed them before, even if this item itself doesn't have any special
2618     // attributes as otherwise it would reuse the attributes from the previous
2619     // cell rendered using the same renderer
2620     NSFont *font = NULL;
2621     NSColor *colText = NULL;
2622
2623     if ( attr.HasFont() )
2624     {
2625         font = data->GetOriginalFont();
2626         if ( !font )
2627         {
2628             // this is the first time we're setting the font, remember the
2629             // original one before changing it
2630             font = [cell font];
2631             data->SaveOriginalFont(font);
2632         }
2633
2634         if ( font )
2635         {
2636             // FIXME: using wxFont methods here doesn't work for some reason
2637             NSFontManager * const fm = [NSFontManager sharedFontManager];
2638             if ( attr.GetBold() )
2639                 font = [fm convertFont:font toHaveTrait:NSBoldFontMask];
2640             if ( attr.GetItalic() )
2641                 font = [fm convertFont:font toHaveTrait:NSItalicFontMask];
2642         }
2643         //else: can't change font if the cell doesn't have any
2644     }
2645
2646     if ( attr.HasColour() )
2647     {
2648         // we can set font for any cell but only NSTextFieldCell provides
2649         // a method for setting text colour so check that this method is
2650         // available before using it
2651         if ( [cell respondsToSelector:@selector(setTextColor:)] &&
2652                 [cell respondsToSelector:@selector(textColor)] )
2653         {
2654             if ( !data->GetOriginalTextColour() )
2655             {
2656                 // the cast to (untyped) id is safe because of the check above
2657                 data->SaveOriginalTextColour([(id)cell textColor]);
2658             }
2659
2660             const wxColour& c = attr.GetColour();
2661             colText = [NSColor colorWithDeviceRed:c.Red() / 255.
2662                 green:c.Green() / 255.
2663                 blue:c.Blue() / 255.
2664                 alpha:c.Alpha() / 255.];
2665         }
2666     }
2667
2668     if ( !font )
2669         font = data->GetOriginalFont();
2670     if ( !colText )
2671         colText = data->GetOriginalTextColour();
2672
2673     if ( font )
2674         [cell setFont:font];
2675
2676     if ( colText )
2677         [(id)cell setTextColor:colText];
2678 }
2679
2680 void wxDataViewRenderer::OSXApplyEnabled(bool enabled)
2681 {
2682     [GetNativeData()->GetItemCell() setEnabled:enabled];
2683 }
2684
2685 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer,wxDataViewRendererBase)
2686
2687 // ---------------------------------------------------------
2688 // wxDataViewCustomRenderer
2689 // ---------------------------------------------------------
2690 wxDataViewCustomRenderer::wxDataViewCustomRenderer(const wxString& varianttype,
2691                                                    wxDataViewCellMode mode,
2692                                                    int align)
2693     : wxDataViewCustomRendererBase(varianttype, mode, align),
2694       m_editorCtrlPtr(NULL),
2695       m_DCPtr(NULL)
2696 {
2697     SetNativeData(new wxDataViewRendererNativeData([[wxCustomCell alloc] init]));
2698 }
2699
2700 bool wxDataViewCustomRenderer::MacRender()
2701 {
2702     [GetNativeData()->GetItemCell() setObjectValue:[[[wxCustomRendererObject alloc] initWithRenderer:this] autorelease]];
2703     return true;
2704 }
2705
2706 void wxDataViewCustomRenderer::OSXApplyAttr(const wxDataViewItemAttr& attr)
2707 {
2708     // simply save the attribute so that it could be reused from our Render()
2709     SetAttr(attr);
2710
2711     // it's not necessary to call the base class version which sets the cell
2712     // properties to correspond to this attribute because we currently don't
2713     // use any NSCell methods in custom renderers anyhow but if we ever start
2714     // doing this (e.g. override RenderText() here to use NSTextFieldCell
2715     // methods), then we should pass it on to wxDataViewRenderer here
2716 }
2717
2718 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
2719
2720 // ---------------------------------------------------------
2721 // wxDataViewTextRenderer
2722 // ---------------------------------------------------------
2723 wxDataViewTextRenderer::wxDataViewTextRenderer(const wxString& varianttype,
2724                                                wxDataViewCellMode mode,
2725                                                int align)
2726     : wxDataViewRenderer(varianttype,mode,align)
2727 {
2728     NSTextFieldCell* cell;
2729
2730
2731     cell = [[NSTextFieldCell alloc] init];
2732     [cell setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2733     SetNativeData(new wxDataViewRendererNativeData(cell));
2734     [cell release];
2735 }
2736
2737 bool wxDataViewTextRenderer::MacRender()
2738 {
2739     if (GetValue().GetType() == GetVariantType())
2740     {
2741         [GetNativeData()->GetItemCell() setObjectValue:wxCFStringRef(GetValue().GetString()).AsNSString()];
2742         return true;
2743     }
2744     else
2745     {
2746         wxFAIL_MSG(wxString("Text renderer cannot render value because of wrong value type; value type: ") << GetValue().GetType());
2747         return false;
2748     }
2749 }
2750
2751 void
2752 wxDataViewTextRenderer::OSXOnCellChanged(NSObject *value,
2753                                          const wxDataViewItem& item,
2754                                          unsigned col)
2755 {
2756     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
2757     model->ChangeValue(ObjectToString(value), item, col);
2758 }
2759
2760 IMPLEMENT_CLASS(wxDataViewTextRenderer,wxDataViewRenderer)
2761
2762 // ---------------------------------------------------------
2763 // wxDataViewBitmapRenderer
2764 // ---------------------------------------------------------
2765 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer(const wxString& varianttype,
2766                                                    wxDataViewCellMode mode,
2767                                                    int align)
2768     : wxDataViewRenderer(varianttype,mode,align)
2769 {
2770     NSImageCell* cell;
2771
2772
2773     cell = [[NSImageCell alloc] init];
2774     SetNativeData(new wxDataViewRendererNativeData(cell));
2775     [cell release];
2776 }
2777
2778 // This method returns 'true' if
2779 //  - the passed bitmap is valid and it could be assigned to the native data
2780 //  browser;
2781 //  - the passed bitmap is invalid (or is not initialized); this case
2782 //  simulates a non-existing bitmap.
2783 // In all other cases the method returns 'false'.
2784 bool wxDataViewBitmapRenderer::MacRender()
2785 {
2786     wxCHECK_MSG(GetValue().GetType() == GetVariantType(),false,wxString("Bitmap renderer cannot render value; value type: ") << GetValue().GetType());
2787
2788     wxBitmap bitmap;
2789
2790     bitmap << GetValue();
2791     if (bitmap.IsOk())
2792         [GetNativeData()->GetItemCell() setObjectValue:[[bitmap.GetNSImage() retain] autorelease]];
2793     return true;
2794 }
2795
2796 IMPLEMENT_CLASS(wxDataViewBitmapRenderer,wxDataViewRenderer)
2797
2798 // -------------------------------------
2799 // wxDataViewChoiceRenderer
2800 // -------------------------------------
2801 wxDataViewChoiceRenderer::wxDataViewChoiceRenderer(const wxArrayString& choices,
2802                                                    wxDataViewCellMode mode,
2803                                                    int alignment)
2804     : wxDataViewRenderer(wxT("string"), mode, alignment),
2805       m_choices(choices)
2806 {
2807     NSPopUpButtonCell* cell;
2808
2809
2810     cell = [[NSPopUpButtonCell alloc] init];
2811     [cell setControlSize:NSMiniControlSize];
2812     [cell setFont:[NSFont fontWithName:[[cell font] fontName] size:[NSFont systemFontSizeForControlSize:NSMiniControlSize]]];
2813     for (size_t i=0; i<choices.GetCount(); ++i)
2814         [cell addItemWithTitle:wxCFStringRef(choices[i]).AsNSString()];
2815     SetNativeData(new wxDataViewRendererNativeData(cell));
2816     [cell release];
2817 }
2818
2819 bool wxDataViewChoiceRenderer::MacRender()
2820 {
2821     if (GetValue().GetType() == GetVariantType())
2822     {
2823         [((NSPopUpButtonCell*) GetNativeData()->GetItemCell()) selectItemWithTitle:[[wxCFStringRef(GetValue().GetString()).AsNSString() retain] autorelease]];
2824         return true;
2825     }
2826     else
2827     {
2828         wxFAIL_MSG(wxString("Choice renderer cannot render value because of wrong value type; value type: ") << GetValue().GetType());
2829         return false;
2830     }
2831 }
2832
2833 IMPLEMENT_CLASS(wxDataViewChoiceRenderer,wxDataViewRenderer)
2834
2835 // ---------------------------------------------------------
2836 // wxDataViewDateRenderer
2837 // ---------------------------------------------------------
2838
2839 wxDataViewDateRenderer::wxDataViewDateRenderer(const wxString& varianttype,
2840                                                wxDataViewCellMode mode,
2841                                                int align)
2842     : wxDataViewRenderer(varianttype,mode,align)
2843 {
2844     NSTextFieldCell* cell;
2845
2846     NSDateFormatter* dateFormatter;
2847
2848
2849     dateFormatter = [[NSDateFormatter alloc] init];
2850     [dateFormatter setFormatterBehavior:NSDateFormatterBehavior10_4];
2851     [dateFormatter setDateStyle:NSDateFormatterShortStyle];
2852     cell = [[NSTextFieldCell alloc] init];
2853     [cell setFormatter:dateFormatter];
2854     SetNativeData(new wxDataViewRendererNativeData(cell,[NSDate dateWithString:@"2000-12-30 20:00:00 +0000"]));
2855     [cell          release];
2856     [dateFormatter release];
2857 }
2858
2859 bool wxDataViewDateRenderer::MacRender()
2860 {
2861     if (GetValue().GetType() == GetVariantType())
2862     {
2863         if (GetValue().GetDateTime().IsValid())
2864         {
2865             // -- find best fitting style to show the date --
2866             // as the style should be identical for all cells a reference date
2867             // instead of the actual cell's date value is used for all cells;
2868             // this reference date is stored in the renderer's native data
2869             // section for speed purposes; otherwise, the reference date's
2870             // string has to be recalculated for each item that may become
2871             // timewise long if a lot of rows using dates exist; the algorithm
2872             // has the preference to display as much information as possible
2873             // in the first instance; but as this is often impossible due to
2874             // space restrictions the style is shortened per loop; finally, if
2875             // the shortest time and date format does not fit into the cell
2876             // the time part is dropped; remark: the time part itself is not
2877             // modified per iteration loop and only uses the short style,
2878             // means that only the hours and minutes are being shown
2879
2880             // GetObject() returns a date for testing the size of a date object
2881             [GetNativeData()->GetItemCell() setObjectValue:GetNativeData()->GetObject()];
2882             [[GetNativeData()->GetItemCell() formatter] setTimeStyle:NSDateFormatterShortStyle];
2883             for (int dateFormatterStyle=4; dateFormatterStyle>0; --dateFormatterStyle)
2884             {
2885                 [[GetNativeData()->GetItemCell() formatter] setDateStyle:(NSDateFormatterStyle)dateFormatterStyle];
2886                 if (dateFormatterStyle == 1)
2887                 {
2888                     // if the shortest style for displaying the date and time
2889                     // is too long to be fully visible remove the time part of
2890                     // the date:
2891                     if ([GetNativeData()->GetItemCell() cellSize].width > [GetNativeData()->GetColumnPtr() width])
2892                         [[GetNativeData()->GetItemCell() formatter] setTimeStyle:NSDateFormatterNoStyle];
2893                     {
2894                         // basically not necessary as the loop would end anyway
2895                         // but let's save the last comparison
2896                         break;
2897                     }
2898                 }
2899                 else if ([GetNativeData()->GetItemCell() cellSize].width <= [GetNativeData()->GetColumnPtr() width])
2900                     break;
2901             }
2902             // set data (the style is set by the previous loop); on OSX the
2903             // date has to be specified with respect to UTC; in wxWidgets the
2904             // date is always entered in the local timezone; so, we have to do
2905             // a conversion from the local to UTC timezone when adding the
2906             // seconds to 1970-01-01 UTC:
2907             [GetNativeData()->GetItemCell() setObjectValue:[NSDate dateWithTimeIntervalSince1970:GetValue().GetDateTime().ToUTC().Subtract(wxDateTime(1,wxDateTime::Jan,1970)).GetSeconds().ToDouble()]];
2908         }
2909         return true;
2910     }
2911     else
2912     {
2913         wxFAIL_MSG(wxString("Date renderer cannot render value because of wrong value type; value type: ") << GetValue().GetType());
2914         return false;
2915     }
2916 }
2917
2918 void
2919 wxDataViewDateRenderer::OSXOnCellChanged(NSObject *value,
2920                                          const wxDataViewItem& item,
2921                                          unsigned col)
2922 {
2923     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
2924     model->ChangeValue(ObjectToDate(value), item, col);
2925 }
2926
2927 IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateRenderer,wxDataViewRenderer)
2928
2929 // ---------------------------------------------------------
2930 // wxDataViewIconTextRenderer
2931 // ---------------------------------------------------------
2932 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer(const wxString& varianttype,
2933                                                        wxDataViewCellMode mode,
2934                                                        int align)
2935      : wxDataViewRenderer(varianttype,mode)
2936 {
2937     wxImageTextCell* cell;
2938
2939
2940     cell = [[wxImageTextCell alloc] init];
2941     [cell setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2942     SetNativeData(new wxDataViewRendererNativeData(cell));
2943     [cell release];
2944 }
2945
2946 bool wxDataViewIconTextRenderer::MacRender()
2947 {
2948     if (GetValue().GetType() == GetVariantType())
2949     {
2950         wxDataViewIconText iconText;
2951
2952         wxImageTextCell* cell;
2953
2954         cell = (wxImageTextCell*) GetNativeData()->GetItemCell();
2955         iconText << GetValue();
2956         if (iconText.GetIcon().IsOk())
2957             [cell setImage:[[wxBitmap(iconText.GetIcon()).GetNSImage() retain] autorelease]];
2958         [cell setStringValue:[[wxCFStringRef(iconText.GetText()).AsNSString() retain] autorelease]];
2959         return true;
2960     }
2961     else
2962     {
2963         wxFAIL_MSG(wxString("Icon & text renderer cannot render value because of wrong value type; value type: ") << GetValue().GetType());
2964         return false;
2965     }
2966 }
2967
2968 void
2969 wxDataViewIconTextRenderer::OSXOnCellChanged(NSObject *value,
2970                                              const wxDataViewItem& item,
2971                                              unsigned col)
2972 {
2973     wxVariant valueIconText;
2974     valueIconText << wxDataViewIconText(ObjectToString(value));
2975
2976     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
2977     model->ChangeValue(valueIconText, item, col);
2978 }
2979
2980 IMPLEMENT_ABSTRACT_CLASS(wxDataViewIconTextRenderer,wxDataViewRenderer)
2981
2982 // ---------------------------------------------------------
2983 // wxDataViewToggleRenderer
2984 // ---------------------------------------------------------
2985 wxDataViewToggleRenderer::wxDataViewToggleRenderer(const wxString& varianttype,
2986                                                    wxDataViewCellMode mode,
2987                                                    int align)
2988     : wxDataViewRenderer(varianttype,mode)
2989 {
2990     NSButtonCell* cell;
2991
2992
2993     cell = [[NSButtonCell alloc] init];
2994     [cell setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2995     [cell setButtonType:NSSwitchButton];
2996     [cell setImagePosition:NSImageOnly];
2997     SetNativeData(new wxDataViewRendererNativeData(cell));
2998     [cell release];
2999 }
3000
3001 bool wxDataViewToggleRenderer::MacRender()
3002 {
3003     if (GetValue().GetType() == GetVariantType())
3004     {
3005         [GetNativeData()->GetItemCell() setIntValue:GetValue().GetLong()];
3006         return true;
3007     }
3008     else
3009     {
3010         wxFAIL_MSG(wxString("Toggle renderer cannot render value because of wrong value type; value type: ") << GetValue().GetType());
3011         return false;
3012     }
3013 }
3014
3015 void
3016 wxDataViewToggleRenderer::OSXOnCellChanged(NSObject *value,
3017                                            const wxDataViewItem& item,
3018                                            unsigned col)
3019 {
3020     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
3021     model->ChangeValue(ObjectToBool(value), item, col);
3022 }
3023
3024 IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleRenderer,wxDataViewRenderer)
3025
3026 // ---------------------------------------------------------
3027 // wxDataViewProgressRenderer
3028 // ---------------------------------------------------------
3029 wxDataViewProgressRenderer::wxDataViewProgressRenderer(const wxString& label,
3030                                                        const wxString& varianttype,
3031                                                        wxDataViewCellMode mode,
3032                                                        int align)
3033     : wxDataViewRenderer(varianttype,mode,align)
3034 {
3035     wxUnusedVar(label);
3036
3037     NSLevelIndicatorCell* cell;
3038
3039     cell = [[NSLevelIndicatorCell alloc] initWithLevelIndicatorStyle:NSContinuousCapacityLevelIndicatorStyle];
3040     [cell setMinValue:0];
3041     [cell setMaxValue:100];
3042     SetNativeData(new wxDataViewRendererNativeData(cell));
3043     [cell release];
3044 }
3045
3046 bool wxDataViewProgressRenderer::MacRender()
3047 {
3048     if (GetValue().GetType() == GetVariantType())
3049     {
3050         [GetNativeData()->GetItemCell() setIntValue:GetValue().GetLong()];
3051         return true;
3052     }
3053     else
3054     {
3055         wxFAIL_MSG(wxString("Progress renderer cannot render value because of wrong value type; value type: ") << GetValue().GetType());
3056         return false;
3057     }
3058 }
3059
3060 void
3061 wxDataViewProgressRenderer::OSXOnCellChanged(NSObject *value,
3062                                              const wxDataViewItem& item,
3063                                              unsigned col)
3064 {
3065     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
3066     model->ChangeValue(ObjectToLong(value), item, col);
3067 }
3068
3069 IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressRenderer,wxDataViewRenderer)
3070
3071 // ---------------------------------------------------------
3072 // wxDataViewColumn
3073 // ---------------------------------------------------------
3074
3075 wxDataViewColumn::wxDataViewColumn(const wxString& title,
3076                                    wxDataViewRenderer* renderer,
3077                                    unsigned int model_column,
3078                                    int width,
3079                                    wxAlignment align,
3080                                    int flags)
3081      : wxDataViewColumnBase(renderer, model_column),
3082        m_NativeDataPtr(new wxDataViewColumnNativeData()),
3083        m_title(title)
3084 {
3085     InitCommon(width, align, flags);
3086     if (renderer && !renderer->IsCustomRenderer() &&
3087         (renderer->GetAlignment() == wxDVR_DEFAULT_ALIGNMENT))
3088         renderer->SetAlignment(align);
3089 }
3090
3091 wxDataViewColumn::wxDataViewColumn(const wxBitmap& bitmap,
3092                                    wxDataViewRenderer* renderer,
3093                                    unsigned int model_column,
3094                                    int width,
3095                                    wxAlignment align,
3096                                    int flags)
3097     : wxDataViewColumnBase(bitmap, renderer, model_column),
3098       m_NativeDataPtr(new wxDataViewColumnNativeData())
3099 {
3100     InitCommon(width, align, flags);
3101     if (renderer && !renderer->IsCustomRenderer() &&
3102         (renderer->GetAlignment() == wxDVR_DEFAULT_ALIGNMENT))
3103         renderer->SetAlignment(align);
3104 }
3105
3106 wxDataViewColumn::~wxDataViewColumn()
3107 {
3108     delete m_NativeDataPtr;
3109 }
3110
3111 int wxDataViewColumn::GetWidth() const
3112 {
3113     return [m_NativeDataPtr->GetNativeColumnPtr() width];
3114 }
3115
3116 bool wxDataViewColumn::IsSortKey() const
3117 {
3118     NSTableColumn *nsCol = GetNativeData()->GetNativeColumnPtr();
3119     return nsCol && ([nsCol sortDescriptorPrototype] != nil);
3120 }
3121
3122 void wxDataViewColumn::SetAlignment(wxAlignment align)
3123 {
3124     m_alignment = align;
3125     [[m_NativeDataPtr->GetNativeColumnPtr() headerCell] setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
3126     if (m_renderer && !m_renderer->IsCustomRenderer() &&
3127         (m_renderer->GetAlignment() == wxDVR_DEFAULT_ALIGNMENT))
3128         m_renderer->SetAlignment(align);
3129 }
3130
3131 void wxDataViewColumn::SetBitmap(const wxBitmap& bitmap)
3132 {
3133     // bitmaps and titles cannot exist at the same time - if the bitmap is set
3134     // the title is removed:
3135     m_title = wxEmptyString;
3136     wxDataViewColumnBase::SetBitmap(bitmap);
3137     [[m_NativeDataPtr->GetNativeColumnPtr() headerCell] setImage:[[bitmap.GetNSImage() retain] autorelease]];
3138 }
3139
3140 void wxDataViewColumn::SetMaxWidth(int maxWidth)
3141 {
3142     m_maxWidth = maxWidth;
3143     [m_NativeDataPtr->GetNativeColumnPtr() setMaxWidth:maxWidth];
3144 }
3145
3146 void wxDataViewColumn::SetMinWidth(int minWidth)
3147 {
3148     m_minWidth = minWidth;
3149     [m_NativeDataPtr->GetNativeColumnPtr() setMinWidth:minWidth];
3150 }
3151
3152 void wxDataViewColumn::SetReorderable(bool reorderable)
3153 {
3154     wxUnusedVar(reorderable);
3155 }
3156
3157 void wxDataViewColumn::SetHidden(bool hidden)
3158 {
3159     // How to set flag here?
3160
3161     [m_NativeDataPtr->GetNativeColumnPtr() setHidden:hidden];
3162 }
3163
3164 bool wxDataViewColumn::IsHidden() const
3165 {
3166     return [m_NativeDataPtr->GetNativeColumnPtr() isHidden];
3167 }
3168
3169 void wxDataViewColumn::SetResizeable(bool resizable)
3170 {
3171     wxDataViewColumnBase::SetResizeable(resizable);
3172     if (resizable)
3173         [m_NativeDataPtr->GetNativeColumnPtr() setResizingMask:NSTableColumnUserResizingMask];
3174     else
3175         [m_NativeDataPtr->GetNativeColumnPtr() setResizingMask:NSTableColumnNoResizing];
3176 }
3177
3178 void wxDataViewColumn::SetSortable(bool sortable)
3179 {
3180     // wxDataViewColumnBase::SetSortable(sortable);
3181     // Avoid endless recursion and just set the flag here
3182     if (sortable)
3183         m_flags |= wxDATAVIEW_COL_SORTABLE;
3184     else
3185         m_flags &= ~wxDATAVIEW_COL_SORTABLE;
3186 }
3187
3188 void wxDataViewColumn::SetSortOrder(bool ascending)
3189 {
3190     if (m_ascending != ascending)
3191     {
3192         m_ascending = ascending;
3193         if (IsSortKey())
3194         {
3195             // change sorting order:
3196             NSArray*          sortDescriptors;
3197             NSSortDescriptor* sortDescriptor;
3198             NSTableColumn*    tableColumn;
3199
3200             tableColumn     = m_NativeDataPtr->GetNativeColumnPtr();
3201             sortDescriptor  = [[NSSortDescriptor alloc] initWithKey:[[tableColumn sortDescriptorPrototype] key] ascending:m_ascending];
3202             sortDescriptors = [NSArray arrayWithObject:sortDescriptor];
3203             [tableColumn setSortDescriptorPrototype:sortDescriptor];
3204             [[tableColumn tableView] setSortDescriptors:sortDescriptors];
3205             [sortDescriptor release];
3206         }
3207     }
3208 }
3209
3210 void wxDataViewColumn::SetTitle(const wxString& title)
3211 {
3212     // bitmaps and titles cannot exist at the same time - if the title is set
3213     // the bitmap is removed:
3214     wxDataViewColumnBase::SetBitmap(wxBitmap());
3215     m_title = title;
3216     [[m_NativeDataPtr->GetNativeColumnPtr() headerCell] setStringValue:[[wxCFStringRef(title).AsNSString() retain] autorelease]];
3217 }
3218
3219 void wxDataViewColumn::SetWidth(int width)
3220 {
3221     m_width = width;
3222
3223     switch ( width )
3224     {
3225         case wxCOL_WIDTH_AUTOSIZE:
3226 #if MAC_OS_X_VERSION_MIN_REQUIRED >= MAC_OS_X_VERSION_10_5
3227             if ( GetOwner() )
3228             {
3229                 wxCocoaDataViewControl *peer = static_cast<wxCocoaDataViewControl*>(GetOwner()->GetPeer());
3230                 peer->FitColumnWidthToContent(GetOwner()->GetColumnPosition(this));
3231                 break;
3232             }
3233 #endif
3234             // fall through if unsupported (OSX < 10.5) or not yet settable
3235
3236         case wxCOL_WIDTH_DEFAULT:
3237             width = wxDVC_DEFAULT_WIDTH;
3238             // fall through
3239
3240         default:
3241             [m_NativeDataPtr->GetNativeColumnPtr() setWidth:width];
3242             break;
3243     }
3244 }
3245
3246 void wxDataViewColumn::SetNativeData(wxDataViewColumnNativeData* newNativeDataPtr)
3247 {
3248     delete m_NativeDataPtr;
3249     m_NativeDataPtr = newNativeDataPtr;
3250 }
3251
3252 #endif // (wxUSE_DATAVIEWCTRL == 1) && !defined(wxUSE_GENERICDATAVIEWCTRL)