src/osx/cocoa/dataview.mm

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