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     // initialize the native control itself too
1822     InitOutlineView(style);
1823 }
1824
1825 void wxCocoaDataViewControl::InitOutlineView(long style)
1826 {
1827     [m_OutlineView setImplementation:this];
1828     [m_OutlineView setColumnAutoresizingStyle:NSTableViewSequentialColumnAutoresizingStyle];
1829     [m_OutlineView setIndentationPerLevel:GetDataViewCtrl()->GetIndent()];
1830     NSUInteger maskGridStyle(NSTableViewGridNone);
1831     if (style & wxDV_HORIZ_RULES)
1832         maskGridStyle |= NSTableViewSolidHorizontalGridLineMask;
1833     if (style & wxDV_VERT_RULES)
1834         maskGridStyle |= NSTableViewSolidVerticalGridLineMask;
1835     [m_OutlineView setGridStyleMask:maskGridStyle];
1836     [m_OutlineView setAllowsMultipleSelection:           (style & wxDV_MULTIPLE)  != 0];
1837     [m_OutlineView setUsesAlternatingRowBackgroundColors:(style & wxDV_ROW_LINES) != 0];
1838
1839     if ( style & wxDV_NO_HEADER )
1840         [m_OutlineView setHeaderView:nil];
1841 }
1842
1843 wxCocoaDataViewControl::~wxCocoaDataViewControl()
1844 {
1845     [m_DataSource  release];
1846     [m_OutlineView release];
1847 }
1848
1849 //
1850 // column related methods (inherited from wxDataViewWidgetImpl)
1851 //
1852 bool wxCocoaDataViewControl::ClearColumns()
1853 {
1854     // as there is a bug in NSOutlineView version (OSX 10.5.6 #6555162) the
1855     // columns cannot be deleted if there is an outline column in the view;
1856     // therefore, the whole view is deleted and newly constructed:
1857     [m_OutlineView release];
1858     m_OutlineView = [[wxCocoaOutlineView alloc] init];
1859     [((NSScrollView*) GetWXWidget()) setDocumentView:m_OutlineView];
1860     [m_OutlineView setDataSource:m_DataSource];
1861
1862     InitOutlineView(GetDataViewCtrl()->GetWindowStyle());
1863
1864     return true;
1865 }
1866
1867 bool wxCocoaDataViewControl::DeleteColumn(wxDataViewColumn* columnPtr)
1868 {
1869     if ([m_OutlineView outlineTableColumn] == columnPtr->GetNativeData()->GetNativeColumnPtr())
1870         [m_OutlineView setOutlineTableColumn:nil]; // due to a bug this does not work
1871     [m_OutlineView removeTableColumn:columnPtr->GetNativeData()->GetNativeColumnPtr()]; // due to a confirmed bug #6555162 the deletion does not work for
1872     // outline table columns (... and there is no workaround)
1873     return (([m_OutlineView columnWithIdentifier:[[[wxPointerObject alloc] initWithPointer:columnPtr] autorelease]]) == -1);
1874 }
1875
1876 void wxCocoaDataViewControl::DoSetExpanderColumn(const wxDataViewColumn *columnPtr)
1877 {
1878     [m_OutlineView setOutlineTableColumn:columnPtr->GetNativeData()->GetNativeColumnPtr()];
1879 }
1880
1881 wxDataViewColumn* wxCocoaDataViewControl::GetColumn(unsigned int pos) const
1882 {
1883     return static_cast<wxDataViewColumn*>([[[[m_OutlineView tableColumns] objectAtIndex:pos] identifier] pointer]);
1884 }
1885
1886 int wxCocoaDataViewControl::GetColumnPosition(const wxDataViewColumn *columnPtr) const
1887 {
1888     return [m_OutlineView columnWithIdentifier:[[[wxPointerObject alloc] initWithPointer:const_cast<wxDataViewColumn*>(columnPtr)] autorelease]];
1889 }
1890
1891 bool wxCocoaDataViewControl::InsertColumn(unsigned int pos, wxDataViewColumn* columnPtr)
1892 {
1893     // create column and set the native data of the dataview column:
1894     NSTableColumn *nativeColumn = ::CreateNativeColumn(columnPtr);
1895     columnPtr->GetNativeData()->SetNativeColumnPtr(nativeColumn);
1896     // as the native control does not allow the insertion of a column at a
1897     // specified position the column is first appended and - if necessary -
1898     // moved to its final position:
1899     [m_OutlineView addTableColumn:nativeColumn];
1900     if (pos != static_cast<unsigned int>([m_OutlineView numberOfColumns]-1))
1901         [m_OutlineView moveColumn:[m_OutlineView numberOfColumns]-1 toColumn:pos];
1902     // done:
1903     return true;
1904 }
1905
1906 //
1907 // item related methods (inherited from wxDataViewWidgetImpl)
1908 //
1909 bool wxCocoaDataViewControl::Add(const wxDataViewItem& parent, const wxDataViewItem& WXUNUSED(item))
1910 {
1911     if (parent.IsOk())
1912         [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:parent] reloadChildren:YES];
1913     else
1914         [m_OutlineView reloadData];
1915     return true;
1916 }
1917
1918 bool wxCocoaDataViewControl::Add(const wxDataViewItem& parent, const wxDataViewItemArray& WXUNUSED(items))
1919 {
1920     if (parent.IsOk())
1921         [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:parent] reloadChildren:YES];
1922     else
1923         [m_OutlineView reloadData];
1924     return true;
1925 }
1926
1927 void wxCocoaDataViewControl::Collapse(const wxDataViewItem& item)
1928 {
1929     [m_OutlineView collapseItem:[m_DataSource getDataViewItemFromBuffer:item]];
1930 }
1931
1932 void wxCocoaDataViewControl::EnsureVisible(const wxDataViewItem& item, const wxDataViewColumn *columnPtr)
1933 {
1934     if (item.IsOk())
1935     {
1936         [m_OutlineView scrollRowToVisible:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]];
1937         if (columnPtr)
1938             [m_OutlineView scrollColumnToVisible:GetColumnPosition(columnPtr)];
1939     }
1940 }
1941
1942 void wxCocoaDataViewControl::Expand(const wxDataViewItem& item)
1943 {
1944     [m_OutlineView expandItem:[m_DataSource getDataViewItemFromBuffer:item]];
1945 }
1946
1947 unsigned int wxCocoaDataViewControl::GetCount() const
1948 {
1949     return [m_OutlineView numberOfRows];
1950 }
1951
1952 wxRect wxCocoaDataViewControl::GetRectangle(const wxDataViewItem& item, const wxDataViewColumn *columnPtr)
1953 {
1954     return wxFromNSRect([m_osxView superview],[m_OutlineView frameOfCellAtColumn:GetColumnPosition(columnPtr)
1955             row:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]]);
1956 }
1957
1958 bool wxCocoaDataViewControl::IsExpanded(const wxDataViewItem& item) const
1959 {
1960     return [m_OutlineView isItemExpanded:[m_DataSource getDataViewItemFromBuffer:item]];
1961 }
1962
1963 bool wxCocoaDataViewControl::Reload()
1964 {
1965     [m_DataSource clearBuffers];
1966     [m_OutlineView scrollColumnToVisible:0];
1967     [m_OutlineView scrollRowToVisible:0];
1968     [m_OutlineView reloadData];
1969     return true;
1970 }
1971
1972 bool wxCocoaDataViewControl::Remove(const wxDataViewItem& parent, const wxDataViewItem& WXUNUSED(item))
1973 {
1974     if (parent.IsOk())
1975         [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:parent] reloadChildren:YES];
1976     else
1977         [m_OutlineView reloadData];
1978     return true;
1979 }
1980
1981 bool wxCocoaDataViewControl::Remove(const wxDataViewItem& parent, const wxDataViewItemArray& WXUNUSED(item))
1982 {
1983     if (parent.IsOk())
1984         [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:parent] reloadChildren:YES];
1985     else
1986         [m_OutlineView reloadData];
1987     return true;
1988 }
1989
1990 bool wxCocoaDataViewControl::Update(const wxDataViewColumn *columnPtr)
1991 {
1992     return false;
1993 }
1994
1995 bool wxCocoaDataViewControl::Update(const wxDataViewItem& WXUNUSED(parent), const wxDataViewItem& item)
1996 {
1997     [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:item]];
1998     return true;
1999 }
2000
2001 bool wxCocoaDataViewControl::Update(const wxDataViewItem& WXUNUSED(parent), const wxDataViewItemArray& items)
2002 {
2003     for (size_t i=0; i<items.GetCount(); ++i)
2004         [m_OutlineView reloadItem:[m_DataSource getDataViewItemFromBuffer:items[i]]];
2005     return true;
2006 }
2007
2008 //
2009 // model related methods
2010 //
2011 bool wxCocoaDataViewControl::AssociateModel(wxDataViewModel* model)
2012 {
2013     [m_DataSource release];
2014     if (model)
2015     {
2016         m_DataSource = [[wxCocoaOutlineDataSource alloc] init];
2017         [m_DataSource setImplementation:this];
2018         [m_DataSource setModel:model];
2019     }
2020     else
2021         m_DataSource = NULL;
2022     [m_OutlineView setDataSource:m_DataSource]; // if there is a data source the data is immediately going to be requested
2023     return true;
2024 }
2025
2026 //
2027 // selection related methods (inherited from wxDataViewWidgetImpl)
2028 //
2029 int wxCocoaDataViewControl::GetSelections(wxDataViewItemArray& sel) const
2030 {
2031     NSIndexSet* selectedRowIndexes([m_OutlineView selectedRowIndexes]);
2032
2033     NSUInteger indexRow;
2034
2035
2036     sel.Empty();
2037     sel.Alloc([selectedRowIndexes count]);
2038     indexRow = [selectedRowIndexes firstIndex];
2039     while (indexRow != NSNotFound)
2040     {
2041         sel.Add(wxDataViewItem([[m_OutlineView itemAtRow:indexRow] pointer]));
2042         indexRow = [selectedRowIndexes indexGreaterThanIndex:indexRow];
2043     }
2044     return sel.GetCount();
2045 }
2046
2047 bool wxCocoaDataViewControl::IsSelected(const wxDataViewItem& item) const
2048 {
2049     return [m_OutlineView isRowSelected:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]];
2050 }
2051
2052 void wxCocoaDataViewControl::Select(const wxDataViewItem& item)
2053 {
2054     if (item.IsOk())
2055         [m_OutlineView selectRowIndexes:[NSIndexSet indexSetWithIndex:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]]
2056             byExtendingSelection:NO];
2057 }
2058
2059 void wxCocoaDataViewControl::SelectAll()
2060 {
2061     [m_OutlineView selectAll:m_OutlineView];
2062 }
2063
2064 void wxCocoaDataViewControl::Unselect(const wxDataViewItem& item)
2065 {
2066     if (item.IsOk())
2067         [m_OutlineView deselectRow:[m_OutlineView rowForItem:[m_DataSource getDataViewItemFromBuffer:item]]];
2068 }
2069
2070 void wxCocoaDataViewControl::UnselectAll()
2071 {
2072     [m_OutlineView deselectAll:m_OutlineView];
2073 }
2074
2075 //
2076 // sorting related methods
2077 //
2078 wxDataViewColumn* wxCocoaDataViewControl::GetSortingColumn() const
2079 {
2080     NSArray* const columns = [m_OutlineView tableColumns];
2081
2082     UInt32 const noOfColumns = [columns count];
2083
2084
2085     for (UInt32 i=0; i<noOfColumns; ++i)
2086         if ([[columns objectAtIndex:i] sortDescriptorPrototype] != nil)
2087             return static_cast<wxDataViewColumn*>([[[columns objectAtIndex:i] identifier] pointer]);
2088     return NULL;
2089 }
2090
2091 void wxCocoaDataViewControl::Resort()
2092 {
2093     [m_DataSource clearChildren];
2094     [m_OutlineView reloadData];
2095 }
2096
2097 //
2098 // other methods (inherited from wxDataViewWidgetImpl)
2099 //
2100 void wxCocoaDataViewControl::DoSetIndent(int indent)
2101 {
2102     [m_OutlineView setIndentationPerLevel:static_cast<CGFloat>(indent)];
2103 }
2104
2105 void wxCocoaDataViewControl::HitTest(const wxPoint& point, wxDataViewItem& item, wxDataViewColumn*& columnPtr) const
2106 {
2107     NSPoint const nativePoint = wxToNSPoint((NSScrollView*) GetWXWidget(),point);
2108
2109     int indexColumn;
2110     int indexRow;
2111
2112
2113     indexColumn = [m_OutlineView columnAtPoint:nativePoint];
2114     indexRow    = [m_OutlineView rowAtPoint:   nativePoint];
2115     if ((indexColumn >= 0) && (indexRow >= 0))
2116     {
2117         columnPtr = static_cast<wxDataViewColumn*>([[[[m_OutlineView tableColumns] objectAtIndex:indexColumn] identifier] pointer]);
2118         item      = wxDataViewItem([[m_OutlineView itemAtRow:indexRow] pointer]);
2119     }
2120     else
2121     {
2122         columnPtr = NULL;
2123         item      = wxDataViewItem();
2124     }
2125 }
2126
2127 void wxCocoaDataViewControl::SetRowHeight(const wxDataViewItem& WXUNUSED(item), unsigned int WXUNUSED(height))
2128     // Not supported by the native control
2129 {
2130 }
2131
2132 void wxCocoaDataViewControl::OnSize()
2133 {
2134     if ([m_OutlineView numberOfColumns] == 1)
2135         [m_OutlineView sizeLastColumnToFit];
2136 }
2137
2138 //
2139 // drag & drop helper methods
2140 //
2141 wxDataFormat wxCocoaDataViewControl::GetDnDDataFormat(wxDataObjectComposite* dataObjects)
2142 {
2143     wxDataFormat resultFormat;
2144     if ( !dataObjects )
2145         return resultFormat;
2146
2147     bool compatible(true);
2148
2149     size_t const noOfFormats = dataObjects->GetFormatCount();
2150     size_t       indexFormat;
2151
2152     wxDataFormat* formats;
2153
2154     // get all formats and check afterwards if the formats are compatible; if
2155     // they are compatible the preferred format is returned otherwise
2156     // wxDF_INVALID is returned;
2157     // currently compatible types (ordered by priority are):
2158     //  - wxDF_UNICODETEXT - wxDF_TEXT
2159     formats = new wxDataFormat[noOfFormats];
2160     dataObjects->GetAllFormats(formats);
2161     indexFormat = 0;
2162     while ((indexFormat < noOfFormats) && compatible)
2163     {
2164         switch (resultFormat.GetType())
2165         {
2166             case wxDF_INVALID:
2167                 resultFormat.SetType(formats[indexFormat].GetType()); // first format (should only be reached if indexFormat == 0)
2168                 break;
2169             case wxDF_TEXT:
2170                 if (formats[indexFormat].GetType() == wxDF_UNICODETEXT)
2171                     resultFormat.SetType(wxDF_UNICODETEXT);
2172                 else // incompatible
2173                 {
2174                     resultFormat.SetType(wxDF_INVALID);
2175                     compatible = false;
2176                 }
2177                 break;
2178             case wxDF_UNICODETEXT:
2179                 if (formats[indexFormat].GetType() != wxDF_TEXT)
2180                 {
2181                     resultFormat.SetType(wxDF_INVALID);
2182                     compatible = false;
2183                 }
2184                 break;
2185             default:
2186                 resultFormat.SetType(wxDF_INVALID); // not (yet) supported format
2187                 compatible = false;
2188         }
2189         ++indexFormat;
2190     }
2191
2192     delete[] formats;
2193
2194     return resultFormat;
2195 }
2196
2197 wxDataObjectComposite* wxCocoaDataViewControl::GetDnDDataObjects(NSData* dataObject) const
2198 {
2199     wxDataFormatId dataFormatID;
2200
2201
2202     [dataObject getBytes:&dataFormatID length:sizeof(wxDataFormatId)];
2203     switch (dataFormatID)
2204     {
2205         case wxDF_TEXT:
2206         case wxDF_UNICODETEXT:
2207             {
2208                 wxTextDataObject* textDataObject(new wxTextDataObject());
2209
2210                 if (textDataObject->SetData(wxDataFormat(dataFormatID),[dataObject length]-sizeof(wxDataFormatId),static_cast<char const*>([dataObject bytes])+sizeof(wxDataFormatId)))
2211                 {
2212                     wxDataObjectComposite* dataObjectComposite(new wxDataObjectComposite());
2213
2214                     dataObjectComposite->Add(textDataObject);
2215                     return dataObjectComposite;
2216                 }
2217                 else
2218                 {
2219                     delete textDataObject;
2220                     return NULL;
2221                 }
2222             }
2223             break;
2224         default:
2225             return NULL;
2226     }
2227 }
2228
2229 id wxCocoaDataViewControl::GetItemAtRow(int row) const
2230 {
2231     return [m_OutlineView itemAtRow:row];
2232 }
2233
2234 // ----------------------------------------------------------------------------
2235 // wxDataViewRendererNativeData
2236 // ----------------------------------------------------------------------------
2237
2238 void wxDataViewRendererNativeData::Init()
2239 {
2240     m_origFont = NULL;
2241     m_origTextColour = NULL;
2242     m_ellipsizeMode = wxELLIPSIZE_MIDDLE;
2243
2244     if ( m_ColumnCell )
2245         ApplyLineBreakMode(m_ColumnCell);
2246 }
2247
2248 void wxDataViewRendererNativeData::ApplyLineBreakMode(NSCell *cell)
2249 {
2250     NSLineBreakMode nsMode = NSLineBreakByWordWrapping;
2251     switch ( m_ellipsizeMode )
2252     {
2253         case wxELLIPSIZE_NONE:
2254             nsMode = NSLineBreakByClipping;
2255             break;
2256
2257         case wxELLIPSIZE_START:
2258             nsMode = NSLineBreakByTruncatingHead;
2259             break;
2260
2261         case wxELLIPSIZE_MIDDLE:
2262             nsMode = NSLineBreakByTruncatingMiddle;
2263             break;
2264
2265         case wxELLIPSIZE_END:
2266             nsMode = NSLineBreakByTruncatingTail;
2267             break;
2268     }
2269
2270     wxASSERT_MSG( nsMode != NSLineBreakByWordWrapping, "unknown wxEllipsizeMode" );
2271
2272     [cell setLineBreakMode: nsMode];
2273 }
2274
2275 // ---------------------------------------------------------
2276 // wxDataViewRenderer
2277 // ---------------------------------------------------------
2278
2279 wxDataViewRenderer::wxDataViewRenderer(const wxString& varianttype,
2280                                        wxDataViewCellMode mode,
2281                                        int align)
2282     : wxDataViewRendererBase(varianttype, mode, align),
2283       m_alignment(align),
2284       m_mode(mode),
2285       m_NativeDataPtr(NULL)
2286 {
2287 }
2288
2289 wxDataViewRenderer::~wxDataViewRenderer()
2290 {
2291     delete m_NativeDataPtr;
2292 }
2293
2294 void wxDataViewRenderer::SetAlignment(int align)
2295 {
2296     m_alignment = align;
2297     [GetNativeData()->GetColumnCell() setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2298 }
2299
2300 void wxDataViewRenderer::SetMode(wxDataViewCellMode mode)
2301 {
2302     m_mode = mode;
2303     if ( GetOwner() )
2304         [GetOwner()->GetNativeData()->GetNativeColumnPtr() setEditable:(mode == wxDATAVIEW_CELL_EDITABLE)];
2305 }
2306
2307 void wxDataViewRenderer::SetNativeData(wxDataViewRendererNativeData* newNativeDataPtr)
2308 {
2309     delete m_NativeDataPtr;
2310     m_NativeDataPtr = newNativeDataPtr;
2311 }
2312
2313 void wxDataViewRenderer::EnableEllipsize(wxEllipsizeMode mode)
2314 {
2315     // we need to store this value to apply it to the columns headerCell in
2316     // CreateNativeColumn()
2317     GetNativeData()->SetEllipsizeMode(mode);
2318
2319     // but we may already apply it to the column cell which will be used for
2320     // this column
2321     GetNativeData()->ApplyLineBreakMode(GetNativeData()->GetColumnCell());
2322 }
2323
2324 wxEllipsizeMode wxDataViewRenderer::GetEllipsizeMode() const
2325 {
2326     return GetNativeData()->GetEllipsizeMode();
2327 }
2328
2329 void
2330 wxDataViewRenderer::OSXOnCellChanged(NSObject *object,
2331                                      const wxDataViewItem& item,
2332                                      unsigned col)
2333 {
2334     // TODO: we probably should get rid of this code entirely and make this
2335     //       function pure virtual, but currently we still have some native
2336     //       renderers (wxDataViewChoiceRenderer) which don't override it and
2337     //       there is also wxDataViewCustomRenderer for which it's not obvious
2338     //       how it should be implemented so keep this "auto-deduction" of
2339     //       variant type from NSObject for now
2340
2341     wxVariant value;
2342     if ( [object isKindOfClass:[NSString class]] )
2343         value = ObjectToString(object);
2344     else if ( [object isKindOfClass:[NSNumber class]] )
2345         value = ObjectToLong(object);
2346     else if ( [object isKindOfClass:[NSDate class]] )
2347         value = ObjectToDate(object);
2348     else
2349     {
2350         wxFAIL_MSG( wxString::Format
2351                     (
2352                      "unknown value type %s",
2353                      wxCFStringRef::AsString([object className])
2354                     ));
2355         return;
2356     }
2357
2358     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
2359     model->ChangeValue(value, item, col);
2360 }
2361
2362 void wxDataViewRenderer::OSXApplyAttr(const wxDataViewItemAttr& attr)
2363 {
2364     wxDataViewRendererNativeData * const data = GetNativeData();
2365     NSCell * const cell = data->GetItemCell();
2366
2367     // set the font and text colour to use: we need to do it if we had ever
2368     // changed them before, even if this item itself doesn't have any special
2369     // attributes as otherwise it would reuse the attributes from the previous
2370     // cell rendered using the same renderer
2371     NSFont *font = NULL;
2372     NSColor *colText = NULL;
2373
2374     if ( attr.HasFont() )
2375     {
2376         font = data->GetOriginalFont();
2377         if ( !font )
2378         {
2379             // this is the first time we're setting the font, remember the
2380             // original one before changing it
2381             font = [cell font];
2382             data->SaveOriginalFont(font);
2383         }
2384
2385         if ( font )
2386         {
2387             // FIXME: using wxFont methods here doesn't work for some reason
2388             NSFontManager * const fm = [NSFontManager sharedFontManager];
2389             if ( attr.GetBold() )
2390                 font = [fm convertFont:font toHaveTrait:NSBoldFontMask];
2391             if ( attr.GetItalic() )
2392                 font = [fm convertFont:font toHaveTrait:NSItalicFontMask];
2393         }
2394         //else: can't change font if the cell doesn't have any
2395     }
2396
2397     if ( attr.HasColour() )
2398     {
2399         // we can set font for any cell but only NSTextFieldCell provides
2400         // a method for setting text colour so check that this method is
2401         // available before using it
2402         if ( [cell respondsToSelector:@selector(setTextColor:)] &&
2403                 [cell respondsToSelector:@selector(textColor)] )
2404         {
2405             if ( !data->GetOriginalTextColour() )
2406             {
2407                 // the cast to (untyped) id is safe because of the check above
2408                 data->SaveOriginalTextColour([(id)cell textColor]);
2409             }
2410
2411             const wxColour& c = attr.GetColour();
2412             colText = [NSColor colorWithDeviceRed:c.Red() / 255.
2413                 green:c.Green() / 255.
2414                 blue:c.Blue() / 255.
2415                 alpha:c.Alpha() / 255.];
2416         }
2417     }
2418
2419     if ( !font )
2420         font = data->GetOriginalFont();
2421     if ( !colText )
2422         colText = data->GetOriginalTextColour();
2423
2424     if ( font )
2425         [cell setFont:font];
2426
2427     if ( colText )
2428         [(id)cell setTextColor:colText];
2429 }
2430
2431 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer,wxDataViewRendererBase)
2432
2433 // ---------------------------------------------------------
2434 // wxDataViewCustomRenderer
2435 // ---------------------------------------------------------
2436 wxDataViewCustomRenderer::wxDataViewCustomRenderer(const wxString& varianttype,
2437                                                    wxDataViewCellMode mode,
2438                                                    int align)
2439     : wxDataViewCustomRendererBase(varianttype, mode, align),
2440       m_editorCtrlPtr(NULL),
2441       m_DCPtr(NULL)
2442 {
2443     SetNativeData(new wxDataViewRendererNativeData([[wxCustomCell alloc] init]));
2444 }
2445
2446 bool wxDataViewCustomRenderer::MacRender()
2447 {
2448     [GetNativeData()->GetItemCell() setObjectValue:[[[wxCustomRendererObject alloc] initWithRenderer:this] autorelease]];
2449     return true;
2450 }
2451
2452 void wxDataViewCustomRenderer::OSXApplyAttr(const wxDataViewItemAttr& attr)
2453 {
2454     // simply save the attribute so that it could be reused from our Render()
2455     SetAttr(attr);
2456
2457     // it's not necessary to call the base class version which sets the cell
2458     // properties to correspond to this attribute because we currently don't
2459     // use any NSCell methods in custom renderers anyhow but if we ever start
2460     // doing this (e.g. override RenderText() here to use NSTextFieldCell
2461     // methods), then we should pass it on to wxDataViewRenderer here
2462 }
2463
2464 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
2465
2466 // ---------------------------------------------------------
2467 // wxDataViewTextRenderer
2468 // ---------------------------------------------------------
2469 wxDataViewTextRenderer::wxDataViewTextRenderer(const wxString& varianttype,
2470                                                wxDataViewCellMode mode,
2471                                                int align)
2472     : wxDataViewRenderer(varianttype,mode,align)
2473 {
2474     NSTextFieldCell* cell;
2475
2476
2477     cell = [[NSTextFieldCell alloc] init];
2478     [cell setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2479     SetNativeData(new wxDataViewRendererNativeData(cell));
2480     [cell release];
2481 }
2482
2483 bool wxDataViewTextRenderer::MacRender()
2484 {
2485     if (GetValue().GetType() == GetVariantType())
2486     {
2487         [GetNativeData()->GetItemCell() setObjectValue:wxCFStringRef(GetValue().GetString()).AsNSString()];
2488         return true;
2489     }
2490     else
2491     {
2492         wxFAIL_MSG(wxString("Text renderer cannot render value because of wrong value type; value type: ") << GetValue().GetType());
2493         return false;
2494     }
2495 }
2496
2497 void
2498 wxDataViewTextRenderer::OSXOnCellChanged(NSObject *value,
2499                                          const wxDataViewItem& item,
2500                                          unsigned col)
2501 {
2502     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
2503     model->ChangeValue(ObjectToString(value), item, col);
2504 }
2505
2506 IMPLEMENT_CLASS(wxDataViewTextRenderer,wxDataViewRenderer)
2507
2508 // ---------------------------------------------------------
2509 // wxDataViewBitmapRenderer
2510 // ---------------------------------------------------------
2511 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer(const wxString& varianttype,
2512                                                    wxDataViewCellMode mode,
2513                                                    int align)
2514     : wxDataViewRenderer(varianttype,mode,align)
2515 {
2516     NSImageCell* cell;
2517
2518
2519     cell = [[NSImageCell alloc] init];
2520     SetNativeData(new wxDataViewRendererNativeData(cell));
2521     [cell release];
2522 }
2523
2524 bool wxDataViewBitmapRenderer::MacRender()
2525     // This method returns 'true' if
2526     //  - the passed bitmap is valid and it could be assigned to the native data browser;
2527     //  - the passed bitmap is invalid (or is not initialized); this case simulates a non-existing bitmap.
2528     // In all other cases the method returns 'false'.
2529 {
2530     wxCHECK_MSG(GetValue().GetType() == GetVariantType(),false,wxString("Bitmap renderer cannot render value; value type: ") << GetValue().GetType());
2531
2532     wxBitmap bitmap;
2533
2534     bitmap << GetValue();
2535     if (bitmap.IsOk())
2536         [GetNativeData()->GetItemCell() setObjectValue:[[bitmap.GetNSImage() retain] autorelease]];
2537     return true;
2538 }
2539
2540 IMPLEMENT_CLASS(wxDataViewBitmapRenderer,wxDataViewRenderer)
2541
2542 // -------------------------------------
2543 // wxDataViewChoiceRenderer
2544 // -------------------------------------
2545 wxDataViewChoiceRenderer::wxDataViewChoiceRenderer(const wxArrayString& choices,
2546                                                    wxDataViewCellMode mode,
2547                                                    int alignment)
2548     : wxDataViewRenderer(wxT("string"), mode, alignment),
2549       m_choices(choices)
2550 {
2551     NSPopUpButtonCell* cell;
2552
2553
2554     cell = [[NSPopUpButtonCell alloc] init];
2555     [cell setControlSize:NSMiniControlSize];
2556     [cell setFont:[[NSFont fontWithName:[[cell font] fontName] size:[NSFont systemFontSizeForControlSize:NSMiniControlSize]] autorelease]];
2557     for (size_t i=0; i<choices.GetCount(); ++i)
2558         [cell addItemWithTitle:[[wxCFStringRef(choices[i]).AsNSString() retain] autorelease]];
2559     SetNativeData(new wxDataViewRendererNativeData(cell));
2560     [cell release];
2561 }
2562
2563 bool wxDataViewChoiceRenderer::MacRender()
2564 {
2565     if (GetValue().GetType() == GetVariantType())
2566     {
2567         [((NSPopUpButtonCell*) GetNativeData()->GetItemCell()) selectItemWithTitle:[[wxCFStringRef(GetValue().GetString()).AsNSString() retain] autorelease]];
2568         return true;
2569     }
2570     else
2571     {
2572         wxFAIL_MSG(wxString("Choice renderer cannot render value because of wrong value type; value type: ") << GetValue().GetType());
2573         return false;
2574     }
2575 }
2576
2577 IMPLEMENT_CLASS(wxDataViewChoiceRenderer,wxDataViewRenderer)
2578
2579 // ---------------------------------------------------------
2580 // wxDataViewDateRenderer
2581 // ---------------------------------------------------------
2582
2583 wxDataViewDateRenderer::wxDataViewDateRenderer(const wxString& varianttype,
2584                                                wxDataViewCellMode mode,
2585                                                int align)
2586     : wxDataViewRenderer(varianttype,mode,align)
2587 {
2588     NSTextFieldCell* cell;
2589
2590     NSDateFormatter* dateFormatter;
2591
2592
2593     dateFormatter = [[NSDateFormatter alloc] init];
2594     [dateFormatter setFormatterBehavior:NSDateFormatterBehavior10_4];
2595     [dateFormatter setDateStyle:NSDateFormatterShortStyle];
2596     cell = [[NSTextFieldCell alloc] init];
2597     [cell setFormatter:dateFormatter];
2598     SetNativeData(new wxDataViewRendererNativeData(cell,[NSDate dateWithString:@"2000-12-30 20:00:00 +0000"]));
2599     [cell          release];
2600     [dateFormatter release];
2601 }
2602
2603 bool wxDataViewDateRenderer::MacRender()
2604 {
2605     if (GetValue().GetType() == GetVariantType())
2606     {
2607         if (GetValue().GetDateTime().IsValid())
2608         {
2609             // -- find best fitting style to show the date --
2610             // as the style should be identical for all cells a reference date instead of the actual cell's date
2611             // value is used for all cells; this reference date is stored in the renderer's native data section
2612             // for speed purposes; otherwise, the reference date's string has to be recalculated for each item that
2613             // may become timewise long if a lot of rows using dates exist;
2614             // the algorithm has the preference to display as much information as possible in the first instance;
2615             // but as this is often impossible due to space restrictions the style is shortened per loop; finally,
2616             // if the shortest time and date format does not fit into the cell the time part is dropped;
2617             // remark: the time part itself is not modified per iteration loop and only uses the short style,
2618             //         means that only the hours and minutes are being shown
2619             [GetNativeData()->GetItemCell() setObjectValue:GetNativeData()->GetObject()]; // GetObject() returns a date for testing the size of a date object
2620             [[GetNativeData()->GetItemCell() formatter] setTimeStyle:NSDateFormatterShortStyle];
2621             for (int dateFormatterStyle=4; dateFormatterStyle>0; --dateFormatterStyle)
2622             {
2623                 [[GetNativeData()->GetItemCell() formatter] setDateStyle:(NSDateFormatterStyle)dateFormatterStyle];
2624                 if (dateFormatterStyle == 1)
2625                 {
2626                     // if the shortest style for displaying the date and time is too long to be fully visible remove the time part of the date:
2627                     if ([GetNativeData()->GetItemCell() cellSize].width > [GetNativeData()->GetColumnPtr() width])
2628                         [[GetNativeData()->GetItemCell() formatter] setTimeStyle:NSDateFormatterNoStyle];
2629                     break; // basically not necessary as the loop would end anyway but let's save the last comparison
2630                 }
2631                 else if ([GetNativeData()->GetItemCell() cellSize].width <= [GetNativeData()->GetColumnPtr() width])
2632                     break;
2633             }
2634             // set data (the style is set by the previous loop);
2635             // 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
2636             // from the local to UTC timezone when adding the seconds to 1970-01-01 UTC:
2637             [GetNativeData()->GetItemCell() setObjectValue:[NSDate dateWithTimeIntervalSince1970:GetValue().GetDateTime().ToUTC().Subtract(wxDateTime(1,wxDateTime::Jan,1970)).GetSeconds().ToDouble()]];
2638         }
2639         return true;
2640     }
2641     else
2642     {
2643         wxFAIL_MSG(wxString("Date renderer cannot render value because of wrong value type; value type: ") << GetValue().GetType());
2644         return false;
2645     }
2646 }
2647
2648 void
2649 wxDataViewDateRenderer::OSXOnCellChanged(NSObject *value,
2650                                          const wxDataViewItem& item,
2651                                          unsigned col)
2652 {
2653     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
2654     model->ChangeValue(ObjectToDate(value), item, col);
2655 }
2656
2657 IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateRenderer,wxDataViewRenderer)
2658
2659 // ---------------------------------------------------------
2660 // wxDataViewIconTextRenderer
2661 // ---------------------------------------------------------
2662 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer(const wxString& varianttype,
2663                                                        wxDataViewCellMode mode,
2664                                                        int align)
2665      : wxDataViewRenderer(varianttype,mode)
2666 {
2667     wxImageTextCell* cell;
2668
2669
2670     cell = [[wxImageTextCell alloc] init];
2671     [cell setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2672     SetNativeData(new wxDataViewRendererNativeData(cell));
2673     [cell release];
2674 }
2675
2676 bool wxDataViewIconTextRenderer::MacRender()
2677 {
2678     if (GetValue().GetType() == GetVariantType())
2679     {
2680         wxDataViewIconText iconText;
2681
2682         wxImageTextCell* cell;
2683
2684         cell = (wxImageTextCell*) GetNativeData()->GetItemCell();
2685         iconText << GetValue();
2686         if (iconText.GetIcon().IsOk())
2687             [cell setImage:[[wxBitmap(iconText.GetIcon()).GetNSImage() retain] autorelease]];
2688         [cell setStringValue:[[wxCFStringRef(iconText.GetText()).AsNSString() retain] autorelease]];
2689         return true;
2690     }
2691     else
2692     {
2693         wxFAIL_MSG(wxString("Icon & text renderer cannot render value because of wrong value type; value type: ") << GetValue().GetType());
2694         return false;
2695     }
2696 }
2697
2698 void
2699 wxDataViewIconTextRenderer::OSXOnCellChanged(NSObject *value,
2700                                              const wxDataViewItem& item,
2701                                              unsigned col)
2702 {
2703     wxVariant valueIconText;
2704     valueIconText << wxDataViewIconText(ObjectToString(value));
2705
2706     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
2707     model->ChangeValue(valueIconText, item, col);
2708 }
2709
2710 IMPLEMENT_ABSTRACT_CLASS(wxDataViewIconTextRenderer,wxDataViewRenderer)
2711
2712 // ---------------------------------------------------------
2713 // wxDataViewToggleRenderer
2714 // ---------------------------------------------------------
2715 wxDataViewToggleRenderer::wxDataViewToggleRenderer(const wxString& varianttype,
2716                                                    wxDataViewCellMode mode,
2717                                                    int align)
2718     : wxDataViewRenderer(varianttype,mode)
2719 {
2720     NSButtonCell* cell;
2721
2722
2723     cell = [[NSButtonCell alloc] init];
2724     [cell setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2725     [cell setButtonType:NSSwitchButton];
2726     [cell setImagePosition:NSImageOnly];
2727     SetNativeData(new wxDataViewRendererNativeData(cell));
2728     [cell release];
2729 }
2730
2731 bool wxDataViewToggleRenderer::MacRender()
2732 {
2733     if (GetValue().GetType() == GetVariantType())
2734     {
2735         [GetNativeData()->GetItemCell() setIntValue:GetValue().GetLong()];
2736         return true;
2737     }
2738     else
2739     {
2740         wxFAIL_MSG(wxString("Toggle renderer cannot render value because of wrong value type; value type: ") << GetValue().GetType());
2741         return false;
2742     }
2743 }
2744
2745 void
2746 wxDataViewToggleRenderer::OSXOnCellChanged(NSObject *value,
2747                                            const wxDataViewItem& item,
2748                                            unsigned col)
2749 {
2750     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
2751     model->ChangeValue(ObjectToBool(value), item, col);
2752 }
2753
2754 IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleRenderer,wxDataViewRenderer)
2755
2756 // ---------------------------------------------------------
2757 // wxDataViewProgressRenderer
2758 // ---------------------------------------------------------
2759 wxDataViewProgressRenderer::wxDataViewProgressRenderer(const wxString& label,
2760                                                        const wxString& varianttype,
2761                                                        wxDataViewCellMode mode,
2762                                                        int align)
2763     : wxDataViewRenderer(varianttype,mode,align)
2764 {
2765     NSLevelIndicatorCell* cell;
2766
2767     cell = [[NSLevelIndicatorCell alloc] initWithLevelIndicatorStyle:NSContinuousCapacityLevelIndicatorStyle];
2768     [cell setMinValue:0];
2769     [cell setMaxValue:100];
2770     SetNativeData(new wxDataViewRendererNativeData(cell));
2771     [cell release];
2772 }
2773
2774 bool wxDataViewProgressRenderer::MacRender()
2775 {
2776     if (GetValue().GetType() == GetVariantType())
2777     {
2778         [GetNativeData()->GetItemCell() setIntValue:GetValue().GetLong()];
2779         return true;
2780     }
2781     else
2782     {
2783         wxFAIL_MSG(wxString("Progress renderer cannot render value because of wrong value type; value type: ") << GetValue().GetType());
2784         return false;
2785     }
2786 }
2787
2788 void
2789 wxDataViewProgressRenderer::OSXOnCellChanged(NSObject *value,
2790                                              const wxDataViewItem& item,
2791                                              unsigned col)
2792 {
2793     wxDataViewModel *model = GetOwner()->GetOwner()->GetModel();
2794     model->ChangeValue(ObjectToLong(value), item, col);
2795 }
2796
2797 IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressRenderer,wxDataViewRenderer)
2798
2799 // ---------------------------------------------------------
2800 // wxDataViewColumn
2801 // ---------------------------------------------------------
2802
2803 wxDataViewColumn::wxDataViewColumn(const wxString& title,
2804                                    wxDataViewRenderer* renderer,
2805                                    unsigned int model_column,
2806                                    int width,
2807                                    wxAlignment align,
2808                                    int flags)
2809      : wxDataViewColumnBase(renderer, model_column),
2810        m_NativeDataPtr(new wxDataViewColumnNativeData()),
2811        m_title(title)
2812 {
2813     InitCommon(width, align, flags);
2814     if (renderer && (renderer->GetAlignment() == wxDVR_DEFAULT_ALIGNMENT))
2815         renderer->SetAlignment(align);
2816 }
2817
2818 wxDataViewColumn::wxDataViewColumn(const wxBitmap& bitmap,
2819                                    wxDataViewRenderer* renderer,
2820                                    unsigned int model_column,
2821                                    int width,
2822                                    wxAlignment align,
2823                                    int flags)
2824     : wxDataViewColumnBase(bitmap, renderer, model_column),
2825       m_NativeDataPtr(new wxDataViewColumnNativeData())
2826 {
2827     InitCommon(width, align, flags);
2828     if (renderer && (renderer->GetAlignment() == wxDVR_DEFAULT_ALIGNMENT))
2829         renderer->SetAlignment(align);
2830 }
2831
2832 wxDataViewColumn::~wxDataViewColumn()
2833 {
2834     delete m_NativeDataPtr;
2835 }
2836
2837 int wxDataViewColumn::GetWidth() const
2838 {
2839     return [m_NativeDataPtr->GetNativeColumnPtr() width];
2840 }
2841
2842 bool wxDataViewColumn::IsSortKey() const
2843 {
2844     NSTableColumn *nsCol = GetNativeData()->GetNativeColumnPtr();
2845     return nsCol && ([nsCol sortDescriptorPrototype] != nil);
2846 }
2847
2848 void wxDataViewColumn::SetAlignment(wxAlignment align)
2849 {
2850     m_alignment = align;
2851     [[m_NativeDataPtr->GetNativeColumnPtr() headerCell] setAlignment:ConvertToNativeHorizontalTextAlignment(align)];
2852     if (m_renderer && (m_renderer->GetAlignment() == wxDVR_DEFAULT_ALIGNMENT))
2853         m_renderer->SetAlignment(align);
2854 }
2855
2856 void wxDataViewColumn::SetBitmap(const wxBitmap& bitmap)
2857 {
2858     // bitmaps and titles cannot exist at the same time - if the bitmap is set the title is removed:
2859     m_title = wxEmptyString;
2860     wxDataViewColumnBase::SetBitmap(bitmap);
2861     [[m_NativeDataPtr->GetNativeColumnPtr() headerCell] setImage:[[bitmap.GetNSImage() retain] autorelease]];
2862 }
2863
2864 void wxDataViewColumn::SetMaxWidth(int maxWidth)
2865 {
2866     m_maxWidth = maxWidth;
2867     [m_NativeDataPtr->GetNativeColumnPtr() setMaxWidth:maxWidth];
2868 }
2869
2870 void wxDataViewColumn::SetMinWidth(int minWidth)
2871 {
2872     m_minWidth = minWidth;
2873     [m_NativeDataPtr->GetNativeColumnPtr() setMinWidth:minWidth];
2874 }
2875
2876 void wxDataViewColumn::SetReorderable(bool reorderable)
2877 {
2878 }
2879
2880 void wxDataViewColumn::SetResizeable(bool resizeable)
2881 {
2882     wxDataViewColumnBase::SetResizeable(resizeable);
2883     if (resizeable)
2884         [m_NativeDataPtr->GetNativeColumnPtr() setResizingMask:NSTableColumnUserResizingMask];
2885     else
2886         [m_NativeDataPtr->GetNativeColumnPtr() setResizingMask:NSTableColumnNoResizing];
2887 }
2888
2889 void wxDataViewColumn::SetSortable(bool sortable)
2890 {
2891     wxDataViewColumnBase::SetSortable(sortable);
2892 }
2893
2894 void wxDataViewColumn::SetSortOrder(bool ascending)
2895 {
2896     if (m_ascending != ascending)
2897     {
2898         m_ascending = ascending;
2899         if (IsSortKey())
2900         {
2901             // change sorting order:
2902             NSArray*          sortDescriptors;
2903             NSSortDescriptor* sortDescriptor;
2904             NSTableColumn*    tableColumn;
2905
2906             tableColumn     = m_NativeDataPtr->GetNativeColumnPtr();
2907             sortDescriptor  = [[NSSortDescriptor alloc] initWithKey:[[tableColumn sortDescriptorPrototype] key] ascending:m_ascending];
2908             sortDescriptors = [NSArray arrayWithObject:sortDescriptor];
2909             [tableColumn setSortDescriptorPrototype:sortDescriptor];
2910             [[tableColumn tableView] setSortDescriptors:sortDescriptors];
2911             [sortDescriptor release];
2912         }
2913     }
2914 }
2915
2916 void wxDataViewColumn::SetTitle(const wxString& title)
2917 {
2918     // bitmaps and titles cannot exist at the same time - if the title is set the bitmap is removed:
2919     wxDataViewColumnBase::SetBitmap(wxBitmap());
2920     m_title = title;
2921     [[m_NativeDataPtr->GetNativeColumnPtr() headerCell] setStringValue:[[wxCFStringRef(title).AsNSString() retain] autorelease]];
2922 }
2923
2924 void wxDataViewColumn::SetWidth(int width)
2925 {
2926     [m_NativeDataPtr->GetNativeColumnPtr() setWidth:width];
2927     m_width = width;
2928 }
2929
2930 void wxDataViewColumn::SetAsSortKey(bool WXUNUSED(sort))
2931 {
2932     // see wxGTK native wxDataViewColumn implementation
2933     wxFAIL_MSG("not implemented");
2934 }
2935
2936 void wxDataViewColumn::SetNativeData(wxDataViewColumnNativeData* newNativeDataPtr)
2937 {
2938     delete m_NativeDataPtr;
2939     m_NativeDataPtr = newNativeDataPtr;
2940 }
2941
2942 #endif // (wxUSE_DATAVIEWCTRL == 1) && !defined(wxUSE_GENERICDATAVIEWCTRL)