]> git.saurik.com Git - wxWidgets.git/blob - src/osx/carbon/dataview.cpp
minor fixes; replace references to Windows95 with references to wxMSW where possible
[wxWidgets.git] / src / osx / carbon / dataview.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/osx/carbon/datavgen.cpp
3 // Purpose: wxDataViewCtrl native mac implementation
4 // Author:
5 // Id: $Id$
6 // Copyright: (c) 2007
7 // Licence: wxWindows licence
8 /////////////////////////////////////////////////////////////////////////////
9
10 // For compilers that support precompilation, includes "wx.h".
11 #include "wx/wxprec.h"
12
13 #if wxUSE_DATAVIEWCTRL
14
15 #include "wx/dataview.h"
16
17 #if !defined(wxUSE_GENERICDATAVIEWCTRL) || (wxUSE_GENERICDATAVIEWCTRL == 0)
18
19 #include <limits>
20
21 #include "wx/osx/carbon/databrow.h"
22
23 #ifndef WX_PRECOMP
24 #include "wx/timer.h"
25 #include "wx/settings.h"
26 #include "wx/dcclient.h"
27 #include "wx/icon.h"
28 #endif
29
30 #include "wx/renderer.h"
31
32 //-----------------------------------------------------------------------------
33 // local constants
34 //-----------------------------------------------------------------------------
35
36 // a list of all catchable events:
37 static EventTypeSpec const eventList[] =
38 {
39 {kEventClassControl, kEventControlDraw},
40 {kEventClassControl, kEventControlHit}
41 };
42
43 //-----------------------------------------------------------------------------
44 // local functions
45 //-----------------------------------------------------------------------------
46
47 static pascal OSStatus wxMacDataViewCtrlEventHandler(EventHandlerCallRef handler, EventRef EventReference, void* Data)
48 {
49 wxDataViewCtrl* DataViewCtrlPtr((wxDataViewCtrl*) Data); // the 'Data' variable always contains a pointer to the data view control that installed the handler
50
51 wxMacCarbonEvent CarbonEvent(EventReference) ;
52
53
54 switch (GetEventKind(EventReference))
55 {
56 case kEventControlDraw:
57 {
58 OSStatus status;
59
60 DataViewCtrlPtr->MacSetDrawingContext(CarbonEvent.GetParameter<CGContextRef>(kEventParamCGContextRef,typeCGContextRef));
61 status = ::CallNextEventHandler(handler,EventReference);
62 DataViewCtrlPtr->MacSetDrawingContext(NULL);
63 return status;
64 } /* block */
65 case kEventControlHit :
66 if (CarbonEvent.GetParameter<ControlPartCode>(kEventParamControlPart,typeControlPartCode) == kControlButtonPart) // we only care about the header
67 {
68 ControlRef controlReference;
69 DataBrowserPropertyID columnPropertyID;
70 unsigned long columnIndex;
71 OSStatus status;
72 wxDataViewEvent DataViewEvent(wxEVT_COMMAND_DATAVIEW_COLUMN_HEADER_CLICK,DataViewCtrlPtr->GetId());
73
74 CarbonEvent.GetParameter(kEventParamDirectObject,&controlReference);
75 // determine the column that triggered the event (this is the column that is responsible for sorting the data view):
76 status = ::GetDataBrowserSortProperty(controlReference,&columnPropertyID);
77 wxCHECK(status == noErr,status);
78 status = ::GetDataBrowserTableViewColumnPosition(controlReference,columnPropertyID,&columnIndex);
79 if (status == errDataBrowserPropertyNotFound) // user clicked into part of the header that does not have a property
80 return ::CallNextEventHandler(handler,EventReference);
81 wxCHECK(status == noErr,status);
82 // initialize wxWidget event handler:
83 DataViewEvent.SetEventObject(DataViewCtrlPtr);
84 DataViewEvent.SetColumn(columnIndex);
85 DataViewEvent.SetDataViewColumn(DataViewCtrlPtr->GetColumn(columnIndex));
86 // finally sent the equivalent wxWidget event:
87 #if wxCHECK_VERSION(2,9,0)
88 DataViewCtrlPtr->HandleWindowEvent(DataViewEvent);
89 #else
90 DataViewCtrlPtr->GetEventHandler()->ProcessEvent(DataViewEvent);
91 #endif
92 return ::CallNextEventHandler(handler,EventReference);
93 } /* if */
94 else
95 return eventNotHandledErr;
96 } /* switch */
97
98 return eventNotHandledErr;
99 } /* wxMacDataViewCtrlEventHandler(EventHandlerCallRef, EventRef, void*) */
100
101 static DataBrowserItemID* CreateDataBrowserItemIDArray(size_t& noOfEntries, wxDataViewItemArray const& items) // returns a newly allocated pointer to valid data browser item IDs
102 {
103 size_t const noOfItems = items.GetCount();
104
105 DataBrowserItemID* itemIDs(new DataBrowserItemID[noOfItems]);
106
107
108 // convert all valid data view items to data browser items
109 noOfEntries = 0;
110 for (size_t i=0; i<noOfItems; ++i)
111 if (items[i].IsOk())
112 {
113 itemIDs[noOfEntries] = reinterpret_cast<DataBrowserItemID>(items[i].GetID());
114 ++noOfEntries;
115 } /* if */
116 // done:
117 return itemIDs;
118 } /* CreateDataBrowserItemIDArray(size_t&, wxDataViewItemArray const&) */
119
120 #if wxCHECK_VERSION(2,9,0)
121 static bool InitializeColumnDescription(DataBrowserListViewColumnDesc& columnDescription, wxDataViewColumn const* columnPtr, DataBrowserPropertyID columnPropertyID, wxCFStringRef const& title)
122 #else
123 static bool InitializeColumnDescription(DataBrowserListViewColumnDesc& columnDescription, wxDataViewColumn const* columnPtr, DataBrowserPropertyID columnPropertyID, wxMacCFStringHolder const& title)
124 #endif
125 {
126 // set properties for the column:
127 columnDescription.propertyDesc.propertyID = columnPropertyID;
128 columnDescription.propertyDesc.propertyType = columnPtr->GetRenderer()->GetPropertyType();
129 columnDescription.propertyDesc.propertyFlags = kDataBrowserListViewSelectionColumn; // make the column selectable
130 if (columnPtr->IsReorderable())
131 columnDescription.propertyDesc.propertyFlags |= kDataBrowserListViewMovableColumn;
132 if (columnPtr->IsResizeable())
133 {
134 columnDescription.headerBtnDesc.minimumWidth = 0;
135 columnDescription.headerBtnDesc.maximumWidth = 30000; // 32767 is the theoretical maximum though but 30000 looks nicer
136 } /* if */
137 else
138 {
139 columnDescription.headerBtnDesc.minimumWidth = columnPtr->GetWidth();
140 columnDescription.headerBtnDesc.maximumWidth = columnPtr->GetWidth();
141 } /* if */
142 if (columnPtr->IsSortable())
143 columnDescription.propertyDesc.propertyFlags |= kDataBrowserListViewSortableColumn;
144 if (columnPtr->GetRenderer()->GetMode() == wxDATAVIEW_CELL_EDITABLE)
145 columnDescription.propertyDesc.propertyFlags |= kDataBrowserPropertyIsEditable;
146 if ((columnDescription.propertyDesc.propertyType == kDataBrowserCustomType) ||
147 (columnDescription.propertyDesc.propertyType == kDataBrowserDateTimeType) ||
148 (columnDescription.propertyDesc.propertyType == kDataBrowserIconAndTextType) ||
149 (columnDescription.propertyDesc.propertyType == kDataBrowserTextType))
150 columnDescription.propertyDesc.propertyFlags |= kDataBrowserListViewTypeSelectColumn; // enables generally the possibility to have user input for the mentioned types
151 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
152 columnDescription.propertyDesc.propertyFlags |= kDataBrowserListViewNoGapForIconInHeaderButton;
153 #endif
154 // set header's properties:
155 columnDescription.headerBtnDesc.version = kDataBrowserListViewLatestHeaderDesc;
156 columnDescription.headerBtnDesc.titleOffset = 0;
157 columnDescription.headerBtnDesc.titleString = ::CFStringCreateCopy(kCFAllocatorDefault,title);
158 columnDescription.headerBtnDesc.initialOrder = kDataBrowserOrderIncreasing; // choose one of the orders as "undefined" is not supported anyway (s. ControlDefs.h in the HIToolbox framework)
159 columnDescription.headerBtnDesc.btnFontStyle.flags = kControlUseFontMask | kControlUseJustMask;
160 switch (columnPtr->GetAlignment())
161 {
162 case wxALIGN_CENTER:
163 case wxALIGN_CENTER_HORIZONTAL:
164 columnDescription.headerBtnDesc.btnFontStyle.just = teCenter;
165 break;
166 case wxALIGN_LEFT:
167 columnDescription.headerBtnDesc.btnFontStyle.just = teFlushLeft;
168 break;
169 case wxALIGN_RIGHT:
170 columnDescription.headerBtnDesc.btnFontStyle.just = teFlushRight;
171 break;
172 default:
173 columnDescription.headerBtnDesc.btnFontStyle.just = teFlushDefault;
174 } /* switch */
175 columnDescription.headerBtnDesc.btnFontStyle.font = kControlFontViewSystemFont;
176 columnDescription.headerBtnDesc.btnFontStyle.style = normal;
177 if (columnPtr->GetBitmap().IsOk())
178 {
179 columnDescription.headerBtnDesc.btnContentInfo.contentType = kControlContentIconRef;
180 #if wxCHECK_VERSION(2,9,0)
181 columnDescription.headerBtnDesc.btnContentInfo.u.iconRef = columnPtr->GetBitmap().GetIconRef();
182 #else
183 columnDescription.headerBtnDesc.btnContentInfo.u.iconRef = columnPtr->GetBitmap().GetBitmapData()->GetIconRef();
184 #endif
185 }
186 else
187 {
188 // not text only as we otherwise could not add a bitmap later
189 // columnDescription.headerBtnDesc.btnContentInfo.contentType = kControlContentTextOnly;
190 columnDescription.headerBtnDesc.btnContentInfo.contentType = kControlContentIconRef;
191 columnDescription.headerBtnDesc.btnContentInfo.u.iconRef = NULL;
192 }
193
194 // done:
195 return true;
196 } /* InitializeColumnDescription(DataBrowserListViewColumnDesc&, wxDataViewColumn const*, DataBrowserPropertyID, wxMacCFStringHolder const&) */
197
198 //-----------------------------------------------------------------------------
199 // local function pointers
200 //-----------------------------------------------------------------------------
201
202 DEFINE_ONE_SHOT_HANDLER_GETTER(wxMacDataViewCtrlEventHandler)
203
204 // ---------------------------------------------------------
205 // wxMacDataViewModelNotifier
206 // ---------------------------------------------------------
207 #pragma mark -
208 class wxMacDataViewModelNotifier : public wxDataViewModelNotifier
209 {
210 public:
211 wxMacDataViewModelNotifier(wxMacDataViewDataBrowserListViewControl* initDataViewControlPtr) : m_dataViewControlPtr(initDataViewControlPtr)
212 {
213 }
214
215 virtual bool ItemAdded(const wxDataViewItem &parent, const wxDataViewItem &item)
216 {
217 DataBrowserItemID itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
218
219 wxCHECK_MSG(item.IsOk(),false,_("Added item is invalid."));
220 bool noFailureFlag = (!(parent.IsOk()) && (this->m_dataViewControlPtr->AddItem(kDataBrowserNoItem,&itemID) == noErr) ||
221 parent.IsOk() && (this->m_dataViewControlPtr->AddItem(reinterpret_cast<DataBrowserItemID>(parent.GetID()),&itemID) == noErr));
222
223 wxDataViewCtrl *dvc = (wxDataViewCtrl*) this->m_dataViewControlPtr->GetWXPeer();
224 if (dvc->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT)
225 {
226 wxDataViewModel *model = GetOwner();
227
228 int height = 20; // TODO find out standard height
229 unsigned int num = dvc->GetColumnCount();
230 unsigned int col;
231 for (col = 0; col < num; col++)
232 {
233 wxDataViewColumn *column = dvc->GetColumn( col );
234 if (column->IsHidden())
235 continue;
236
237 wxDataViewCustomRenderer *renderer = wxDynamicCast( column->GetRenderer(), wxDataViewCustomRenderer );
238 if (renderer)
239 {
240 wxVariant value;
241 model->GetValue( value, item, column->GetModelColumn() );
242 renderer->SetValue( value );
243 height = wxMax( height, renderer->GetSize().y );
244 }
245
246 }
247
248 if (height > 20)
249 this->m_dataViewControlPtr->SetRowHeight( itemID, height );
250 }
251
252 return noFailureFlag;
253 } /* ItemAdded(wxDataViewItem const&, wxDataViewItem const&) */
254
255 virtual bool ItemsAdded(wxDataViewItem const& parent, wxDataViewItemArray const& items)
256 {
257 bool noFailureFlag;
258
259 DataBrowserItemID* itemIDs;
260
261 size_t noOfEntries;
262
263
264 // convert all valid data view items to data browser items:
265 itemIDs = ::CreateDataBrowserItemIDArray(noOfEntries,items);
266 // insert all valid items into control:
267 noFailureFlag = ((noOfEntries == 0) ||
268 !(parent.IsOk()) && (this->m_dataViewControlPtr->AddItems(kDataBrowserNoItem,noOfEntries,itemIDs,kDataBrowserItemNoProperty) == noErr) ||
269 parent.IsOk() && (this->m_dataViewControlPtr->AddItems(reinterpret_cast<DataBrowserItemID>(parent.GetID()),noOfEntries,itemIDs,kDataBrowserItemNoProperty) == noErr));
270 // give allocated array space free again:
271 delete[] itemIDs;
272
273 wxDataViewCtrl *dvc = (wxDataViewCtrl*) this->m_dataViewControlPtr->GetWXPeer();
274 if (dvc->GetWindowStyle() & wxDV_VARIABLE_LINE_HEIGHT)
275 {
276 wxDataViewModel *model = GetOwner();
277 unsigned int colnum = dvc->GetColumnCount();
278
279 size_t i;
280 size_t count = items.GetCount();
281 for (i = 0; i < count; i++)
282 {
283 wxDataViewItem item = items[i];
284 DataBrowserItemID itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
285
286 int height = 20; // TODO find out standard height
287 unsigned int col;
288 for (col = 0; col < colnum; col++)
289 {
290 wxDataViewColumn *column = dvc->GetColumn( col );
291 if (column->IsHidden())
292 continue; // skip it!
293
294 if ((col != 0) && model->IsContainer(item) && !model->HasContainerColumns(item))
295 continue; // skip it!
296
297 wxDataViewCustomRenderer *renderer = wxDynamicCast( column->GetRenderer(), wxDataViewCustomRenderer );
298 if (renderer)
299 {
300 wxVariant value;
301 model->GetValue( value, item, column->GetModelColumn() );
302 renderer->SetValue( value );
303 height = wxMax( height, renderer->GetSize().y );
304 }
305 }
306
307 if (height > 20)
308 this->m_dataViewControlPtr->SetRowHeight( itemID, height );
309 }
310 }
311
312 // done:
313 return noFailureFlag;
314 } /* ItemsAdded(wxDataViewItem const&, wxDataViewItemArray const&) */
315
316 virtual bool ItemChanged(wxDataViewItem const& item)
317 {
318 DataBrowserItemID itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
319
320
321 wxCHECK_MSG(item.IsOk(),false,_("Changed item is invalid."));
322 if (this->m_dataViewControlPtr->UpdateItems(&itemID) == noErr)
323 {
324 wxDataViewCtrl* dataViewCtrlPtr(dynamic_cast<wxDataViewCtrl*>(this->m_dataViewControlPtr->GetWXPeer()));
325
326 // sent the equivalent wxWidget event:
327 wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED,dataViewCtrlPtr->GetId()); // variable defintion
328
329 dataViewEvent.SetEventObject(dataViewCtrlPtr);
330 dataViewEvent.SetItem(item);
331 // sent the equivalent wxWidget event:
332 #if wxCHECK_VERSION(2,9,0)
333 dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
334 #else
335 dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
336 #endif
337 // done
338 return true;
339 } /* if */
340 else
341 return false;
342 } /* ItemChanged(wxDataViewItem const&) */
343
344 virtual bool ItemsChanged(wxDataViewItemArray const& items)
345 {
346 bool noFailureFlag;
347
348 DataBrowserItemID* itemIDs;
349
350 size_t noOfEntries;
351
352
353 // convert all valid data view items to data browser items:
354 itemIDs = ::CreateDataBrowserItemIDArray(noOfEntries,items);
355 // change items (ATTENTION: ONLY ITEMS OF THE ROOT ARE CHANGED BECAUSE THE PARENT PARAMETER IS MISSING):
356 noFailureFlag = (this->m_dataViewControlPtr->UpdateItems(kDataBrowserNoItem,noOfEntries,itemIDs,kDataBrowserItemNoProperty,kDataBrowserItemNoProperty) == noErr);
357 if (noFailureFlag)
358 {
359 wxDataViewCtrl* dataViewCtrlPtr(dynamic_cast<wxDataViewCtrl*>(this->m_dataViewControlPtr->GetWXPeer()));
360
361 // send for all changed items a wxWidget event:
362 wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED,dataViewCtrlPtr->GetId()); // variable defintion
363
364 dataViewEvent.SetEventObject(dataViewCtrlPtr);
365 for (size_t i=0; i<noOfEntries; ++i)
366 {
367 dataViewEvent.SetItem(reinterpret_cast<void*>(itemIDs[i]));
368 #if wxCHECK_VERSION(2,9,0)
369 dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
370 #else
371 dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
372 #endif
373 } /* for */
374 } /* if */
375 // release allocated array space:
376 delete[] itemIDs;
377 // done:
378 return noFailureFlag;
379 } /* ItemsChanged(wxDataViewItem const&) */
380
381 virtual bool ItemDeleted(wxDataViewItem const& parent, wxDataViewItem const& item)
382 {
383 if (item.IsOk())
384 {
385 // variable definition and initialization:
386 DataBrowserItemID itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
387 OSStatus errorStatus;
388 wxDataViewCtrl* dataViewCtrlPtr(dynamic_cast<wxDataViewCtrl*>(this->m_dataViewControlPtr->GetWXPeer()));
389
390 // when this method is called and currently an item is being edited this item may have already been deleted in the model (the passed item and the being edited item have
391 // not to be identical because the being edited item might be below the passed item in the hierarchy);
392 // to prevent the control trying to ask the model to update an already deleted item the control is informed that currently a deleting process
393 // has been started and that variables can currently not be updated even when requested by the system:
394 dataViewCtrlPtr->SetDeleting(true);
395 errorStatus = this->m_dataViewControlPtr->RemoveItem(reinterpret_cast<DataBrowserItemID>(parent.GetID()),&itemID);
396 // enable automatic updating again:
397 dataViewCtrlPtr->SetDeleting(false);
398 return (errorStatus == noErr);
399 } /* if */
400 else
401 return false;
402 } /* ItemDeleted(wxDataViewItem const&, wxDataViewItem const&) */
403
404 virtual bool ItemsDeleted(wxDataViewItem const& parent, wxDataViewItemArray const& items)
405 {
406 bool noFailureFlag;
407
408 DataBrowserItemID* itemIDs;
409
410 wxDataViewCtrl* dataViewCtrlPtr(dynamic_cast<wxDataViewCtrl*>(this->m_dataViewControlPtr->GetWXPeer()));
411
412 size_t noOfEntries;
413
414
415 wxCHECK_MSG(dataViewCtrlPtr != NULL,false,_("Data view control is not correctly initialized"));
416 // convert all valid data view items to data browser items:
417 itemIDs = ::CreateDataBrowserItemIDArray(noOfEntries,items);
418 // when this method is called and currently an item is being edited this item may have already been deleted in the model (the passed item and the being edited item have
419 // not to be identical because the being edited item might be below the passed item in the hierarchy);
420 // to prevent the control trying to ask the model to update an already deleted item the control is informed that currently a deleting process
421 // has been started and that variables can currently not be updated even when requested by the system:
422 dataViewCtrlPtr->SetDeleting(true);
423 // insert all valid items into control:
424 noFailureFlag = ((noOfEntries == 0) ||
425 !(parent.IsOk()) && (this->m_dataViewControlPtr->RemoveItems(kDataBrowserNoItem,noOfEntries,itemIDs,kDataBrowserItemNoProperty) == noErr) ||
426 parent.IsOk() && (this->m_dataViewControlPtr->RemoveItems(reinterpret_cast<DataBrowserItemID>(parent.GetID()),noOfEntries,itemIDs,kDataBrowserItemNoProperty) == noErr));
427 // enable automatic updating again:
428 dataViewCtrlPtr->SetDeleting(false);
429 // give allocated array space free again:
430 delete[] itemIDs;
431 // done:
432 return noFailureFlag;
433 } /* ItemsDeleted(wxDataViewItem const&, wxDataViewItemArray const&) */
434
435 virtual bool ValueChanged(wxDataViewItem const& item, unsigned int col)
436 {
437 DataBrowserItemID itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
438 DataBrowserItemID parentID;
439
440 DataBrowserPropertyID propertyID;
441
442 wxDataViewCtrl* dataViewCtrlPtr(dynamic_cast<wxDataViewCtrl*>(this->m_dataViewControlPtr->GetWXPeer()));
443
444
445 wxCHECK_MSG(item.IsOk(), false,_("Passed item is invalid."));
446 wxCHECK_MSG(this->GetOwner() != NULL,false,_("Owner not initialized."));
447 wxCHECK_MSG(dataViewCtrlPtr != NULL, false,_("Control is wrongly initialized."));
448 parentID = reinterpret_cast<DataBrowserItemID>(this->GetOwner()->GetParent(item).GetID());
449 if ((this->m_dataViewControlPtr->GetPropertyID(col,&propertyID) == noErr) &&
450 (this->m_dataViewControlPtr->UpdateItems(parentID,1,&itemID,dataViewCtrlPtr->GetColumn(col)->GetPropertyID(),propertyID) == noErr))
451 {
452 // variable definition and initialization:
453 wxDataViewEvent dataViewEvent(wxEVT_COMMAND_DATAVIEW_ITEM_VALUE_CHANGED,dataViewCtrlPtr->GetId());
454
455 dataViewEvent.SetEventObject(dataViewCtrlPtr);
456 dataViewEvent.SetColumn(col);
457 dataViewEvent.SetItem(item);
458 // send the equivalent wxWidget event:
459 #if wxCHECK_VERSION(2,9,0)
460 dataViewCtrlPtr->HandleWindowEvent(dataViewEvent);
461 #else
462 dataViewCtrlPtr->GetEventHandler()->ProcessEvent(dataViewEvent);
463 #endif
464 // done
465 return true;
466 } /* if */
467 else
468 return false;
469 } /* ValueChanged(wxDataViewItem const&, unsigned int) */
470
471 virtual bool Cleared()
472 {
473 bool noFailureFlag = (this->m_dataViewControlPtr->RemoveItems() == noErr);
474 wxDataViewItem item;
475 wxDataViewItemArray array;
476 GetOwner()->GetChildren( item, array );
477 ItemsAdded( item, array );
478 this->m_dataViewControlPtr->SetScrollPosition(0, 0);
479 return noFailureFlag;
480 } /* Cleared() */
481
482 virtual void Resort()
483 {
484 this->m_dataViewControlPtr->Resort();
485 }
486
487 protected:
488 private:
489 //
490 // variables
491 //
492 wxMacDataViewDataBrowserListViewControl* m_dataViewControlPtr;
493 };
494
495 // ---------------------------------------------------------
496 // wxDataViewRenderer
497 // ---------------------------------------------------------
498 #pragma mark -
499 wxDataViewRenderer::wxDataViewRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
500 :wxDataViewRendererBase(varianttype,mode,align), m_alignment(align), m_mode(mode)
501 {
502 } /* wxDataViewRenderer::wxDataViewRenderer(wxString const&, wxDataViewCellMode) */
503
504 void wxDataViewRenderer::SetMode(wxDataViewCellMode mode)
505 {
506 wxDataViewColumn* dataViewColumnPtr;
507
508
509 this->m_mode = mode;
510 dataViewColumnPtr = this->GetOwner();
511 if (dataViewColumnPtr != NULL)
512 {
513 // variable definition and initialization:
514 wxDataViewCtrl* dataViewCtrlPtr(dataViewColumnPtr->GetOwner());
515
516 if (dataViewCtrlPtr != NULL)
517 {
518 // variable definition and initialization:
519 wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
520
521 if (macDataViewListCtrlPtr != NULL)
522 {
523 // variable definition and initialization:
524 DataBrowserPropertyFlags flags;
525
526 verify_noerr(macDataViewListCtrlPtr->GetPropertyFlags(dataViewColumnPtr->GetPropertyID(),&flags));
527 if (mode == wxDATAVIEW_CELL_EDITABLE)
528 flags |= kDataBrowserPropertyIsEditable;
529 else
530 flags &= ~kDataBrowserPropertyIsEditable;
531 verify_noerr(macDataViewListCtrlPtr->SetPropertyFlags(dataViewColumnPtr->GetPropertyID(),flags));
532 } /* if */
533 } /* if */
534 } /* if */
535 } /* wxDataViewRenderer::SetMode(wxDataViewCellMode) */
536
537 IMPLEMENT_ABSTRACT_CLASS(wxDataViewRenderer,wxDataViewRendererBase)
538
539 // ---------------------------------------------------------
540 // wxDataViewCustomRenderer
541 // ---------------------------------------------------------
542 #pragma mark -
543 wxDataViewCustomRenderer::wxDataViewCustomRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
544 :wxDataViewRenderer(varianttype,mode,align), m_editorCtrlPtr(NULL), m_DCPtr(NULL)
545 {
546 } /* wxDataViewCustomRenderer::wxDataViewCustomRenderer(wxString const&, wxDataViewCellMode) */
547
548 wxDataViewCustomRenderer::~wxDataViewCustomRenderer()
549 {
550 delete this->m_DCPtr;
551 } /* wxDataViewCustomRenderer::~wxDataViewCustomRenderer() */
552
553 void wxDataViewCustomRenderer::RenderText( const wxString &text, int xoffset, wxRect cell, wxDC *dc, int state )
554 {
555 wxDataViewCtrl *view = GetOwner()->GetOwner();
556 // wxColour col = (state & wxDATAVIEW_CELL_SELECTED) ? wxSystemSettings::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT) : view->GetForegroundColour();
557 wxColour col = (state & wxDATAVIEW_CELL_SELECTED) ? *wxWHITE : view->GetForegroundColour();
558 dc->SetTextForeground(col);
559 dc->DrawText( text, cell.x + xoffset, cell.y + ((cell.height - dc->GetCharHeight()) / 2));
560 }
561
562 wxDC* wxDataViewCustomRenderer::GetDC()
563 {
564 if (this->m_DCPtr == NULL)
565 {
566 if ((GetOwner() == NULL) || (GetOwner()->GetOwner() == NULL))
567 return NULL;
568 this->m_DCPtr = new wxWindowDC(this->GetOwner()->GetOwner());
569 } /* if */
570 return this->m_DCPtr;
571 } /* wxDataViewCustomRenderer::GetDC() */
572
573 bool wxDataViewCustomRenderer::Render()
574 {
575 return true;
576 } /* wxDataViewCustomRenderer::Render() */
577
578 void wxDataViewCustomRenderer::SetDC(wxDC* newDCPtr)
579 {
580 delete this->m_DCPtr;
581 this->m_DCPtr = newDCPtr;
582 } /* wxDataViewCustomRenderer::SetDC(wxDC*) */
583
584 WXDataBrowserPropertyType wxDataViewCustomRenderer::GetPropertyType() const
585 {
586 return kDataBrowserCustomType;
587 } /* wxDataViewCustomRenderer::GetPropertyType() const */
588
589 IMPLEMENT_ABSTRACT_CLASS(wxDataViewCustomRenderer, wxDataViewRenderer)
590
591 // ---------------------------------------------------------
592 // wxDataViewTextRenderer
593 // ---------------------------------------------------------
594 #pragma mark -
595 wxDataViewTextRenderer::wxDataViewTextRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
596 :wxDataViewRenderer(varianttype,mode,align)
597 {
598 } /* wxDataViewTextRenderer::wxDataViewTextRenderer(wxString const&, wxDataViewCellMode, int) */
599
600 bool wxDataViewTextRenderer::Render()
601 {
602 wxCHECK_MSG(this->GetValue().GetType() == this->GetVariantType(),false,wxString(_("Text renderer cannot render value; value type: ")) << this->GetValue().GetType());
603
604 // variable definition:
605 #if wxCHECK_VERSION(2,9,0)
606 wxCFStringRef cfString(this->GetValue().GetString(),(this->GetView()->GetFont().Ok() ? this->GetView()->GetFont().GetEncoding() : wxLocale::GetSystemEncoding()));
607 #else
608 wxMacCFStringHolder cfString(this->GetValue().GetString(),(this->GetView()->GetFont().Ok() ? this->GetView()->GetFont().GetEncoding() : wxLocale::GetSystemEncoding()));
609 #endif
610 return (::SetDataBrowserItemDataText(this->GetDataReference(),cfString) == noErr);
611 } /* wxDataViewTextRenderer::Render() */
612
613 WXDataBrowserPropertyType wxDataViewTextRenderer::GetPropertyType() const
614 {
615 return kDataBrowserTextType;
616 } /* wxDataViewTextRenderer::GetPropertyType() const */
617
618 IMPLEMENT_CLASS(wxDataViewTextRenderer,wxDataViewRenderer)
619
620 // ---------------------------------------------------------
621 // wxDataViewTextRendererAttr
622 // ---------------------------------------------------------
623 #pragma mark -
624 wxDataViewTextRendererAttr::wxDataViewTextRendererAttr(wxString const& varianttype, wxDataViewCellMode mode, int align)
625 :wxDataViewTextRenderer(varianttype,mode,align)
626 {
627 } /* wxDataViewTextRendererAttr::wxDataViewTextRendererAttr(wxString const&, wxDataViewCellMode, int) */
628
629 IMPLEMENT_CLASS(wxDataViewTextRendererAttr,wxDataViewTextRenderer)
630
631 // ---------------------------------------------------------
632 // wxDataViewBitmapRenderer
633 // ---------------------------------------------------------
634 #pragma mark -
635 wxDataViewBitmapRenderer::wxDataViewBitmapRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
636 :wxDataViewRenderer(varianttype,mode,align)
637 {
638 }
639
640 bool wxDataViewBitmapRenderer::Render()
641 // This method returns 'true' if
642 // - the passed bitmap is valid and it could be assigned to the native data browser;
643 // - the passed bitmap is invalid (or is not initialized); this case simulates a non-existing bitmap.
644 // In all other cases the method returns 'false'.
645 {
646 wxCHECK_MSG(this->GetValue().GetType() == this->GetVariantType(),false,wxString(_("Bitmap renderer cannot render value; value type: ")) << this->GetValue().GetType());
647
648 // variable definition:
649 wxBitmap bitmap;
650
651 bitmap << this->GetValue();
652 if (bitmap.Ok())
653 #if wxCHECK_VERSION(2,9,0)
654 return (::SetDataBrowserItemDataIcon(this->GetDataReference(),bitmap.GetIconRef()) == noErr);
655 #else
656 return (::SetDataBrowserItemDataIcon(this->GetDataReference(),bitmap.GetBitmapData()->GetIconRef()) == noErr);
657 #endif
658 else
659 return true;
660 } /* wxDataViewBitmapRenderer::Render() */
661
662 WXDataBrowserPropertyType wxDataViewBitmapRenderer::GetPropertyType() const
663 {
664 return kDataBrowserIconType;
665 } /* wxDataViewBitmapRenderer::GetPropertyType() const */
666
667 IMPLEMENT_CLASS(wxDataViewBitmapRenderer,wxDataViewRenderer)
668
669 // ---------------------------------------------------------
670 // wxDataViewIconTextRenderer
671 // ---------------------------------------------------------
672 #pragma mark -
673 wxDataViewIconTextRenderer::wxDataViewIconTextRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
674 :wxDataViewRenderer(varianttype,mode)
675 {
676 }
677
678 bool wxDataViewIconTextRenderer::Render()
679 {
680 wxCHECK_MSG(this->GetValue().GetType() == this->GetVariantType(),false,wxString(_("Icon & text renderer cannot render value; value type: ")) << this->GetValue().GetType());
681
682 // variable definition:
683 wxDataViewIconText iconText;
684
685 iconText << this->GetValue();
686
687 // variable definition:
688 #if wxCHECK_VERSION(2,9,0)
689 wxCFStringRef cfString(iconText.GetText(),(this->GetView()->GetFont().Ok() ? this->GetView()->GetFont().GetEncoding() : wxLocale::GetSystemEncoding()));
690 #else
691 wxMacCFStringHolder cfString(iconText.GetText(),(this->GetView()->GetFont().Ok() ? this->GetView()->GetFont().GetEncoding() : wxLocale::GetSystemEncoding()));
692 #endif
693
694 if (iconText.GetIcon().IsOk())
695 if (::SetDataBrowserItemDataIcon(this->GetDataReference(),MAC_WXHICON(iconText.GetIcon().GetHICON())) != noErr)
696 return false;
697 return (::SetDataBrowserItemDataText(this->GetDataReference(),cfString) == noErr);
698 } /* wxDataViewIconTextRenderer::Render() */
699
700 WXDataBrowserPropertyType wxDataViewIconTextRenderer::GetPropertyType() const
701 {
702 return kDataBrowserIconAndTextType;
703 } /* wxDataViewIconTextRenderer::GetPropertyType() const */
704
705 IMPLEMENT_ABSTRACT_CLASS(wxDataViewIconTextRenderer,wxDataViewRenderer)
706
707
708 // ---------------------------------------------------------
709 // wxDataViewToggleRenderer
710 // ---------------------------------------------------------
711 #pragma mark -
712 wxDataViewToggleRenderer::wxDataViewToggleRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
713 :wxDataViewRenderer(varianttype,mode)
714 {
715 }
716
717 bool wxDataViewToggleRenderer::Render()
718 {
719 wxCHECK_MSG(this->GetValue().GetType() == this->GetVariantType(),false,wxString(_("Toggle renderer cannot render value; value type: ")) << this->GetValue().GetType());
720 return (::SetDataBrowserItemDataButtonValue(this->GetDataReference(),this->GetValue().GetBool()) == noErr);
721 } /* wxDataViewToggleRenderer::Render() */
722
723 WXDataBrowserPropertyType wxDataViewToggleRenderer::GetPropertyType() const
724 {
725 return kDataBrowserCheckboxType;
726 } /* wxDataViewToggleRenderer::GetPropertyType() const */
727
728 IMPLEMENT_ABSTRACT_CLASS(wxDataViewToggleRenderer,wxDataViewRenderer)
729
730 // ---------------------------------------------------------
731 // wxDataViewProgressRenderer
732 // ---------------------------------------------------------
733 #pragma mark -
734 wxDataViewProgressRenderer::wxDataViewProgressRenderer(wxString const& label, wxString const& varianttype, wxDataViewCellMode mode, int align)
735 :wxDataViewRenderer(varianttype,mode,align)
736 {
737 }
738
739 bool wxDataViewProgressRenderer::Render()
740 {
741 wxCHECK_MSG(this->GetValue().GetType() == this->GetVariantType(),false,wxString(_("Progress renderer cannot render value type; value type: ")) << this->GetValue().GetType());
742 return ((::SetDataBrowserItemDataMinimum(this->GetDataReference(), 0) == noErr) &&
743 (::SetDataBrowserItemDataMaximum(this->GetDataReference(),100) == noErr) &&
744 (::SetDataBrowserItemDataValue (this->GetDataReference(),this->GetValue().GetLong()) == noErr));
745 } /* wxDataViewProgressRenderer::Render() */
746
747 WXDataBrowserPropertyType wxDataViewProgressRenderer::GetPropertyType() const
748 {
749 return kDataBrowserProgressBarType;
750 } /* wxDataViewProgressRenderer::GetPropertyType() const */
751
752 IMPLEMENT_ABSTRACT_CLASS(wxDataViewProgressRenderer,wxDataViewRenderer)
753
754 // ---------------------------------------------------------
755 // wxDataViewDateRenderer
756 // ---------------------------------------------------------
757 #pragma mark -
758 wxDataViewDateRenderer::wxDataViewDateRenderer(wxString const& varianttype, wxDataViewCellMode mode, int align)
759 :wxDataViewRenderer(varianttype,mode,align)
760 {
761 }
762
763 bool wxDataViewDateRenderer::Render()
764 {
765 wxCHECK_MSG(this->GetValue().GetType() == this->GetVariantType(),false,wxString(_("Date renderer cannot render value; value type: ")) << this->GetValue().GetType());
766 return (::SetDataBrowserItemDataDateTime(this->GetDataReference(),this->GetValue().GetDateTime().Subtract(wxDateTime(1,wxDateTime::Jan,1904)).GetSeconds().GetLo()) == noErr);
767 } /* wxDataViewDateRenderer::Render() */
768
769 WXDataBrowserPropertyType wxDataViewDateRenderer::GetPropertyType() const
770 {
771 return kDataBrowserDateTimeType;
772 } /* wxDataViewDateRenderer::GetPropertyType() const */
773
774 IMPLEMENT_ABSTRACT_CLASS(wxDataViewDateRenderer,wxDataViewRenderer)
775
776 // ---------------------------------------------------------
777 // wxDataViewColumn
778 // ---------------------------------------------------------
779 #pragma mark -
780 wxDataViewColumn::wxDataViewColumn(wxString const &title, wxDataViewRenderer *cell, unsigned int model_column, int width, wxAlignment align, int flags)
781 :wxDataViewColumnBase(title,cell,model_column,width,align,flags), m_ascending(true),
782 m_flags(flags & ~(wxDATAVIEW_COL_HIDDEN)), m_maxWidth(30000), m_minWidth(0), m_width(width >= 0 ? width : wxDVC_DEFAULT_WIDTH),
783 m_alignment(align), m_title(title)
784 {
785 } /* wxDataViewColumn::wxDataViewColumn(wxString const &title, wxDataViewRenderer*, unsigned int, int, wxAlignment, int) */
786
787 wxDataViewColumn::wxDataViewColumn(wxBitmap const& bitmap, wxDataViewRenderer *cell, unsigned int model_column, int width, wxAlignment align, int flags)
788 :wxDataViewColumnBase(bitmap,cell,model_column,width,align,flags), m_ascending(true),
789 m_flags(flags & ~(wxDATAVIEW_COL_HIDDEN)), m_maxWidth(30000), m_minWidth(0), m_width(width >= 0 ? width : wxDVC_DEFAULT_WIDTH),
790 m_alignment(align)
791 {
792 } /* wxDataViewColumn::wxDataViewColumn(wxBitmap const&, wxDataViewRenderer*, unsigned int, int, wxAlignment, int) */
793
794 void wxDataViewColumn::SetAlignment(wxAlignment align)
795 {
796 wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
797
798
799 this->m_alignment = align;
800 if (dataViewCtrlPtr != NULL)
801 {
802 // variable definition and initialization:
803 wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
804
805 if (macDataViewListCtrlPtr != NULL)
806 {
807 // variable definition and initialization:
808 DataBrowserListViewHeaderDesc headerDescription;
809
810 wxCHECK_RET(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not get header description."));
811 switch (align)
812 {
813 case wxALIGN_CENTER:
814 case wxALIGN_CENTER_HORIZONTAL:
815 headerDescription.btnFontStyle.just = teCenter;
816 break;
817 case wxALIGN_LEFT:
818 headerDescription.btnFontStyle.just = teFlushLeft;
819 break;
820 case wxALIGN_RIGHT:
821 headerDescription.btnFontStyle.just = teFlushRight;
822 break;
823 default:
824 headerDescription.btnFontStyle.just = teFlushDefault;
825 } /* switch */
826 wxCHECK_RET(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not set alignment."));
827 } /* if */
828 } /* if */
829 } /* wxDataViewColumn::SetAlignment(wxAlignment) */
830
831 void wxDataViewColumn::SetBitmap(wxBitmap const& bitmap)
832 {
833 wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
834
835
836 wxDataViewColumnBase::SetBitmap(bitmap);
837 if (dataViewCtrlPtr != NULL)
838 {
839 // variable definition and initialization:
840 wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
841
842 if (macDataViewListCtrlPtr != NULL)
843 {
844 // variable definition and initialization:
845 DataBrowserListViewHeaderDesc headerDescription;
846
847 wxCHECK_RET(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not get header description."));
848 if (this->GetBitmap().Ok())
849 #if wxCHECK_VERSION(2,9,0)
850 headerDescription.btnContentInfo.u.iconRef = this->GetBitmap().GetIconRef();
851 #else
852 headerDescription.btnContentInfo.u.iconRef = this->GetBitmap().GetBitmapData()->GetIconRef();
853 #endif
854 else
855 headerDescription.btnContentInfo.u.iconRef = NULL;
856 wxCHECK_RET(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not set icon."));
857 } /* if */
858 } /* if */
859 } /* wxDataViewColumn::SetBitmap(wxBitmap const&) */
860
861 void wxDataViewColumn::SetFlags(int flags)
862 {
863 this->SetHidden ((flags & wxDATAVIEW_COL_HIDDEN) != 0);
864 this->SetReorderable((flags & wxDATAVIEW_COL_REORDERABLE) != 0);
865 this->SetResizeable ((flags & wxDATAVIEW_COL_RESIZABLE) != 0);
866 this->SetSortable ((flags & wxDATAVIEW_COL_SORTABLE) != 0);
867 } /* wxDataViewColumn::SetFlags(int) */
868
869 void wxDataViewColumn::SetMaxWidth(int maxWidth)
870 {
871 wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
872
873
874 this->m_maxWidth = maxWidth;
875 if (dataViewCtrlPtr != NULL)
876 {
877 // variable definition and initialization:
878 wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
879
880 if (macDataViewListCtrlPtr != NULL)
881 {
882 // variable definition and initialization:
883 DataBrowserListViewHeaderDesc headerDescription;
884
885 wxCHECK_RET(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not get header description."));
886 headerDescription.maximumWidth = static_cast<UInt16>(maxWidth);
887 wxCHECK_RET(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not set maximum width."));
888 } /* if */
889 } /* if */
890 } /* wxDataViewColumn::SetMaxWidth(int) */
891
892 void wxDataViewColumn::SetMinWidth(int minWidth)
893 {
894 wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
895
896
897 this->m_minWidth = minWidth;
898 if (dataViewCtrlPtr != NULL)
899 {
900 // variable definition and initialization:
901 wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
902
903 if (macDataViewListCtrlPtr != NULL)
904 {
905 // variable definition and initialization:
906 DataBrowserListViewHeaderDesc headerDescription;
907
908 wxCHECK_RET(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not get header description."));
909 headerDescription.minimumWidth = static_cast<UInt16>(minWidth);
910 wxCHECK_RET(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not set minimum width."));
911 } /* if */
912 } /* if */
913 } /* wxDataViewColumn::SetMaxWidth(int) */
914
915 void wxDataViewColumn::SetReorderable(bool reorderable)
916 {
917 // first set the internal flag of the column:
918 if (reorderable)
919 this->m_flags |= wxDATAVIEW_COL_REORDERABLE;
920 else
921 this->m_flags &= ~wxDATAVIEW_COL_REORDERABLE;
922 // if the column is associated with a control change also immediately the flags of the control:
923 wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner()); // variable definition and initialization
924
925 if (dataViewCtrlPtr != NULL)
926 {
927 // variable definition and initialization:
928 DataBrowserPropertyFlags flags;
929 wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
930
931 wxCHECK_RET(macDataViewListCtrlPtr != NULL, _("Valid pointer to native data view control does not exist"));
932 wxCHECK_RET(macDataViewListCtrlPtr->GetPropertyFlags(this->GetPropertyID(),&flags) == noErr,_("Could not get property flags."));
933 if (reorderable)
934 flags |= kDataBrowserListViewMovableColumn;
935 else
936 flags &= ~kDataBrowserListViewMovableColumn;
937 wxCHECK_RET(macDataViewListCtrlPtr->SetPropertyFlags(this->GetPropertyID(),flags) == noErr,_("Could not set property flags."));
938 } /* if */
939 } /* wxDataViewColumn::SetReorderable(bool) */
940
941 void wxDataViewColumn::SetResizeable(bool resizeable)
942 {
943 // first set the internal flag of the column:
944 if (resizeable)
945 this->m_flags |= wxDATAVIEW_COL_RESIZABLE;
946 else
947 this->m_flags &= ~wxDATAVIEW_COL_RESIZABLE;
948 // if the column is associated with a control change also immediately the flags of the control:
949 wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner()); // variable definition and initialization
950
951 if (dataViewCtrlPtr != NULL)
952 {
953 // variable definition and initialization:
954 wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
955
956 if (macDataViewListCtrlPtr != NULL)
957 {
958 // variable definition and initialization:
959 DataBrowserListViewHeaderDesc headerDescription;
960
961 verify_noerr(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription));
962 if (resizeable) {
963 headerDescription.minimumWidth = 0;
964 headerDescription.maximumWidth = 30000;
965 }
966 else {
967 headerDescription.minimumWidth = this->m_width;
968 headerDescription.maximumWidth = this->m_width;
969 }
970 verify_noerr(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription));
971 macDataViewListCtrlPtr->SetSortProperty(this->GetPropertyID());
972 } /* if */
973 } /* if */
974 } /* wxDataViewColumn::SetResizeable(bool) */
975
976 void wxDataViewColumn::SetSortable(bool sortable)
977 {
978 // first set the internal flag of the column:
979 if (sortable)
980 this->m_flags |= wxDATAVIEW_COL_SORTABLE;
981 else
982 this->m_flags &= ~wxDATAVIEW_COL_SORTABLE;
983 // if the column is associated with a control change also immediately the flags of the control:
984 wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner()); // variable definition and initialization
985
986 if (dataViewCtrlPtr != NULL)
987 {
988 // variable definition and initialization:
989 DataBrowserPropertyFlags flags;
990 wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
991
992 wxCHECK_RET(macDataViewListCtrlPtr != NULL, _("Valid pointer to native data view control does not exist"));
993 wxCHECK_RET(macDataViewListCtrlPtr->GetPropertyFlags(this->GetPropertyID(),&flags) == noErr,_("Could not get property flags."));
994 if (sortable)
995 flags |= kDataBrowserListViewSortableColumn;
996 else
997 flags &= ~kDataBrowserListViewSortableColumn;
998 wxCHECK_RET(macDataViewListCtrlPtr->SetPropertyFlags(this->GetPropertyID(),flags) == noErr,_("Could not set property flags."));
999 } /* if */
1000 } /* wxDataViewColumn::SetSortable(bool) */
1001
1002 void wxDataViewColumn::SetSortOrder(bool ascending)
1003 {
1004 wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
1005
1006
1007 this->m_ascending = ascending;
1008 if (dataViewCtrlPtr != NULL)
1009 {
1010 // variable definition and initialization:
1011 wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
1012
1013 if (macDataViewListCtrlPtr != NULL)
1014 {
1015 // variable definition and initialization:
1016 DataBrowserListViewHeaderDesc headerDescription;
1017
1018 verify_noerr(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription));
1019 if (ascending)
1020 headerDescription.initialOrder = kDataBrowserOrderIncreasing;
1021 else
1022 headerDescription.initialOrder = kDataBrowserOrderDecreasing;
1023 verify_noerr(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription));
1024 macDataViewListCtrlPtr->SetSortProperty(this->GetPropertyID());
1025 } /* if */
1026 } /* if */
1027 } /* wxDataViewColumn::SetSortOrder(bool) */
1028
1029 void wxDataViewColumn::SetTitle(wxString const& title)
1030 {
1031 wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
1032
1033
1034 this->m_title = title;
1035 if (dataViewCtrlPtr != NULL)
1036 {
1037 // variable definition and initialization:
1038 wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
1039
1040 if (macDataViewListCtrlPtr != NULL)
1041 {
1042 // variable definition and initialization:
1043 DataBrowserListViewHeaderDesc headerDescription;
1044 #if wxCHECK_VERSION(2,9,0)
1045 wxCFStringRef cfTitle(title,(dataViewCtrlPtr->GetFont().Ok() ? dataViewCtrlPtr->GetFont().GetEncoding() : wxLocale::GetSystemEncoding()));
1046 #else
1047 wxMacCFStringHolder cfTitle(title,(dataViewCtrlPtr->GetFont().Ok() ? dataViewCtrlPtr->GetFont().GetEncoding() : wxLocale::GetSystemEncoding()));
1048 #endif
1049
1050 wxCHECK_RET(macDataViewListCtrlPtr->GetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not get header description."));
1051 headerDescription.titleString = cfTitle;
1052 wxCHECK_RET(macDataViewListCtrlPtr->SetHeaderDesc(this->GetPropertyID(),&headerDescription) == noErr,_("Could not set header description."));
1053 } /* if */
1054 } /* if */
1055 } /* wxDataViewColumn::SetTitle(wxString const&) */
1056
1057 void wxDataViewColumn::SetWidth(int width)
1058 {
1059 wxDataViewCtrl* dataViewCtrlPtr(this->GetOwner());
1060
1061
1062 if ((width >= this->m_minWidth) && (width <= this->m_maxWidth))
1063 {
1064 this->m_width = width;
1065 if (dataViewCtrlPtr != NULL)
1066 {
1067 // variable definition and initialization:
1068 wxMacDataViewDataBrowserListViewControlPointer macDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(dataViewCtrlPtr->GetPeer()));
1069
1070 if (macDataViewListCtrlPtr != NULL)
1071 wxCHECK_RET(macDataViewListCtrlPtr->SetColumnWidth(this->GetPropertyID(),static_cast<UInt16>(width)) == noErr,_("Could not set column width."));
1072 } /* if */
1073 } /* if */
1074 } /* wxDataViewColumn::SetWidth(int) */
1075
1076 IMPLEMENT_ABSTRACT_CLASS(wxDataViewColumn,wxDataViewColumnBase)
1077
1078 //-----------------------------------------------------------------------------
1079 // wxDataViewCtrl
1080 //-----------------------------------------------------------------------------
1081
1082
1083 wxDataViewCtrl::~wxDataViewCtrl()
1084 {
1085 ClearColumns();
1086 }
1087
1088 #pragma mark -
1089 void wxDataViewCtrl::Init()
1090 {
1091 this->m_CustomRendererPtr = NULL;
1092 this->m_Deleting = false;
1093 this->m_macIsUserPane = false;
1094 this->m_cgContext = NULL;
1095 } /* wxDataViewCtrl::Init() */
1096
1097 bool wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator )
1098 {
1099 if (!(this->wxControl::Create(parent,id,pos,size,style & ~(wxHSCROLL | wxVSCROLL),validator)))
1100 return false;
1101
1102 #ifdef __WXMAC__
1103 MacSetClipChildren(true) ;
1104 #endif
1105
1106 this->m_peer = new wxMacDataViewDataBrowserListViewControl(this,pos,size,style);
1107
1108 if ( style & wxBORDER_NONE )
1109 this->m_peer->SetData( kControlNoPart, kControlDataBrowserIncludesFrameAndFocusTag, (Boolean) false ) ;
1110
1111 this->MacPostControlCreate(pos,size);
1112 ::SetAutomaticControlDragTrackingEnabledForWindow(::GetControlOwner(this->m_peer->GetControlRef()),true);
1113
1114 InstallControlEventHandler(this->m_peer->GetControlRef(),GetwxMacDataViewCtrlEventHandlerUPP(),GetEventTypeCount(eventList),eventList,this,NULL);
1115
1116 ::SetDataBrowserTableViewHiliteStyle( this->m_peer->GetControlRef(), kDataBrowserTableViewFillHilite );
1117
1118 return true;
1119 } /* wxDataViewCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style, const wxValidator& validator) */
1120
1121 /*static*/
1122 wxVisualAttributes wxDataViewCtrl::GetClassDefaultAttributes(wxWindowVariant variant)
1123 {
1124 wxVisualAttributes attr;
1125
1126 attr.colFg = wxSystemSettings::GetColour( wxSYS_COLOUR_WINDOWTEXT );
1127 attr.colBg = wxSystemSettings::GetColour( wxSYS_COLOUR_LISTBOX );
1128 attr.font.MacCreateFromThemeFont(kThemeViewsFont);
1129
1130 return attr;
1131 }
1132
1133 bool wxDataViewCtrl::AssociateModel(wxDataViewModel* model)
1134 {
1135 if (!wxDataViewCtrlBase::AssociateModel(model))
1136 return false;
1137
1138 model->AddNotifier(new wxMacDataViewModelNotifier(dynamic_cast<wxMacDataViewDataBrowserListViewControl*>(this->m_peer)));
1139
1140 return true;
1141 }
1142
1143 bool wxDataViewCtrl::AppendColumn(wxDataViewColumn* columnPtr)
1144 {
1145 return InsertColumn( kDataBrowserListViewAppendColumn, columnPtr );
1146 }
1147
1148 bool wxDataViewCtrl::PrependColumn(wxDataViewColumn* columnPtr)
1149 {
1150 return InsertColumn( 0, columnPtr );
1151 }
1152
1153 bool wxDataViewCtrl::InsertColumn(unsigned int pos, wxDataViewColumn* columnPtr)
1154 {
1155 DataBrowserListViewColumnDesc columnDescription;
1156
1157 DataBrowserPropertyID NewPropertyID;
1158
1159 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1160
1161 #if wxCHECK_VERSION(2,9,0)
1162 wxCFStringRef title(columnPtr->GetTitle(),this->m_font.Ok() ? this->GetFont().GetEncoding() : wxLocale::GetSystemEncoding());
1163 #else
1164 wxMacCFStringHolder title(columnPtr->GetTitle(),this->m_font.Ok() ? this->GetFont().GetEncoding() : wxLocale::GetSystemEncoding());
1165 #endif
1166
1167
1168 // first, some error checking:
1169 wxCHECK_MSG(MacDataViewListCtrlPtr != NULL, false,_("m_peer is not or incorrectly initialized"));
1170 wxCHECK_MSG(columnPtr != NULL, false,_("Column pointer must not be NULL."));
1171 wxCHECK_MSG(columnPtr->GetRenderer() != NULL, false,_("Column does not have a renderer."));
1172 wxCHECK_MSG(this->GetModel() != NULL, false,_("No model associated with control."));
1173 wxCHECK_MSG((columnPtr->GetModelColumn() >= 0) &&
1174 (columnPtr->GetModelColumn() < this->GetModel()->GetColumnCount()),false,_("Column's model column has no equivalent in the associated model."));
1175
1176 // try to get new ID for the column:
1177 wxCHECK_MSG(MacDataViewListCtrlPtr->GetFreePropertyID(&NewPropertyID) == noErr,false,_("Cannot create new column's ID. Probably max. number of columns reached."));
1178 // full column variable initialization:
1179 columnPtr->SetPropertyID(NewPropertyID);
1180 // add column to wxWidget's internal structure:
1181 wxCHECK_MSG(this->wxDataViewCtrlBase::AppendColumn(columnPtr) &&
1182 this->m_ColumnPointers.insert(ColumnPointerHashMapType::value_type(NewPropertyID,columnPtr)).second,false,_("Could not add column to internal structures."));
1183 // create a column description and add column to the native control:
1184 wxCHECK_MSG(::InitializeColumnDescription(columnDescription,columnPtr,NewPropertyID,title), false,_("Column description could not be initialized."));
1185 wxCHECK_MSG(MacDataViewListCtrlPtr->AddColumn(&columnDescription,pos) == noErr,false,_("Column could not be added."));
1186
1187 // final adjustments for the layout:
1188 wxCHECK_MSG(MacDataViewListCtrlPtr->SetColumnWidth(NewPropertyID,columnPtr->GetWidth()) == noErr,false,_("Column width could not be set."));
1189
1190 // make sure that the data is up-to-date...
1191 // if the newly appended column is the first column add the initial data to the control and mark the column as an expander column,
1192 // otherwise ask the control to 'update' the data in the newly appended column:
1193 if (this->GetColumnCount() == 1)
1194 {
1195 this->SetExpanderColumn(columnPtr);
1196 this->AddChildrenLevel(wxDataViewItem());
1197 } /* if */
1198 else
1199 MacDataViewListCtrlPtr->UpdateItems(kDataBrowserNoItem,0,NULL,kDataBrowserItemNoProperty,NewPropertyID);
1200 // done:
1201 return true;
1202 }
1203
1204 bool wxDataViewCtrl::ClearColumns()
1205 {
1206 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1207
1208
1209 while (this->m_ColumnPointers.begin() != this->m_ColumnPointers.end())
1210 {
1211 wxCHECK_MSG(MacDataViewListCtrlPtr->RemoveColumnByProperty(this->m_ColumnPointers.begin()->first) == noErr,false,_("Could not remove column."));
1212 delete this->m_ColumnPointers.begin()->second;
1213 this->m_ColumnPointers.erase(this->m_ColumnPointers.begin());
1214 } /* while */
1215 return true;
1216 }
1217
1218 bool wxDataViewCtrl::DeleteColumn(wxDataViewColumn* columnPtr)
1219 {
1220 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1221
1222
1223 if ((MacDataViewListCtrlPtr->RemoveColumnByProperty(columnPtr->GetPropertyID()) == noErr) && (this->m_ColumnPointers.erase(columnPtr->GetPropertyID()) > 0))
1224 {
1225 delete columnPtr;
1226 return true;
1227 } /* if */
1228 else
1229 return false;
1230 } /* wxDataViewCtrl::DeleteColumn(wxDataViewColumn*) */
1231
1232 wxDataViewColumn* wxDataViewCtrl::GetColumn(unsigned int pos) const
1233 {
1234 DataBrowserPropertyID propertyID;
1235
1236 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1237
1238
1239 if (MacDataViewListCtrlPtr->GetPropertyID(pos,&propertyID) == noErr)
1240 {
1241 // variable definition:
1242 ColumnPointerHashMapType::const_iterator Result(this->m_ColumnPointers.find(propertyID));
1243
1244 if (Result != this->m_ColumnPointers.end())
1245 return Result->second;
1246 else
1247 return NULL;
1248 } /* if */
1249 else
1250 return NULL;
1251 } /* wxDataViewCtrl::GetColumn(unsigned int pos) const */
1252
1253 unsigned int wxDataViewCtrl::GetColumnCount() const
1254 {
1255 return this->m_ColumnPointers.size();
1256 } /* wxDataViewCtrl::GetColumnCount() const */
1257
1258 int wxDataViewCtrl::GetColumnPosition(wxDataViewColumn const* columnPtr) const
1259 {
1260 if (columnPtr != NULL)
1261 {
1262 // variable definition and initialization:
1263 DataBrowserTableViewColumnIndex Position;
1264 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1265
1266 wxCHECK_MSG(MacDataViewListCtrlPtr->GetColumnIndex(columnPtr->GetPropertyID(),&Position) == noErr,-1,_("Could not determine column's position"));
1267 return static_cast<int>(Position);
1268 } /* if */
1269 else
1270 return wxNOT_FOUND;
1271 } /* wxDataViewCtrl::GetColumnPosition(wxDataViewColumn const*) const */
1272
1273 void wxDataViewCtrl::Collapse(wxDataViewItem const& item)
1274 {
1275 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1276
1277
1278 MacDataViewListCtrlPtr->CloseContainer(reinterpret_cast<DataBrowserItemID>(item.GetID()));
1279 } /* wxDataViewCtrl::Collapse(wxDataViewItem const&) */
1280
1281 void wxDataViewCtrl::EnsureVisible(wxDataViewItem const& item, wxDataViewColumn const* columnPtr)
1282 {
1283 if (item.IsOk())
1284 {
1285 // variable definition and initialization:
1286 DataBrowserPropertyID propertyID;
1287 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1288
1289 if (columnPtr != NULL)
1290 propertyID = columnPtr->GetPropertyID();
1291 else
1292 propertyID = kDataBrowserNoItem;
1293 MacDataViewListCtrlPtr->RevealItem(reinterpret_cast<DataBrowserItemID>(item.GetID()),propertyID,kDataBrowserRevealOnly);
1294 } /* if */
1295 } /* wxDataViewCtrl::EnsureVisible(wxDataViewItem const&, wxDataViewColumn const*) */
1296
1297 void wxDataViewCtrl::Expand(wxDataViewItem const& item)
1298 {
1299 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1300
1301
1302 MacDataViewListCtrlPtr->OpenContainer(reinterpret_cast<DataBrowserItemID>(item.GetID()));
1303 } /* wxDataViewCtrl::Expand(wxDataViewItem const&) */
1304
1305 wxDataViewColumn* wxDataViewCtrl::GetSortingColumn() const
1306 {
1307 DataBrowserPropertyID propertyID;
1308
1309 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1310
1311
1312 if (MacDataViewListCtrlPtr->GetSortProperty(&propertyID) == noErr)
1313 return this->GetColumnPtr(propertyID);
1314 else
1315 return NULL;
1316 } /* wxDataViewCtrl::GetSortingColumn() const */
1317
1318 unsigned int wxDataViewCtrl::GetCount() const
1319 {
1320 ItemCount noOfItems;
1321
1322
1323 wxCHECK_MSG(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer)->GetItemCount(&noOfItems) == noErr,0,_("Could not determine number of items"));
1324 return noOfItems;
1325 } /* wxDataViewCtrl::GetCount() const */
1326
1327 wxRect wxDataViewCtrl::GetItemRect(wxDataViewItem const& item, wxDataViewColumn const* columnPtr) const
1328 {
1329 if (item.IsOk() && (columnPtr != NULL))
1330 {
1331 // variable definition:
1332 Rect MacRectangle;
1333 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1334
1335 if (MacDataViewListCtrlPtr->GetPartBounds(reinterpret_cast<DataBrowserItemID>(item.GetID()),columnPtr->GetPropertyID(),kDataBrowserPropertyContentPart,&MacRectangle) == noErr)
1336 {
1337 // variable definition:
1338 wxRect rectangle;
1339
1340 ::wxMacNativeToRect(&MacRectangle,&rectangle);
1341 return rectangle;
1342 } /* if */
1343 else
1344 return wxRect();
1345 } /* if */
1346 else
1347 return wxRect();
1348 } /* wxDataViewCtrl::GetItemRect(wxDataViewItem const&, unsigned int) const */
1349
1350 wxDataViewItem wxDataViewCtrl::GetSelection() const
1351 {
1352 wxArrayDataBrowserItemID itemIDs;
1353
1354 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1355
1356
1357 if (MacDataViewListCtrlPtr->GetSelectedItemIDs(itemIDs) > 0)
1358 return wxDataViewItem(reinterpret_cast<void*>(itemIDs[0]));
1359 else
1360 return wxDataViewItem();
1361 } /* wxDataViewCtrl::GetSelection() const */
1362
1363 int wxDataViewCtrl::GetSelections(wxDataViewItemArray& sel) const
1364 {
1365 size_t NoOfSelectedItems;
1366
1367 wxArrayDataBrowserItemID itemIDs;
1368
1369 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1370
1371
1372 NoOfSelectedItems = MacDataViewListCtrlPtr->GetSelectedItemIDs(itemIDs);
1373 sel.Empty();
1374 sel.SetCount(NoOfSelectedItems);
1375 for (size_t i=0; i<NoOfSelectedItems; ++i)
1376 sel[i] = wxDataViewItem(reinterpret_cast<void*>(itemIDs[i]));
1377 return static_cast<int>(NoOfSelectedItems);
1378 } /* wxDataViewCtrl::GetSelections(wxDataViewItemArray&) const */
1379
1380 void wxDataViewCtrl::HitTest(wxPoint const& point, wxDataViewItem& item, wxDataViewColumn*& columnPtr) const
1381 {
1382 item = wxDataViewItem();
1383 columnPtr = NULL;
1384 } /* wxDataViewCtrl::HitTest(wxPoint const&, wxDataViewItem&, wxDataViewColumn*&) const */
1385
1386 bool wxDataViewCtrl::IsSelected(wxDataViewItem const& item) const
1387 {
1388 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1389
1390
1391 return MacDataViewListCtrlPtr->IsItemSelected(reinterpret_cast<DataBrowserItemID>(item.GetID()));
1392 } /* wxDataViewCtrl::IsSelected(wxDataViewItem const&) const */
1393
1394 void wxDataViewCtrl::SelectAll()
1395 {
1396 DataBrowserItemID* itemIDPtr;
1397
1398 Handle handle(::NewHandle(0));
1399
1400 size_t NoOfItems;
1401
1402 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1403
1404
1405 wxCHECK_RET(MacDataViewListCtrlPtr->GetItems(kDataBrowserNoItem,true,kDataBrowserItemAnyState,handle) == noErr,_("Could not get items."));
1406 NoOfItems = static_cast<size_t>(::GetHandleSize(handle)/sizeof(DataBrowserItemID));
1407 HLock(handle);
1408 itemIDPtr = (DataBrowserItemID*) (*handle);
1409 MacDataViewListCtrlPtr->SetSelectedItems(NoOfItems,itemIDPtr,kDataBrowserItemsAssign);
1410 HUnlock(handle);
1411 DisposeHandle(handle);
1412 } /* wxDataViewCtrl::SelectAll() */
1413
1414 void wxDataViewCtrl::Select(wxDataViewItem const& item)
1415 {
1416 if (item.IsOk())
1417 {
1418 // variable definition and initialization:
1419 DataBrowserItemID itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
1420 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1421
1422 MacDataViewListCtrlPtr->SetSelectedItems(1,&itemID,kDataBrowserItemsAdd);
1423 } /* if */
1424 } /* wxDataViewCtrl::Select(wxDataViewItem const&) */
1425
1426 void wxDataViewCtrl::SetSelections(wxDataViewItemArray const& sel)
1427 {
1428 size_t const NoOfSelections = sel.GetCount();
1429
1430 DataBrowserItemID* itemIDs;
1431
1432 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1433
1434
1435 itemIDs = new DataBrowserItemID[NoOfSelections];
1436 for (size_t i=0; i<NoOfSelections; ++i)
1437 itemIDs[i] = reinterpret_cast<DataBrowserItemID>(sel[i].GetID());
1438 MacDataViewListCtrlPtr->SetSelectedItems(NoOfSelections,itemIDs,kDataBrowserItemsAssign);
1439 delete[] itemIDs;
1440 } /* wxDataViewCtrl::SetSelections(wxDataViewItemArray const&) */
1441
1442 void wxDataViewCtrl::Unselect(wxDataViewItem const& item)
1443 {
1444 if (item.IsOk())
1445 {
1446 // variable definition and initialization:
1447 DataBrowserItemID itemID(reinterpret_cast<DataBrowserItemID>(item.GetID()));
1448 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1449
1450 MacDataViewListCtrlPtr->SetSelectedItems(1,&itemID,kDataBrowserItemsRemove);
1451 } /* if */
1452 } /* wxDataViewCtrl::Unselect(wxDataViewItem const&) */
1453
1454 void wxDataViewCtrl::UnselectAll()
1455 {
1456 DataBrowserItemID* itemIDPtr;
1457
1458 Handle handle(::NewHandle(0));
1459
1460 size_t NoOfItems;
1461
1462 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1463
1464
1465 wxCHECK_RET(MacDataViewListCtrlPtr->GetItems(kDataBrowserNoItem,true,kDataBrowserItemAnyState,handle) == noErr,_("Could not get items."));
1466 NoOfItems = static_cast<size_t>(::GetHandleSize(handle)/sizeof(DataBrowserItemID));
1467 HLock(handle);
1468 itemIDPtr = (DataBrowserItemID*) (*handle);
1469 MacDataViewListCtrlPtr->SetSelectedItems(NoOfItems,itemIDPtr,kDataBrowserItemsRemove);
1470 HUnlock(handle);
1471 DisposeHandle(handle);
1472 } /* wxDataViewCtrl::UnselectAll() */
1473
1474 // data handling:
1475 void wxDataViewCtrl::AddChildrenLevel(wxDataViewItem const& parentItem)
1476 {
1477 int NoOfChildren;
1478
1479 wxDataViewItemArray items;
1480
1481
1482 wxCHECK_RET(this->GetModel() != NULL,_("Model pointer not initialized."));
1483 NoOfChildren = this->GetModel()->GetChildren(parentItem,items);
1484 #if 0
1485 for (int i=0; i<NoOfChildren; ++i)
1486 (void) this->GetModel()->ItemAdded(parentItem,items[i]);
1487 #else
1488 (void) this->GetModel()->ItemsAdded(parentItem,items);
1489 #endif
1490 }
1491
1492 void wxDataViewCtrl::FinishCustomItemEditing()
1493 {
1494 if (this->GetCustomRendererItem().IsOk())
1495 {
1496 this->GetCustomRendererPtr()->FinishEditing();
1497 this->SetCustomRendererItem(wxDataViewItem());
1498 this->SetCustomRendererPtr (NULL);
1499 }
1500 }
1501
1502 wxDataViewColumn* wxDataViewCtrl::GetColumnPtr(WXDataBrowserPropertyID propertyID) const
1503 {
1504 // variable definition:
1505 ColumnPointerHashMapType::const_iterator Result(this->m_ColumnPointers.find(propertyID));
1506
1507 if (Result != this->m_ColumnPointers.end())
1508 return Result->second;
1509 else
1510 return NULL;
1511 }
1512
1513 // inherited methods from wxDataViewCtrlBase
1514 void wxDataViewCtrl::DoSetExpanderColumn()
1515 {
1516 if (this->GetExpanderColumn() != NULL)
1517 {
1518 // variable definition and initialization:
1519 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1520
1521 (void) MacDataViewListCtrlPtr->SetDisclosureColumn(this->GetExpanderColumn()->GetPropertyID(),false); // second parameter explicitely passed to ensure that arrow is centered
1522 }
1523 }
1524
1525 void wxDataViewCtrl::DoSetIndent()
1526 {
1527 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1528
1529 (void) MacDataViewListCtrlPtr->SetIndent(static_cast<float>(this->GetIndent()));
1530 }
1531
1532 // event handling:
1533 void wxDataViewCtrl::OnSize(wxSizeEvent& event)
1534 {
1535 unsigned int const NoOfColumns = this->GetColumnCount();
1536
1537
1538 for (unsigned int i=0; i<NoOfColumns; ++i)
1539 {
1540 // variable definition and initialization:
1541 wxDataViewColumn* dataViewColumnPtr(this->GetColumn(i));
1542
1543 if (dataViewColumnPtr != NULL)
1544 {
1545 // variable definition and initialization:
1546 wxDataViewCustomRenderer* dataViewCustomRendererPtr(dynamic_cast<wxDataViewCustomRenderer*>(dataViewColumnPtr->GetRenderer()));
1547
1548 if (dataViewCustomRendererPtr != NULL)
1549 dataViewCustomRendererPtr->SetDC(NULL); // reset DC because DC has changed
1550 } /* if */
1551 } /* for */
1552
1553 wxMacDataViewDataBrowserListViewControlPointer MacDataViewListCtrlPtr(dynamic_cast<wxMacDataViewDataBrowserListViewControlPointer>(this->m_peer));
1554 ControlRef ref = MacDataViewListCtrlPtr->GetControlRef();
1555 if (NoOfColumns == 1)
1556 {
1557 ::SetDataBrowserHasScrollBars( ref, false, true );
1558 ::AutoSizeDataBrowserListViewColumns( ref );
1559 }
1560 if (NoOfColumns > 1)
1561 {
1562 ::SetDataBrowserHasScrollBars( ref, true, true );
1563 }
1564
1565 event.Skip();
1566 } /* wxDataViewCtrl::OnSize(wxSizeEvent&) */
1567
1568 IMPLEMENT_DYNAMIC_CLASS(wxDataViewCtrl,wxDataViewCtrlBase)
1569
1570 BEGIN_EVENT_TABLE(wxDataViewCtrl,wxDataViewCtrlBase)
1571 EVT_SIZE(wxDataViewCtrl::OnSize)
1572 END_EVENT_TABLE()
1573
1574 #endif
1575 // !wxUSE_GENERICDATAVIEWCTRL
1576
1577 #endif
1578 // wxUSE_DATAVIEWCTRL
1579