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