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