src/osx/cocoa/dataview.mm

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