src/osx/cocoa/dataview.mm

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