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