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