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