]>
Commit | Line | Data |
---|---|---|
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 | ||
89 | namespace | |
90 | { | |
91 | ||
92 | inline wxDataViewItem wxDataViewItemFromItem(id item) | |
93 | { | |
94 | return wxDataViewItem([static_cast<wxPointerObject *>(item) pointer]); | |
95 | } | |
96 | ||
97 | inline 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 |
204 | namespace |
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 | |
209 | wxString 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 | ||
221 | bool 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 | ||
235 | long 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 | ||
247 | wxDateTime 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 |
272 | NSInteger 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 | 302 | NSTextAlignment 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 | 312 | NSTableColumn* 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 | |
378 | wxWidgetImplType* 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) |
406 | initWithModelPtr:(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) |
494 | outlineView:(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) |
659 | outlineView:(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) |
683 | outlineView:(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 | |
1898 | wxCocoaDataViewControl::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 |
1924 | void 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 | 1942 | wxCocoaDataViewControl::~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 | 1951 | bool 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 | ||
1966 | bool 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 | 1975 | void wxCocoaDataViewControl::DoSetExpanderColumn(const wxDataViewColumn *columnPtr) |
e86edab0 | 1976 | { |
8e59cbe4 | 1977 | [m_OutlineView setOutlineTableColumn:columnPtr->GetNativeData()->GetNativeColumnPtr()]; |
e86edab0 RR |
1978 | } |
1979 | ||
1980 | wxDataViewColumn* 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 | 1985 | int 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 | ||
1990 | bool 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 |
2009 | void 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 | 2130 | bool 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 | 2139 | bool 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 | 2148 | void wxCocoaDataViewControl::Collapse(const wxDataViewItem& item) |
e86edab0 | 2149 | { |
8e59cbe4 | 2150 | [m_OutlineView collapseItem:[m_DataSource getDataViewItemFromBuffer:item]]; |
e86edab0 RR |
2151 | } |
2152 | ||
8e59cbe4 | 2153 | void 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 | 2163 | void wxCocoaDataViewControl::Expand(const wxDataViewItem& item) |
e86edab0 | 2164 | { |
8e59cbe4 | 2165 | [m_OutlineView expandItem:[m_DataSource getDataViewItemFromBuffer:item]]; |
e86edab0 RR |
2166 | } |
2167 | ||
de40d736 | 2168 | unsigned int wxCocoaDataViewControl::GetCount() const |
e86edab0 | 2169 | { |
8e59cbe4 | 2170 | return [m_OutlineView numberOfRows]; |
e86edab0 RR |
2171 | } |
2172 | ||
8e59cbe4 | 2173 | wxRect 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 | 2179 | bool wxCocoaDataViewControl::IsExpanded(const wxDataViewItem& item) const |
e86edab0 | 2180 | { |
8e59cbe4 | 2181 | return [m_OutlineView isItemExpanded:[m_DataSource getDataViewItemFromBuffer:item]]; |
e86edab0 RR |
2182 | } |
2183 | ||
de40d736 | 2184 | bool 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 | 2193 | bool 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 | 2202 | bool 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 | 2211 | bool wxCocoaDataViewControl::Update(const wxDataViewColumn *columnPtr) |
e86edab0 | 2212 | { |
e7794cf2 SC |
2213 | wxUnusedVar(columnPtr); |
2214 | ||
8e59cbe4 | 2215 | return false; |
e86edab0 RR |
2216 | } |
2217 | ||
8e59cbe4 | 2218 | bool 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 | 2224 | bool 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 | // | |
2234 | bool 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 | |
2253 | wxDataViewItem wxCocoaDataViewControl::GetCurrentItem() const | |
2254 | { | |
2255 | return wxDataViewItem([[m_OutlineView itemAtRow:[m_OutlineView selectedRow]] pointer]); | |
2256 | } | |
2257 | ||
2258 | void 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 |
2268 | int 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 | 2286 | bool 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 | 2291 | void 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 | 2298 | void wxCocoaDataViewControl::SelectAll() |
e86edab0 | 2299 | { |
8e59cbe4 | 2300 | [m_OutlineView selectAll:m_OutlineView]; |
e86edab0 RR |
2301 | } |
2302 | ||
8e59cbe4 | 2303 | void 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 | 2309 | void wxCocoaDataViewControl::UnselectAll() |
e86edab0 | 2310 | { |
8e59cbe4 | 2311 | [m_OutlineView deselectAll:m_OutlineView]; |
e86edab0 RR |
2312 | } |
2313 | ||
2314 | // | |
2315 | // sorting related methods | |
2316 | // | |
de40d736 | 2317 | wxDataViewColumn* 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 | 2330 | void wxCocoaDataViewControl::Resort() |
e86edab0 | 2331 | { |
8e59cbe4 VZ |
2332 | [m_DataSource clearChildren]; |
2333 | [m_OutlineView reloadData]; | |
e86edab0 RR |
2334 | } |
2335 | ||
eeea3b03 RD |
2336 | void 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 | // | |
2344 | void wxCocoaDataViewControl::DoSetIndent(int indent) | |
2345 | { | |
8e59cbe4 | 2346 | [m_OutlineView setIndentationPerLevel:static_cast<CGFloat>(indent)]; |
e86edab0 RR |
2347 | } |
2348 | ||
8e59cbe4 | 2349 | void 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 |
2371 | void wxCocoaDataViewControl::SetRowHeight(const wxDataViewItem& WXUNUSED(item), unsigned int WXUNUSED(height)) |
2372 | // Not supported by the native control | |
e86edab0 RR |
2373 | { |
2374 | } | |
2375 | ||
de40d736 | 2376 | void 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 | // | |
2385 | wxDataFormat 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 | ||
2441 | wxDataObjectComposite* 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 |
2473 | id wxCocoaDataViewControl::GetItemAtRow(int row) const |
2474 | { | |
2475 | return [m_OutlineView itemAtRow:row]; | |
2476 | } | |
2477 | ||
c937bcac VZ |
2478 | // ---------------------------------------------------------------------------- |
2479 | // wxDataViewRendererNativeData | |
2480 | // ---------------------------------------------------------------------------- | |
2481 | ||
2482 | void 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 | ||
2492 | void 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 | |
2523 | wxDataViewRenderer::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 | 2533 | wxDataViewRenderer::~wxDataViewRenderer() |
e86edab0 | 2534 | { |
8e59cbe4 | 2535 | delete m_NativeDataPtr; |
e86edab0 RR |
2536 | } |
2537 | ||
2538 | void wxDataViewRenderer::SetAlignment(int align) | |
2539 | { | |
8e59cbe4 VZ |
2540 | m_alignment = align; |
2541 | [GetNativeData()->GetColumnCell() setAlignment:ConvertToNativeHorizontalTextAlignment(align)]; | |
e86edab0 RR |
2542 | } |
2543 | ||
2544 | void 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 | ||
2551 | void wxDataViewRenderer::SetNativeData(wxDataViewRendererNativeData* newNativeDataPtr) | |
2552 | { | |
8e59cbe4 VZ |
2553 | delete m_NativeDataPtr; |
2554 | m_NativeDataPtr = newNativeDataPtr; | |
e86edab0 RR |
2555 | } |
2556 | ||
c937bcac VZ |
2557 | void 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 | ||
2568 | wxEllipsizeMode wxDataViewRenderer::GetEllipsizeMode() const | |
2569 | { | |
2570 | return GetNativeData()->GetEllipsizeMode(); | |
2571 | } | |
2572 | ||
9461dd8c VZ |
2573 | void |
2574 | wxDataViewRenderer::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 |
2606 | void 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 |
2675 | void wxDataViewRenderer::OSXApplyEnabled(bool enabled) |
2676 | { | |
2677 | [GetNativeData()->GetItemCell() setEnabled:enabled]; | |
2678 | } | |
2679 | ||
e86edab0 RR |
2680 | IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer,wxDataViewRendererBase) |
2681 | ||
2682 | // --------------------------------------------------------- | |
2683 | // wxDataViewCustomRenderer | |
2684 | // --------------------------------------------------------- | |
8e59cbe4 VZ |
2685 | wxDataViewCustomRenderer::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 | 2695 | bool wxDataViewCustomRenderer::MacRender() |
e86edab0 | 2696 | { |
8e59cbe4 VZ |
2697 | [GetNativeData()->GetItemCell() setObjectValue:[[[wxCustomRendererObject alloc] initWithRenderer:this] autorelease]]; |
2698 | return true; | |
e86edab0 RR |
2699 | } |
2700 | ||
b0607dd2 VZ |
2701 | void 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 |
2713 | IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer) |
2714 | ||
2715 | // --------------------------------------------------------- | |
2716 | // wxDataViewTextRenderer | |
2717 | // --------------------------------------------------------- | |
8e59cbe4 VZ |
2718 | wxDataViewTextRenderer::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 | 2732 | bool 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 |
2746 | void |
2747 | wxDataViewTextRenderer::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 |
2755 | IMPLEMENT_CLASS(wxDataViewTextRenderer,wxDataViewRenderer) |
2756 | ||
2757 | // --------------------------------------------------------- | |
2758 | // wxDataViewBitmapRenderer | |
2759 | // --------------------------------------------------------- | |
8e59cbe4 VZ |
2760 | wxDataViewBitmapRenderer::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 | 2779 | bool 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 | ||
2791 | IMPLEMENT_CLASS(wxDataViewBitmapRenderer,wxDataViewRenderer) | |
2792 | ||
2793 | // ------------------------------------- | |
2794 | // wxDataViewChoiceRenderer | |
2795 | // ------------------------------------- | |
8e59cbe4 VZ |
2796 | wxDataViewChoiceRenderer::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 | 2814 | bool 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 | ||
2828 | IMPLEMENT_CLASS(wxDataViewChoiceRenderer,wxDataViewRenderer) | |
2829 | ||
2830 | // --------------------------------------------------------- | |
2831 | // wxDataViewDateRenderer | |
2832 | // --------------------------------------------------------- | |
8e59cbe4 VZ |
2833 | |
2834 | wxDataViewDateRenderer::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 | 2854 | bool 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 |
2913 | void |
2914 | wxDataViewDateRenderer::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 |
2922 | IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateRenderer,wxDataViewRenderer) |
2923 | ||
2924 | // --------------------------------------------------------- | |
2925 | // wxDataViewIconTextRenderer | |
2926 | // --------------------------------------------------------- | |
8e59cbe4 VZ |
2927 | wxDataViewIconTextRenderer::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 | 2941 | bool 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 | 2963 | void |
9461dd8c | 2964 | wxDataViewIconTextRenderer::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 |
2975 | IMPLEMENT_ABSTRACT_CLASS(wxDataViewIconTextRenderer,wxDataViewRenderer) |
2976 | ||
2977 | // --------------------------------------------------------- | |
2978 | // wxDataViewToggleRenderer | |
2979 | // --------------------------------------------------------- | |
8e59cbe4 VZ |
2980 | wxDataViewToggleRenderer::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 | 2996 | bool 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 |
3010 | void |
3011 | wxDataViewToggleRenderer::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 |
3019 | IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleRenderer,wxDataViewRenderer) |
3020 | ||
3021 | // --------------------------------------------------------- | |
3022 | // wxDataViewProgressRenderer | |
3023 | // --------------------------------------------------------- | |
8e59cbe4 VZ |
3024 | wxDataViewProgressRenderer::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 | 3041 | bool 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 |
3055 | void |
3056 | wxDataViewProgressRenderer::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 |
3064 | IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressRenderer,wxDataViewRenderer) |
3065 | ||
3066 | // --------------------------------------------------------- | |
3067 | // wxDataViewColumn | |
3068 | // --------------------------------------------------------- | |
8e59cbe4 VZ |
3069 | |
3070 | wxDataViewColumn::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 |
3086 | wxDataViewColumn::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 | 3101 | wxDataViewColumn::~wxDataViewColumn() |
e86edab0 | 3102 | { |
8e59cbe4 | 3103 | delete m_NativeDataPtr; |
e86edab0 RR |
3104 | } |
3105 | ||
d831e2db VZ |
3106 | int wxDataViewColumn::GetWidth() const |
3107 | { | |
3108 | return [m_NativeDataPtr->GetNativeColumnPtr() width]; | |
3109 | } | |
3110 | ||
e86edab0 RR |
3111 | bool wxDataViewColumn::IsSortKey() const |
3112 | { | |
8e59cbe4 VZ |
3113 | NSTableColumn *nsCol = GetNativeData()->GetNativeColumnPtr(); |
3114 | return nsCol && ([nsCol sortDescriptorPrototype] != nil); | |
e86edab0 RR |
3115 | } |
3116 | ||
3117 | void 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 | 3126 | void 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 | ||
3135 | void wxDataViewColumn::SetMaxWidth(int maxWidth) | |
3136 | { | |
8e59cbe4 VZ |
3137 | m_maxWidth = maxWidth; |
3138 | [m_NativeDataPtr->GetNativeColumnPtr() setMaxWidth:maxWidth]; | |
e86edab0 RR |
3139 | } |
3140 | ||
3141 | void wxDataViewColumn::SetMinWidth(int minWidth) | |
3142 | { | |
8e59cbe4 VZ |
3143 | m_minWidth = minWidth; |
3144 | [m_NativeDataPtr->GetNativeColumnPtr() setMinWidth:minWidth]; | |
e86edab0 RR |
3145 | } |
3146 | ||
3147 | void wxDataViewColumn::SetReorderable(bool reorderable) | |
3148 | { | |
e7794cf2 | 3149 | wxUnusedVar(reorderable); |
e86edab0 RR |
3150 | } |
3151 | ||
f6cb92b8 RR |
3152 | void wxDataViewColumn::SetHidden(bool hidden) |
3153 | { | |
3154 | // How to set flag here? | |
3155 | ||
3156 | [m_NativeDataPtr->GetNativeColumnPtr() setHidden:hidden]; | |
3157 | } | |
3158 | ||
3159 | bool wxDataViewColumn::IsHidden() const | |
3160 | { | |
3161 | return [m_NativeDataPtr->GetNativeColumnPtr() isHidden]; | |
3162 | } | |
3163 | ||
d13b34d3 | 3164 | void 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 | ||
3173 | void 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 | ||
3183 | void 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 | 3205 | void 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 | ||
3214 | void 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 | ||
3241 | void wxDataViewColumn::SetAsSortKey(bool WXUNUSED(sort)) | |
3242 | { | |
8e59cbe4 VZ |
3243 | // see wxGTK native wxDataViewColumn implementation |
3244 | wxFAIL_MSG("not implemented"); | |
e86edab0 RR |
3245 | } |
3246 | ||
3247 | void 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) |