]> git.saurik.com Git - wxWidgets.git/blob - src/mac/carbon/utils.cpp
removing the old style code cases
[wxWidgets.git] / src / mac / carbon / utils.cpp
1 /////////////////////////////////////////////////////////////////////////////
2 // Name: src/mac/carbon/utils.cpp
3 // Purpose: Various utilities
4 // Author: Stefan Csomor
5 // Modified by:
6 // Created: 1998-01-01
7 // RCS-ID: $Id$
8 // Copyright: (c) Stefan Csomor
9 // Licence: wxWindows licence
10 /////////////////////////////////////////////////////////////////////////////
11
12 #include "wx/wxprec.h"
13
14 #include "wx/utils.h"
15
16 #ifndef WX_PRECOMP
17 #include "wx/intl.h"
18 #include "wx/app.h"
19 #if wxUSE_GUI
20 #include "wx/toplevel.h"
21 #include "wx/font.h"
22 #endif
23 #endif
24
25 #include "wx/apptrait.h"
26
27 #if wxUSE_GUI
28 #include "wx/mac/uma.h"
29 #endif
30
31 #include <ctype.h>
32
33 #include <stdio.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <stdarg.h>
37
38 #include "MoreFilesX.h"
39
40 #ifndef __DARWIN__
41 #include <Threads.h>
42 #include <Sound.h>
43 #endif
44
45 #if wxUSE_GUI
46 #if TARGET_API_MAC_OSX
47 #include <CoreServices/CoreServices.h>
48 #else
49 #include <DriverServices.h>
50 #include <Multiprocessing.h>
51 #endif
52
53 #ifdef __DARWIN__
54 #include <Carbon/Carbon.h>
55 #else
56 #include <ATSUnicode.h>
57 #include <TextCommon.h>
58 #include <TextEncodingConverter.h>
59 #endif
60 #endif // wxUSE_GUI
61
62 #include "wx/mac/private.h"
63
64 #if defined(__MWERKS__) && wxUSE_UNICODE
65 #if __MWERKS__ < 0x4100 || !defined(__DARWIN__)
66 #include <wtime.h>
67 #endif
68 #endif
69
70 #if wxUSE_BASE
71
72 // our OS version is the same in non GUI and GUI cases
73 wxOperatingSystemId wxGetOsVersion(int *majorVsn, int *minorVsn)
74 {
75 long theSystem;
76 Gestalt(gestaltSystemVersion, &theSystem);
77
78 if ( majorVsn != NULL )
79 *majorVsn = (theSystem >> 8);
80
81 if ( minorVsn != NULL )
82 *minorVsn = (theSystem & 0xFF);
83
84 #if defined( __DARWIN__ )
85 return wxOS_MAC_OSX_DARWIN;
86 #else
87 return wxOS_MAC_OS;
88 #endif
89 }
90
91 // ----------------------------------------------------------------------------
92 // debugging support
93 // ----------------------------------------------------------------------------
94
95 #if defined(__WXDEBUG__) && defined(__WXMAC__) && !defined(__DARWIN__) && defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
96
97 // MetroNub stuff doesn't seem to work in CodeWarrior 5.3 Carbon builds...
98
99 #ifndef __MetroNubUtils__
100 #include "MetroNubUtils.h"
101 #endif
102
103 #ifndef __GESTALT__
104 #include <Gestalt.h>
105 #endif
106
107 #if TARGET_API_MAC_CARBON
108
109 #include <CodeFragments.h>
110
111 extern "C" long CallUniversalProc(UniversalProcPtr theProcPtr, ProcInfoType procInfo, ...);
112
113 ProcPtr gCallUniversalProc_Proc = NULL;
114
115 #endif
116
117 static MetroNubUserEntryBlock* gMetroNubEntry = NULL;
118
119 static long fRunOnce = false;
120
121
122 Boolean IsMetroNubInstalled()
123 {
124 if (!fRunOnce)
125 {
126 long result, value;
127
128 fRunOnce = true;
129 gMetroNubEntry = NULL;
130
131 if (Gestalt(gestaltSystemVersion, &value) == noErr && value < 0x1000)
132 {
133 // look for MetroNub's Gestalt selector
134 if (Gestalt(kMetroNubUserSignature, &result) == noErr)
135 {
136 #if TARGET_API_MAC_CARBON
137 if (gCallUniversalProc_Proc == NULL)
138 {
139 CFragConnectionID connectionID;
140 Ptr mainAddress;
141 Str255 errorString;
142 ProcPtr symbolAddress;
143 OSErr err;
144 CFragSymbolClass symbolClass;
145
146 symbolAddress = NULL;
147 err = GetSharedLibrary("\pInterfaceLib", kPowerPCCFragArch, kFindCFrag,
148 &connectionID, &mainAddress, errorString);
149
150 if (err != noErr)
151 {
152 gCallUniversalProc_Proc = NULL;
153 goto end;
154 }
155
156 err = FindSymbol(connectionID, "\pCallUniversalProc",
157 (Ptr *) &gCallUniversalProc_Proc, &symbolClass);
158
159 if (err != noErr)
160 {
161 gCallUniversalProc_Proc = NULL;
162 goto end;
163 }
164 }
165 #endif
166
167 {
168 MetroNubUserEntryBlock* block = (MetroNubUserEntryBlock *)result;
169
170 // make sure the version of the API is compatible
171 if (block->apiLowVersion <= kMetroNubUserAPIVersion &&
172 kMetroNubUserAPIVersion <= block->apiHiVersion)
173 {
174 // success!
175 gMetroNubEntry = block;
176 }
177 }
178 }
179 }
180 }
181
182 end:
183
184 #if TARGET_API_MAC_CARBON
185 return (gMetroNubEntry != NULL && gCallUniversalProc_Proc != NULL);
186 #else
187 return (gMetroNubEntry != NULL);
188 #endif
189 }
190
191 Boolean IsMWDebuggerRunning()
192 {
193 if (IsMetroNubInstalled())
194 return CallIsDebuggerRunningProc(gMetroNubEntry->isDebuggerRunning);
195
196 return false;
197 }
198
199 Boolean AmIBeingMWDebugged()
200 {
201 if (IsMetroNubInstalled())
202 return CallAmIBeingDebuggedProc(gMetroNubEntry->amIBeingDebugged);
203
204 return false;
205 }
206
207 extern bool WXDLLEXPORT wxIsDebuggerRunning()
208 {
209 return IsMWDebuggerRunning() && AmIBeingMWDebugged();
210 }
211
212 #else
213
214 extern bool WXDLLEXPORT wxIsDebuggerRunning()
215 {
216 return false;
217 }
218
219 #endif // defined(__WXMAC__) && !defined(__DARWIN__) && (__MWERKS__ >= 0x2400)
220
221
222 #ifndef __DARWIN__
223 // defined in unix/utilsunx.cpp for Mac OS X
224
225 // get full hostname (with domain name if possible)
226 bool wxGetFullHostName(wxChar *buf, int maxSize)
227 {
228 return wxGetHostName(buf, maxSize);
229 }
230
231 // Get user ID e.g. jacs
232 bool wxGetUserId(wxChar *buf, int maxSize)
233 {
234 return wxGetUserName( buf , maxSize );
235 }
236
237 const wxChar* wxGetHomeDir(wxString *pstr)
238 {
239 *pstr = wxMacFindFolder( (short) kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder );
240 return pstr->c_str();
241 }
242
243 // Get hostname only (without domain name)
244 bool wxGetHostName(wxChar *buf, int maxSize)
245 {
246 // Gets Chooser name of user by examining a System resource.
247 buf[0] = 0;
248
249 const short kComputerNameID = -16413;
250
251 short oldResFile = CurResFile();
252 UseResFile(0);
253 StringHandle chooserName = (StringHandle)::GetString(kComputerNameID);
254 UseResFile(oldResFile);
255
256 if (chooserName && *chooserName)
257 {
258 HLock( (Handle) chooserName );
259 wxString name = wxMacMakeStringFromPascal( *chooserName );
260 HUnlock( (Handle) chooserName );
261 ReleaseResource( (Handle) chooserName );
262 wxStrncpy( buf , name , maxSize - 1 );
263 }
264
265 return true;
266 }
267
268 // Get user name e.g. Stefan Csomor
269 bool wxGetUserName(wxChar *buf, int maxSize)
270 {
271 // Gets Chooser name of user by examining a System resource.
272 buf[0] = 0;
273
274 const short kChooserNameID = -16096;
275
276 short oldResFile = CurResFile();
277 UseResFile(0);
278 StringHandle chooserName = (StringHandle)::GetString(kChooserNameID);
279 UseResFile(oldResFile);
280
281 if (chooserName && *chooserName)
282 {
283 HLock( (Handle) chooserName );
284 wxString name = wxMacMakeStringFromPascal( *chooserName );
285 HUnlock( (Handle) chooserName );
286 ReleaseResource( (Handle) chooserName );
287 wxStrncpy( buf , name , maxSize - 1 );
288 }
289
290 return true;
291 }
292
293 int wxKill(long pid, wxSignal sig , wxKillError *rc, int flags)
294 {
295 // TODO
296 return 0;
297 }
298
299 WXDLLEXPORT bool wxGetEnv(const wxString& var, wxString *value)
300 {
301 // TODO : under classic there is no environement support, under X yes
302 return false;
303 }
304
305 // set the env var name to the given value, return true on success
306 WXDLLEXPORT bool wxSetEnv(const wxString& var, const wxChar *value)
307 {
308 // TODO : under classic there is no environement support, under X yes
309 return false;
310 }
311
312 // Execute a program in an Interactive Shell
313 bool wxShell(const wxString& command)
314 {
315 // TODO
316 return false;
317 }
318
319 // Shutdown or reboot the PC
320 bool wxShutdown(wxShutdownFlags wFlags)
321 {
322 // TODO
323 return false;
324 }
325
326 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
327 wxMemorySize wxGetFreeMemory()
328 {
329 return (wxMemorySize)FreeMem();
330 }
331
332 #ifndef __DARWIN__
333
334 void wxMicroSleep(unsigned long microseconds)
335 {
336 AbsoluteTime wakeup = AddDurationToAbsolute( microseconds * durationMicrosecond , UpTime());
337 MPDelayUntil( & wakeup);
338 }
339
340 void wxMilliSleep(unsigned long milliseconds)
341 {
342 AbsoluteTime wakeup = AddDurationToAbsolute( milliseconds, UpTime());
343 MPDelayUntil( & wakeup);
344 }
345
346 void wxSleep(int nSecs)
347 {
348 wxMilliSleep(1000*nSecs);
349 }
350
351 #endif
352
353 // Consume all events until no more left
354 void wxFlushEvents()
355 {
356 }
357
358 #endif // !__DARWIN__
359
360 // Emit a beeeeeep
361 void wxBell()
362 {
363 SysBeep(30);
364 }
365
366
367 #endif // wxUSE_BASE
368
369 #if wxUSE_GUI
370
371 wxPortId wxGUIAppTraits::GetToolkitVersion(int *verMaj, int *verMin) const
372 {
373 // We suppose that toolkit version is the same as OS version under Mac
374 wxGetOsVersion(verMaj, verMin);
375
376 return wxPORT_MAC;
377 }
378
379 // Reading and writing resources (eg WIN.INI, .Xdefaults)
380 #if wxUSE_RESOURCES
381 bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
382 {
383 // TODO
384 return false;
385 }
386
387 bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
388 {
389 wxString buf;
390 buf.Printf(wxT("%.4f"), value);
391
392 return wxWriteResource(section, entry, buf, file);
393 }
394
395 bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
396 {
397 wxString buf;
398 buf.Printf(wxT("%ld"), value);
399
400 return wxWriteResource(section, entry, buf, file);
401 }
402
403 bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
404 {
405 wxString buf;
406 buf.Printf(wxT("%d"), value);
407
408 return wxWriteResource(section, entry, buf, file);
409 }
410
411 bool wxGetResource(const wxString& section, const wxString& entry, char **value, const wxString& file)
412 {
413 // TODO
414 return false;
415 }
416
417 bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file)
418 {
419 char *s = NULL;
420 bool succ = wxGetResource(section, entry, (char **)&s, file);
421 if (succ)
422 {
423 *value = (float)strtod(s, NULL);
424 delete[] s;
425 }
426
427 return succ;
428 }
429
430 bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file)
431 {
432 char *s = NULL;
433 bool succ = wxGetResource(section, entry, (char **)&s, file);
434 if (succ)
435 {
436 *value = strtol(s, NULL, 10);
437 delete[] s;
438 }
439
440 return succ;
441 }
442
443 bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
444 {
445 char *s = NULL;
446 bool succ = wxGetResource(section, entry, (char **)&s, file);
447 if (succ)
448 {
449 *value = (int)strtol(s, NULL, 10);
450 delete[] s;
451 }
452
453 return succ;
454 }
455 #endif // wxUSE_RESOURCES
456
457 int gs_wxBusyCursorCount = 0;
458 extern wxCursor gMacCurrentCursor;
459 wxCursor gMacStoredActiveCursor;
460
461 // Set the cursor to the busy cursor for all windows
462 void wxBeginBusyCursor(const wxCursor *cursor)
463 {
464 if (gs_wxBusyCursorCount++ == 0)
465 {
466 gMacStoredActiveCursor = gMacCurrentCursor;
467 cursor->MacInstall();
468 }
469 //else: nothing to do, already set
470 }
471
472 // Restore cursor to normal
473 void wxEndBusyCursor()
474 {
475 wxCHECK_RET( gs_wxBusyCursorCount > 0,
476 wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );
477
478 if (--gs_wxBusyCursorCount == 0)
479 {
480 gMacStoredActiveCursor.MacInstall();
481 gMacStoredActiveCursor = wxNullCursor;
482 }
483 }
484
485 // true if we're between the above two calls
486 bool wxIsBusy()
487 {
488 return (gs_wxBusyCursorCount > 0);
489 }
490
491 #endif // wxUSE_GUI
492
493 #if wxUSE_BASE
494
495 wxString wxMacFindFolderNoSeparator( short vol,
496 OSType folderType,
497 Boolean createFolder)
498 {
499 FSRef fsRef;
500 wxString strDir;
501
502 if ( FSFindFolder( vol, folderType, createFolder, &fsRef) == noErr)
503 {
504 strDir = wxMacFSRefToPath( &fsRef );
505 }
506
507 return strDir;
508 }
509
510 wxString wxMacFindFolder( short vol,
511 OSType folderType,
512 Boolean createFolder)
513 {
514 return wxMacFindFolderNoSeparator(vol, folderType, createFolder) + wxFILE_SEP_PATH;
515 }
516
517 #endif // wxUSE_BASE
518
519 #if wxUSE_GUI
520
521 // Check whether this window wants to process messages, e.g. Stop button
522 // in long calculations.
523 bool wxCheckForInterrupt(wxWindow *wnd)
524 {
525 // TODO
526 return false;
527 }
528
529 void wxGetMousePosition( int* x, int* y )
530 {
531 Point pt;
532
533 GetMouse( &pt );
534 LocalToGlobal( &pt );
535 *x = pt.h;
536 *y = pt.v;
537 };
538
539 // Return true if we have a colour display
540 bool wxColourDisplay()
541 {
542 return true;
543 }
544
545 // Returns depth of screen
546 int wxDisplayDepth()
547 {
548 Rect globRect;
549 SetRect(&globRect, -32760, -32760, 32760, 32760);
550 GDHandle theMaxDevice;
551
552 int theDepth = 8;
553 theMaxDevice = GetMaxDevice(&globRect);
554 if (theMaxDevice != NULL)
555 theDepth = (**(**theMaxDevice).gdPMap).pixelSize;
556
557 return theDepth;
558 }
559
560 // Get size of display
561 void wxDisplaySize(int *width, int *height)
562 {
563 BitMap screenBits;
564 GetQDGlobalsScreenBits( &screenBits );
565
566 if (width != NULL)
567 *width = screenBits.bounds.right - screenBits.bounds.left;
568
569 if (height != NULL)
570 *height = screenBits.bounds.bottom - screenBits.bounds.top;
571 }
572
573 void wxDisplaySizeMM(int *width, int *height)
574 {
575 wxDisplaySize(width, height);
576 // on mac 72 is fixed (at least now;-)
577 float cvPt2Mm = 25.4 / 72;
578
579 if (width != NULL)
580 *width = int( *width * cvPt2Mm );
581
582 if (height != NULL)
583 *height = int( *height * cvPt2Mm );
584 }
585
586 void wxClientDisplayRect(int *x, int *y, int *width, int *height)
587 {
588 Rect r;
589
590 GetAvailableWindowPositioningBounds( GetMainDevice() , &r );
591 if ( x )
592 *x = r.left;
593 if ( y )
594 *y = r.top;
595 if ( width )
596 *width = r.right - r.left;
597 if ( height )
598 *height = r.bottom - r.top;
599 }
600
601 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
602 {
603 return wxGenericFindWindowAtPoint(pt);
604 }
605
606 #endif // wxUSE_GUI
607
608 #if wxUSE_BASE
609
610 wxString wxGetOsDescription()
611 {
612 #ifdef WXWIN_OS_DESCRIPTION
613 // use configure generated description if available
614 return wxString(wxT("MacOS (")) + wxT(WXWIN_OS_DESCRIPTION) + wxString(wxT(")"));
615 #else
616 return wxT("MacOS"); //TODO:define further
617 #endif
618 }
619
620 #ifndef __DARWIN__
621 wxChar *wxGetUserHome (const wxString& user)
622 {
623 // TODO
624 return NULL;
625 }
626
627 bool wxGetDiskSpace(const wxString& path, wxDiskspaceSize_t *pTotal, wxDiskspaceSize_t *pFree)
628 {
629 if ( path.empty() )
630 return false;
631
632 wxString p = path;
633 if (p[0u] == ':' )
634 p = wxGetCwd() + p;
635
636 int pos = p.Find(':');
637 if ( pos != wxNOT_FOUND )
638 p = p.Mid(1,pos);
639
640 p = p + wxT(":");
641
642 OSErr err = noErr;
643
644 FSRef fsRef;
645 err = wxMacPathToFSRef( p , &fsRef );
646 if ( noErr == err )
647 {
648 FSVolumeRefNum vRefNum;
649 err = FSGetVRefNum( &fsRef , &vRefNum );
650 if ( noErr == err )
651 {
652 UInt64 freeBytes , totalBytes;
653 err = FSGetVInfo( vRefNum , NULL , &freeBytes , &totalBytes );
654 if ( noErr == err )
655 {
656 if ( pTotal )
657 *pTotal = wxDiskspaceSize_t( totalBytes );
658 if ( pFree )
659 *pFree = wxDiskspaceSize_t( freeBytes );
660 }
661 }
662 }
663
664 return err == noErr;
665 }
666 #endif // !__DARWIN__
667
668 //---------------------------------------------------------------------------
669 // wxMac Specific utility functions
670 //---------------------------------------------------------------------------
671
672 void wxMacStringToPascal( const wxString&from , StringPtr to )
673 {
674 wxCharBuffer buf = from.mb_str( wxConvLocal );
675 int len = strlen(buf);
676
677 if ( len > 255 )
678 len = 255;
679 to[0] = len;
680 memcpy( (char*) &to[1] , buf , len );
681 }
682
683 wxString wxMacMakeStringFromPascal( ConstStringPtr from )
684 {
685 return wxString( (char*) &from[1] , wxConvLocal , from[0] );
686 }
687
688 // ----------------------------------------------------------------------------
689 // Common Event Support
690 // ----------------------------------------------------------------------------
691
692 extern ProcessSerialNumber gAppProcess;
693
694 void wxMacWakeUp()
695 {
696 ProcessSerialNumber psn;
697 Boolean isSame;
698 psn.highLongOfPSN = 0;
699 psn.lowLongOfPSN = kCurrentProcess;
700 SameProcess( &gAppProcess , &psn , &isSame );
701 if ( isSame )
702 {
703 #if TARGET_CARBON
704 OSStatus err = noErr;
705
706 #if 0
707 // lead sometimes to race conditions, although all calls used should be thread safe ...
708 static wxMacCarbonEvent s_wakeupEvent;
709 if ( !s_wakeupEvent.IsValid() )
710 {
711 err = s_wakeupEvent.Create( 'WXMC', 'WXMC', GetCurrentEventTime(),
712 kEventAttributeNone );
713 }
714 if ( err == noErr )
715 {
716
717 if ( IsEventInQueue( GetMainEventQueue() , s_wakeupEvent ) )
718 return;
719 s_wakeupEvent.SetCurrentTime();
720 err = PostEventToQueue(GetMainEventQueue(), s_wakeupEvent,
721 kEventPriorityHigh );
722 }
723 #else
724 wxMacCarbonEvent wakeupEvent;
725 wakeupEvent.Create( 'WXMC', 'WXMC', GetCurrentEventTime(),
726 kEventAttributeNone );
727 err = PostEventToQueue(GetMainEventQueue(), wakeupEvent,
728 kEventPriorityHigh );
729 #endif
730 #else
731 PostEvent( nullEvent , 0 );
732 #endif
733 }
734 else
735 {
736 WakeUpProcess( &gAppProcess );
737 }
738 }
739
740 #endif // wxUSE_BASE
741
742 #if wxUSE_GUI
743
744 // ----------------------------------------------------------------------------
745 // Native Struct Conversions
746 // ----------------------------------------------------------------------------
747
748 void wxMacRectToNative( const wxRect *wx , Rect *n )
749 {
750 n->left = wx->x;
751 n->top = wx->y;
752 n->right = wx->x + wx->width;
753 n->bottom = wx->y + wx->height;
754 }
755
756 void wxMacNativeToRect( const Rect *n , wxRect* wx )
757 {
758 wx->x = n->left;
759 wx->y = n->top;
760 wx->width = n->right - n->left;
761 wx->height = n->bottom - n->top;
762 }
763
764 void wxMacPointToNative( const wxPoint* wx , Point *n )
765 {
766 n->h = wx->x;
767 n->v = wx->y;
768 }
769
770 void wxMacNativeToPoint( const Point *n , wxPoint* wx )
771 {
772 wx->x = n->h;
773 wx->y = n->v;
774 }
775
776 // ----------------------------------------------------------------------------
777 // Carbon Event Support
778 // ----------------------------------------------------------------------------
779
780 OSStatus wxMacCarbonEvent::GetParameter(EventParamName inName, EventParamType inDesiredType, UInt32 inBufferSize, void * outData)
781 {
782 return ::GetEventParameter( m_eventRef , inName , inDesiredType , NULL , inBufferSize , NULL , outData );
783 }
784
785 OSStatus wxMacCarbonEvent::SetParameter(EventParamName inName, EventParamType inType, UInt32 inBufferSize, const void * inData)
786 {
787 return ::SetEventParameter( m_eventRef , inName , inType , inBufferSize , inData );
788 }
789
790 // ----------------------------------------------------------------------------
791 // Control Access Support
792 // ----------------------------------------------------------------------------
793
794 wxMacControl::wxMacControl(wxWindow* peer , bool isRootControl )
795 {
796 Init();
797 m_peer = peer;
798 m_isRootControl = isRootControl;
799 }
800
801 wxMacControl::wxMacControl( wxWindow* peer , ControlRef control )
802 {
803 Init();
804 m_peer = peer;
805 m_controlRef = control;
806 }
807
808 wxMacControl::wxMacControl( wxWindow* peer , WXWidget control )
809 {
810 Init();
811 m_peer = peer;
812 m_controlRef = (ControlRef) control;
813 }
814
815 wxMacControl::~wxMacControl()
816 {
817 }
818
819 void wxMacControl::Init()
820 {
821 m_peer = NULL;
822 m_controlRef = NULL;
823 m_needsFocusRect = false;
824 m_isRootControl = false;
825 }
826
827 void wxMacControl::Dispose()
828 {
829 wxASSERT_MSG( IsValidControlHandle(m_controlRef) , wxT("Invalid Control Handle (maybe already released) in Dispose") );
830
831 CFIndex count = CFGetRetainCount( m_controlRef ) ;
832 wxASSERT_MSG( count == 1 , wxT("Reference Count of native control was not 1 in Dispose") );
833
834 ::DisposeControl( m_controlRef );
835 m_controlRef = NULL;
836 }
837
838 void wxMacControl::SetReference( SInt32 data )
839 {
840 SetControlReference( m_controlRef , data );
841 }
842
843 OSStatus wxMacControl::GetData(ControlPartCode inPartCode , ResType inTag , Size inBufferSize , void * inOutBuffer , Size * outActualSize ) const
844 {
845 return ::GetControlData( m_controlRef , inPartCode , inTag , inBufferSize , inOutBuffer , outActualSize );
846 }
847
848 OSStatus wxMacControl::GetDataSize(ControlPartCode inPartCode , ResType inTag , Size * outActualSize ) const
849 {
850 return ::GetControlDataSize( m_controlRef , inPartCode , inTag , outActualSize );
851 }
852
853 OSStatus wxMacControl::SetData(ControlPartCode inPartCode , ResType inTag , Size inSize , const void * inData)
854 {
855 return ::SetControlData( m_controlRef , inPartCode , inTag , inSize , inData );
856 }
857
858 OSStatus wxMacControl::SendEvent( EventRef event , OptionBits inOptions )
859 {
860 #if TARGET_API_MAC_OSX
861 return SendEventToEventTargetWithOptions( event,
862 HIObjectGetEventTarget( (HIObjectRef) m_controlRef ), inOptions );
863 #else
864 #pragma unused(inOptions)
865 return SendEventToEventTarget(event,GetControlEventTarget( m_controlRef ) );
866 #endif
867 }
868
869 OSStatus wxMacControl::SendHICommand( HICommand &command , OptionBits inOptions )
870 {
871 wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess );
872
873 event.SetParameter<HICommand>(kEventParamDirectObject,command);
874
875 return SendEvent( event , inOptions );
876 }
877
878 OSStatus wxMacControl::SendHICommand( UInt32 commandID , OptionBits inOptions )
879 {
880 HICommand command;
881
882 memset( &command, 0 , sizeof(command) );
883 command.commandID = commandID;
884 return SendHICommand( command , inOptions );
885 }
886
887 void wxMacControl::Flash( ControlPartCode part , UInt32 ticks )
888 {
889 unsigned long finalTicks;
890
891 HiliteControl( m_controlRef , part );
892 Delay( ticks , &finalTicks );
893 HiliteControl( m_controlRef , kControlNoPart );
894 }
895
896 SInt32 wxMacControl::GetValue() const
897 {
898 return ::GetControl32BitValue( m_controlRef );
899 }
900
901 SInt32 wxMacControl::GetMaximum() const
902 {
903 return ::GetControl32BitMaximum( m_controlRef );
904 }
905
906 SInt32 wxMacControl::GetMinimum() const
907 {
908 return ::GetControl32BitMinimum( m_controlRef );
909 }
910
911 void wxMacControl::SetValue( SInt32 v )
912 {
913 ::SetControl32BitValue( m_controlRef , v );
914 }
915
916 void wxMacControl::SetMinimum( SInt32 v )
917 {
918 ::SetControl32BitMinimum( m_controlRef , v );
919 }
920
921 void wxMacControl::SetMaximum( SInt32 v )
922 {
923 ::SetControl32BitMaximum( m_controlRef , v );
924 }
925
926 void wxMacControl::SetValueAndRange( SInt32 value , SInt32 minimum , SInt32 maximum )
927 {
928 ::SetControl32BitMinimum( m_controlRef , minimum );
929 ::SetControl32BitMaximum( m_controlRef , maximum );
930 ::SetControl32BitValue( m_controlRef , value );
931 }
932
933 OSStatus wxMacControl::SetFocus( ControlFocusPart focusPart )
934 {
935 return SetKeyboardFocus( GetControlOwner( m_controlRef ), m_controlRef, focusPart );
936 }
937
938 bool wxMacControl::HasFocus() const
939 {
940 ControlRef control;
941 GetKeyboardFocus( GetUserFocusWindow() , &control );
942 return control == m_controlRef;
943 }
944
945 void wxMacControl::SetNeedsFocusRect( bool needs )
946 {
947 m_needsFocusRect = needs;
948 }
949
950 bool wxMacControl::NeedsFocusRect() const
951 {
952 return m_needsFocusRect;
953 }
954
955 void wxMacControl::VisibilityChanged(bool shown)
956 {
957 }
958
959 void wxMacControl::SuperChangedPosition()
960 {
961 }
962
963 void wxMacControl::SetFont( const wxFont & font , const wxColour& foreground , long windowStyle )
964 {
965 m_font = font;
966 ControlFontStyleRec fontStyle;
967 if ( font.MacGetThemeFontID() != kThemeCurrentPortFont )
968 {
969 switch ( font.MacGetThemeFontID() )
970 {
971 case kThemeSmallSystemFont :
972 fontStyle.font = kControlFontSmallSystemFont;
973 break;
974
975 case 109 : // mini font
976 fontStyle.font = -5;
977 break;
978
979 case kThemeSystemFont :
980 fontStyle.font = kControlFontBigSystemFont;
981 break;
982
983 default :
984 fontStyle.font = kControlFontBigSystemFont;
985 break;
986 }
987
988 fontStyle.flags = kControlUseFontMask;
989 }
990 else
991 {
992 fontStyle.font = font.MacGetFontNum();
993 fontStyle.style = font.MacGetFontStyle();
994 fontStyle.size = font.MacGetFontSize();
995 fontStyle.flags = kControlUseFontMask | kControlUseFaceMask | kControlUseSizeMask;
996 }
997
998 fontStyle.just = teJustLeft;
999 fontStyle.flags |= kControlUseJustMask;
1000 if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_CENTER_HORIZONTAL )
1001 fontStyle.just = teJustCenter;
1002 else if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_RIGHT )
1003 fontStyle.just = teJustRight;
1004
1005
1006 // we only should do this in case of a non-standard color, as otherwise 'disabled' controls
1007 // won't get grayed out by the system anymore
1008
1009 if ( foreground != *wxBLACK )
1010 {
1011 fontStyle.foreColor = MAC_WXCOLORREF( foreground.GetPixel() );
1012 fontStyle.flags |= kControlUseForeColorMask;
1013 }
1014
1015 ::SetControlFontStyle( m_controlRef , &fontStyle );
1016 }
1017
1018 void wxMacControl::SetBackground( const wxBrush &WXUNUSED(brush) )
1019 {
1020 // TODO
1021 // setting up a color proc is not recommended anymore
1022 }
1023
1024 void wxMacControl::SetRange( SInt32 minimum , SInt32 maximum )
1025 {
1026 ::SetControl32BitMinimum( m_controlRef , minimum );
1027 ::SetControl32BitMaximum( m_controlRef , maximum );
1028 }
1029
1030 short wxMacControl::HandleKey( SInt16 keyCode, SInt16 charCode, EventModifiers modifiers )
1031 {
1032 return HandleControlKey( m_controlRef , keyCode , charCode , modifiers );
1033 }
1034
1035 void wxMacControl::SetActionProc( ControlActionUPP actionProc )
1036 {
1037 SetControlAction( m_controlRef , actionProc );
1038 }
1039
1040 void wxMacControl::SetViewSize( SInt32 viewSize )
1041 {
1042 SetControlViewSize(m_controlRef , viewSize );
1043 }
1044
1045 SInt32 wxMacControl::GetViewSize() const
1046 {
1047 return GetControlViewSize( m_controlRef );
1048 }
1049
1050 bool wxMacControl::IsVisible() const
1051 {
1052 return IsControlVisible( m_controlRef );
1053 }
1054
1055 void wxMacControl::SetVisibility( bool visible , bool redraw )
1056 {
1057 SetControlVisibility( m_controlRef , visible , redraw );
1058 }
1059
1060 bool wxMacControl::IsEnabled() const
1061 {
1062 #if TARGET_API_MAC_OSX
1063 return IsControlEnabled( m_controlRef );
1064 #else
1065 return IsControlActive( m_controlRef );
1066 #endif
1067 }
1068
1069 bool wxMacControl::IsActive() const
1070 {
1071 return IsControlActive( m_controlRef );
1072 }
1073
1074 void wxMacControl::Enable( bool enable )
1075 {
1076 if ( enable )
1077 EnableControl( m_controlRef );
1078 else
1079 DisableControl( m_controlRef );
1080 }
1081
1082 void wxMacControl::SetDrawingEnabled( bool enable )
1083 {
1084 HIViewSetDrawingEnabled( m_controlRef , enable );
1085 }
1086
1087 bool wxMacControl::GetNeedsDisplay() const
1088 {
1089 return HIViewGetNeedsDisplay( m_controlRef );
1090 }
1091
1092 void wxMacControl::SetNeedsDisplay( RgnHandle where )
1093 {
1094 if ( !IsVisible() )
1095 return;
1096
1097 HIViewSetNeedsDisplayInRegion( m_controlRef , where , true );
1098 }
1099
1100 void wxMacControl::SetNeedsDisplay( Rect* where )
1101 {
1102 if ( !IsVisible() )
1103 return;
1104
1105 if ( where != NULL )
1106 {
1107 RgnHandle update = NewRgn();
1108 RectRgn( update , where );
1109 HIViewSetNeedsDisplayInRegion( m_controlRef , update , true );
1110 DisposeRgn( update );
1111 }
1112 else
1113 HIViewSetNeedsDisplay( m_controlRef , true );
1114 }
1115
1116 void wxMacControl::Convert( wxPoint *pt , wxMacControl *from , wxMacControl *to )
1117 {
1118 HIPoint hiPoint;
1119
1120 hiPoint.x = pt->x;
1121 hiPoint.y = pt->y;
1122 HIViewConvertPoint( &hiPoint , from->m_controlRef , to->m_controlRef );
1123 pt->x = (int)hiPoint.x;
1124 pt->y = (int)hiPoint.y;
1125 }
1126
1127 void wxMacControl::SetRect( Rect *r )
1128 {
1129 //A HIRect is actually a CGRect on OSX - which consists of two structures -
1130 //CGPoint and CGSize, which have two floats each
1131 HIRect hir = { { r->left , r->top }, { r->right - r->left , r->bottom - r->top } };
1132 HIViewSetFrame ( m_controlRef , &hir );
1133 // eventuall we might have to do a SetVisibility( false , true );
1134 // before and a SetVisibility( true , true ); after
1135 }
1136
1137 void wxMacControl::GetRect( Rect *r )
1138 {
1139 GetControlBounds( m_controlRef , r );
1140 }
1141
1142 void wxMacControl::GetRectInWindowCoords( Rect *r )
1143 {
1144 UMAGetControlBoundsInWindowCoords( m_controlRef , r );
1145 }
1146
1147 void wxMacControl::GetBestRect( Rect *r )
1148 {
1149 short baselineoffset;
1150
1151 GetBestControlRect( m_controlRef , r , &baselineoffset );
1152 }
1153
1154 void wxMacControl::SetLabel( const wxString &title )
1155 {
1156 wxFontEncoding encoding;
1157
1158 if ( m_font.Ok() )
1159 encoding = m_font.GetEncoding();
1160 else
1161 encoding = wxFont::GetDefaultEncoding();
1162
1163 UMASetControlTitle( m_controlRef , title , encoding );
1164 }
1165
1166 void wxMacControl::GetFeatures( UInt32 * features )
1167 {
1168 GetControlFeatures( m_controlRef , features );
1169 }
1170
1171 OSStatus wxMacControl::GetRegion( ControlPartCode partCode , RgnHandle region )
1172 {
1173 OSStatus err = GetControlRegion( m_controlRef , partCode , region );
1174 return err;
1175 }
1176
1177 OSStatus wxMacControl::SetZOrder( bool above , wxMacControl* other )
1178 {
1179 #if TARGET_API_MAC_OSX
1180 return HIViewSetZOrder( m_controlRef,above ? kHIViewZOrderAbove : kHIViewZOrderBelow,
1181 (other != NULL) ? other->m_controlRef : NULL);
1182 #else
1183 return 0;
1184 #endif
1185 }
1186
1187 #if TARGET_API_MAC_OSX
1188 // SetNeedsDisplay would not invalidate the children
1189 static void InvalidateControlAndChildren( HIViewRef control )
1190 {
1191 HIViewSetNeedsDisplay( control , true );
1192 UInt16 childrenCount = 0;
1193 OSStatus err = CountSubControls( control , &childrenCount );
1194 if ( err == errControlIsNotEmbedder )
1195 return;
1196
1197 wxASSERT_MSG( err == noErr , wxT("Unexpected error when accessing subcontrols") );
1198
1199 for ( UInt16 i = childrenCount; i >=1; --i )
1200 {
1201 HIViewRef child;
1202
1203 err = GetIndexedSubControl( control , i , & child );
1204 if ( err == errControlIsNotEmbedder )
1205 return;
1206
1207 InvalidateControlAndChildren( child );
1208 }
1209 }
1210 #endif
1211
1212 void wxMacControl::InvalidateWithChildren()
1213 {
1214 #if TARGET_API_MAC_OSX
1215 InvalidateControlAndChildren( m_controlRef );
1216 #endif
1217 }
1218
1219 void wxMacControl::ScrollRect( wxRect *r , int dx , int dy )
1220 {
1221 wxASSERT( r != NULL );
1222
1223 HIRect scrollarea = CGRectMake( r->x , r->y , r->width , r->height);
1224 HIViewScrollRect ( m_controlRef , &scrollarea , dx ,dy );
1225 }
1226
1227 OSType wxMacCreator = 'WXMC';
1228 OSType wxMacControlProperty = 'MCCT';
1229
1230 void wxMacControl::SetReferenceInNativeControl()
1231 {
1232 void * data = this;
1233 verify_noerr( SetControlProperty ( m_controlRef ,
1234 wxMacCreator,wxMacControlProperty, sizeof(data), &data ) );
1235 }
1236
1237 wxMacControl* wxMacControl::GetReferenceFromNativeControl(ControlRef control)
1238 {
1239 wxMacControl* ctl = NULL;
1240 UInt32 actualSize;
1241 if ( GetControlProperty( control ,wxMacCreator,wxMacControlProperty, sizeof(ctl) ,
1242 &actualSize , &ctl ) == noErr )
1243 {
1244 return ctl;
1245 }
1246 return NULL;
1247 }
1248
1249 // ============================================================================
1250 // DataBrowser Wrapper
1251 // ============================================================================
1252 //
1253 // basing on DataBrowserItemIDs
1254 //
1255
1256 pascal void wxMacDataBrowserControl::DataBrowserItemNotificationProc(
1257 ControlRef browser,
1258 DataBrowserItemID itemID,
1259 DataBrowserItemNotification message,
1260 DataBrowserItemDataRef itemData )
1261 {
1262 wxMacDataBrowserControl* ctl = dynamic_cast<wxMacDataBrowserControl*>( wxMacControl::GetReferenceFromNativeControl( browser ) );
1263 if ( ctl != 0 )
1264 {
1265 ctl->ItemNotification(itemID, message, itemData);
1266 }
1267 }
1268
1269 pascal OSStatus wxMacDataBrowserControl::DataBrowserGetSetItemDataProc(
1270 ControlRef browser,
1271 DataBrowserItemID itemID,
1272 DataBrowserPropertyID property,
1273 DataBrowserItemDataRef itemData,
1274 Boolean changeValue )
1275 {
1276 OSStatus err = errDataBrowserPropertyNotSupported;
1277 wxMacDataBrowserControl* ctl = dynamic_cast<wxMacDataBrowserControl*>( wxMacControl::GetReferenceFromNativeControl( browser ) );
1278 if ( ctl != 0 )
1279 {
1280 err = ctl->GetSetItemData(itemID, property, itemData, changeValue);
1281 }
1282 return err;
1283 }
1284
1285 pascal Boolean wxMacDataBrowserControl::DataBrowserCompareProc(
1286 ControlRef browser,
1287 DataBrowserItemID itemOneID,
1288 DataBrowserItemID itemTwoID,
1289 DataBrowserPropertyID sortProperty)
1290 {
1291 wxMacDataBrowserControl* ctl = dynamic_cast<wxMacDataBrowserControl*>( wxMacControl::GetReferenceFromNativeControl( browser ) );
1292 if ( ctl != 0 )
1293 {
1294 return ctl->CompareItems(itemOneID, itemTwoID, sortProperty);
1295 }
1296 return false;
1297 }
1298
1299 DataBrowserItemDataUPP gDataBrowserItemDataUPP = NULL;
1300 DataBrowserItemNotificationUPP gDataBrowserItemNotificationUPP = NULL;
1301 DataBrowserItemCompareUPP gDataBrowserItemCompareUPP = NULL;
1302
1303 wxMacDataBrowserControl::wxMacDataBrowserControl( wxWindow* peer, const wxPoint& pos, const wxSize& size, long style) : wxMacControl( peer )
1304 {
1305 Rect bounds = wxMacGetBoundsForControl( peer, pos, size );
1306 OSStatus err = ::CreateDataBrowserControl(
1307 MAC_WXHWND(peer->MacGetTopLevelWindowRef()),
1308 &bounds, kDataBrowserListView, &m_controlRef );
1309 SetReferenceInNativeControl();
1310 verify_noerr( err );
1311 if ( gDataBrowserItemCompareUPP == NULL )
1312 gDataBrowserItemCompareUPP = NewDataBrowserItemCompareUPP(DataBrowserCompareProc);
1313 if ( gDataBrowserItemDataUPP == NULL )
1314 gDataBrowserItemDataUPP = NewDataBrowserItemDataUPP(DataBrowserGetSetItemDataProc);
1315 if ( gDataBrowserItemNotificationUPP == NULL )
1316 {
1317 gDataBrowserItemNotificationUPP =
1318 #if TARGET_API_MAC_OSX
1319 (DataBrowserItemNotificationUPP) NewDataBrowserItemNotificationWithItemUPP(DataBrowserItemNotificationProc);
1320 #else
1321 NewDataBrowserItemNotificationUPP(DataBrowserItemNotificationProc);
1322 #endif
1323 }
1324
1325 DataBrowserCallbacks callbacks;
1326 InitializeDataBrowserCallbacks( &callbacks, kDataBrowserLatestCallbacks );
1327
1328 callbacks.u.v1.itemDataCallback = gDataBrowserItemDataUPP;
1329 callbacks.u.v1.itemCompareCallback = gDataBrowserItemCompareUPP;
1330 callbacks.u.v1.itemNotificationCallback = gDataBrowserItemNotificationUPP;
1331 SetCallbacks( &callbacks );
1332
1333 }
1334
1335 OSStatus wxMacDataBrowserControl::GetItemCount( DataBrowserItemID container,
1336 Boolean recurse,
1337 DataBrowserItemState state,
1338 UInt32 *numItems) const
1339 {
1340 return GetDataBrowserItemCount( m_controlRef, container, recurse, state, numItems );
1341 }
1342
1343 OSStatus wxMacDataBrowserControl::GetItems( DataBrowserItemID container,
1344 Boolean recurse,
1345 DataBrowserItemState state,
1346 Handle items) const
1347 {
1348 return GetDataBrowserItems( m_controlRef, container, recurse, state, items );
1349 }
1350
1351 OSStatus wxMacDataBrowserControl::SetSelectionFlags( DataBrowserSelectionFlags options )
1352 {
1353 return SetDataBrowserSelectionFlags( m_controlRef, options );
1354 }
1355
1356 OSStatus wxMacDataBrowserControl::AddColumn( DataBrowserListViewColumnDesc *columnDesc,
1357 DataBrowserTableViewColumnIndex position )
1358 {
1359 return AddDataBrowserListViewColumn( m_controlRef, columnDesc, position );
1360 }
1361
1362 OSStatus wxMacDataBrowserControl::GetColumnIDFromIndex( DataBrowserTableViewColumnIndex position, DataBrowserTableViewColumnID* id ){
1363 return GetDataBrowserTableViewColumnProperty( m_controlRef, position, id );
1364 }
1365
1366 OSStatus wxMacDataBrowserControl::RemoveColumn( DataBrowserTableViewColumnIndex position )
1367 {
1368 DataBrowserTableViewColumnID id;
1369 GetColumnIDFromIndex( position, &id );
1370 return RemoveDataBrowserTableViewColumn( m_controlRef, id );
1371 }
1372
1373 OSStatus wxMacDataBrowserControl::AutoSizeColumns()
1374 {
1375 return AutoSizeDataBrowserListViewColumns(m_controlRef);
1376 }
1377
1378 OSStatus wxMacDataBrowserControl::SetHasScrollBars( bool horiz, bool vert )
1379 {
1380 return SetDataBrowserHasScrollBars( m_controlRef, horiz, vert );
1381 }
1382
1383 OSStatus wxMacDataBrowserControl::SetHiliteStyle( DataBrowserTableViewHiliteStyle hiliteStyle )
1384 {
1385 return SetDataBrowserTableViewHiliteStyle( m_controlRef, hiliteStyle );
1386 }
1387
1388 OSStatus wxMacDataBrowserControl::SetHeaderButtonHeight(UInt16 height)
1389 {
1390 return SetDataBrowserListViewHeaderBtnHeight( m_controlRef, height );
1391 }
1392
1393 OSStatus wxMacDataBrowserControl::GetHeaderButtonHeight(UInt16 *height)
1394 {
1395 return GetDataBrowserListViewHeaderBtnHeight( m_controlRef, height );
1396 }
1397
1398 OSStatus wxMacDataBrowserControl::SetCallbacks(const DataBrowserCallbacks *callbacks)
1399 {
1400 return SetDataBrowserCallbacks( m_controlRef, callbacks );
1401 }
1402
1403 OSStatus wxMacDataBrowserControl::UpdateItems(
1404 DataBrowserItemID container,
1405 UInt32 numItems,
1406 const DataBrowserItemID *items,
1407 DataBrowserPropertyID preSortProperty,
1408 DataBrowserPropertyID propertyID ) const
1409 {
1410 return UpdateDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty, propertyID );
1411 }
1412
1413 bool wxMacDataBrowserControl::IsItemSelected( DataBrowserItemID item ) const
1414 {
1415 return IsDataBrowserItemSelected( m_controlRef, item );
1416 }
1417
1418 OSStatus wxMacDataBrowserControl::AddItems(
1419 DataBrowserItemID container,
1420 UInt32 numItems,
1421 const DataBrowserItemID *items,
1422 DataBrowserPropertyID preSortProperty )
1423 {
1424 return AddDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty );
1425 }
1426
1427 OSStatus wxMacDataBrowserControl::RemoveItems(
1428 DataBrowserItemID container,
1429 UInt32 numItems,
1430 const DataBrowserItemID *items,
1431 DataBrowserPropertyID preSortProperty )
1432 {
1433 return RemoveDataBrowserItems( m_controlRef, container, numItems, items, preSortProperty );
1434 }
1435
1436 OSStatus wxMacDataBrowserControl::RevealItem(
1437 DataBrowserItemID item,
1438 DataBrowserPropertyID propertyID,
1439 DataBrowserRevealOptions options ) const
1440 {
1441 return RevealDataBrowserItem( m_controlRef, item, propertyID, options );
1442 }
1443
1444 OSStatus wxMacDataBrowserControl::SetSelectedItems(
1445 UInt32 numItems,
1446 const DataBrowserItemID *items,
1447 DataBrowserSetOption operation )
1448 {
1449 return SetDataBrowserSelectedItems( m_controlRef, numItems, items, operation );
1450 }
1451
1452 OSStatus wxMacDataBrowserControl::GetSelectionAnchor( DataBrowserItemID *first, DataBrowserItemID *last ) const
1453 {
1454 return GetDataBrowserSelectionAnchor( m_controlRef, first, last );
1455 }
1456
1457 OSStatus wxMacDataBrowserControl::GetItemID( DataBrowserTableViewRowIndex row, DataBrowserItemID * item ) const
1458 {
1459 return GetDataBrowserTableViewItemID( m_controlRef, row, item );
1460 }
1461
1462 OSStatus wxMacDataBrowserControl::GetItemRow( DataBrowserItemID item, DataBrowserTableViewRowIndex * row ) const
1463 {
1464 return GetDataBrowserTableViewItemRow( m_controlRef, item, row );
1465 }
1466
1467 OSStatus wxMacDataBrowserControl::SetDefaultRowHeight( UInt16 height )
1468 {
1469 return SetDataBrowserTableViewRowHeight( m_controlRef , height );
1470 }
1471
1472 OSStatus wxMacDataBrowserControl::GetDefaultRowHeight( UInt16 * height ) const
1473 {
1474 return GetDataBrowserTableViewRowHeight( m_controlRef, height );
1475 }
1476
1477 OSStatus wxMacDataBrowserControl::SetRowHeight( DataBrowserItemID item , UInt16 height)
1478 {
1479 return SetDataBrowserTableViewItemRowHeight( m_controlRef, item , height );
1480 }
1481
1482 OSStatus wxMacDataBrowserControl::GetRowHeight( DataBrowserItemID item , UInt16 *height) const
1483 {
1484 return GetDataBrowserTableViewItemRowHeight( m_controlRef, item , height);
1485 }
1486
1487 OSStatus wxMacDataBrowserControl::GetColumnWidth( DataBrowserPropertyID column , UInt16 *width ) const
1488 {
1489 return GetDataBrowserTableViewNamedColumnWidth( m_controlRef , column , width );
1490 }
1491
1492 OSStatus wxMacDataBrowserControl::SetColumnWidth( DataBrowserPropertyID column , UInt16 width )
1493 {
1494 return SetDataBrowserTableViewNamedColumnWidth( m_controlRef , column , width );
1495 }
1496
1497 OSStatus wxMacDataBrowserControl::GetDefaultColumnWidth( UInt16 *width ) const
1498 {
1499 return GetDataBrowserTableViewColumnWidth( m_controlRef , width );
1500 }
1501
1502 OSStatus wxMacDataBrowserControl::SetDefaultColumnWidth( UInt16 width )
1503 {
1504 return SetDataBrowserTableViewColumnWidth( m_controlRef , width );
1505 }
1506
1507 OSStatus wxMacDataBrowserControl::GetColumnCount(UInt32* numColumns) const
1508 {
1509 return GetDataBrowserTableViewColumnCount( m_controlRef, numColumns);
1510 }
1511
1512 OSStatus wxMacDataBrowserControl::GetColumnPosition( DataBrowserPropertyID column,
1513 UInt32 *position) const
1514 {
1515 return GetDataBrowserTableViewColumnPosition( m_controlRef , column , position);
1516 }
1517
1518 OSStatus wxMacDataBrowserControl::SetColumnPosition( DataBrowserPropertyID column, UInt32 position)
1519 {
1520 return SetDataBrowserTableViewColumnPosition( m_controlRef , column , position);
1521 }
1522
1523 OSStatus wxMacDataBrowserControl::GetScrollPosition( UInt32 *top , UInt32 *left ) const
1524 {
1525 return GetDataBrowserScrollPosition( m_controlRef , top , left );
1526 }
1527
1528 OSStatus wxMacDataBrowserControl::SetScrollPosition( UInt32 top , UInt32 left )
1529 {
1530 return SetDataBrowserScrollPosition( m_controlRef , top , left );
1531 }
1532
1533 OSStatus wxMacDataBrowserControl::GetSortProperty( DataBrowserPropertyID *column ) const
1534 {
1535 return GetDataBrowserSortProperty( m_controlRef , column );
1536 }
1537
1538 OSStatus wxMacDataBrowserControl::SetSortProperty( DataBrowserPropertyID column )
1539 {
1540 return SetDataBrowserSortProperty( m_controlRef , column );
1541 }
1542
1543 OSStatus wxMacDataBrowserControl::GetSortOrder( DataBrowserSortOrder *order ) const
1544 {
1545 return GetDataBrowserSortOrder( m_controlRef , order );
1546 }
1547
1548 OSStatus wxMacDataBrowserControl::SetSortOrder( DataBrowserSortOrder order )
1549 {
1550 return SetDataBrowserSortOrder( m_controlRef , order );
1551 }
1552
1553 OSStatus wxMacDataBrowserControl::GetPropertyFlags( DataBrowserPropertyID property,
1554 DataBrowserPropertyFlags *flags ) const
1555 {
1556 return GetDataBrowserPropertyFlags( m_controlRef , property , flags );
1557 }
1558
1559 OSStatus wxMacDataBrowserControl::SetPropertyFlags( DataBrowserPropertyID property,
1560 DataBrowserPropertyFlags flags )
1561 {
1562 return SetDataBrowserPropertyFlags( m_controlRef , property , flags );
1563 }
1564
1565 OSStatus wxMacDataBrowserControl::GetHeaderDesc( DataBrowserPropertyID property,
1566 DataBrowserListViewHeaderDesc *desc ) const
1567 {
1568 return GetDataBrowserListViewHeaderDesc( m_controlRef , property , desc );
1569 }
1570
1571 OSStatus wxMacDataBrowserControl::SetHeaderDesc( DataBrowserPropertyID property,
1572 DataBrowserListViewHeaderDesc *desc )
1573 {
1574 return SetDataBrowserListViewHeaderDesc( m_controlRef , property , desc );
1575 }
1576
1577 OSStatus wxMacDataBrowserControl::SetDisclosureColumn( DataBrowserPropertyID property ,
1578 Boolean expandableRows )
1579 {
1580 return SetDataBrowserListViewDisclosureColumn( m_controlRef, property, expandableRows);
1581 }
1582
1583 // ============================================================================
1584 // Higher-level Databrowser
1585 // ============================================================================
1586 //
1587 // basing on data item objects
1588 //
1589
1590 wxMacDataItem::wxMacDataItem()
1591 {
1592 m_data = NULL;
1593 m_order = 0;
1594 m_colId = kTextColumnId; // for compat with existing wx*ListBox impls.
1595 }
1596
1597 wxMacDataItem::~wxMacDataItem()
1598 {
1599 }
1600
1601 void wxMacDataItem::SetOrder( SInt32 order )
1602 {
1603 m_order = order;
1604 }
1605
1606 SInt32 wxMacDataItem::GetOrder() const
1607 {
1608 return m_order;
1609 }
1610
1611 void wxMacDataItem::SetData( void* data)
1612 {
1613 m_data = data;
1614 }
1615
1616 void* wxMacDataItem::GetData() const
1617 {
1618 return m_data;
1619 }
1620
1621 short wxMacDataItem::GetColumn()
1622 {
1623 return m_colId;
1624 }
1625
1626 void wxMacDataItem::SetColumn( short col )
1627 {
1628 m_colId = col;
1629 }
1630
1631 void wxMacDataItem::SetLabel( const wxString& str)
1632 {
1633 m_label = str;
1634 m_cfLabel.Assign( str , wxLocale::GetSystemEncoding());
1635 }
1636
1637 const wxString& wxMacDataItem::GetLabel() const
1638 {
1639 return m_label;
1640 }
1641
1642 bool wxMacDataItem::IsLessThan(wxMacDataItemBrowserControl *owner ,
1643 const wxMacDataItem* rhs,
1644 DataBrowserPropertyID sortProperty) const
1645 {
1646 const wxMacDataItem* otherItem = dynamic_cast<const wxMacDataItem*>(rhs);
1647 bool retval = false;
1648
1649 if ( sortProperty == m_colId && owner->GetSortOrder() != SortOrder_None){
1650 retval = m_label.CmpNoCase( otherItem->m_label) < 0;
1651 }
1652
1653 else if ( owner->GetSortOrder() == SortOrder_None || sortProperty == kNumericOrderColumnId )
1654 retval = m_order < otherItem->m_order;
1655
1656 return retval;
1657 }
1658
1659 OSStatus wxMacDataItem::GetSetData( wxMacDataItemBrowserControl *owner ,
1660 DataBrowserPropertyID property,
1661 DataBrowserItemDataRef itemData,
1662 bool changeValue )
1663 {
1664 OSStatus err = errDataBrowserPropertyNotSupported;
1665 if ( !changeValue )
1666 {
1667 if ( property == m_colId ){
1668 err = ::SetDataBrowserItemDataText( itemData, m_cfLabel );
1669 err = noErr;
1670 }
1671 else if ( property == kNumericOrderColumnId ){
1672 err = ::SetDataBrowserItemDataValue( itemData, m_order );
1673 err = noErr;
1674 }
1675 else{
1676 }
1677 }
1678 else
1679 {
1680 switch (property)
1681 {
1682 // no editable props here
1683 default:
1684 break;
1685 }
1686 }
1687
1688 return err;
1689 }
1690
1691 void wxMacDataItem::Notification(wxMacDataItemBrowserControl *owner ,
1692 DataBrowserItemNotification message,
1693 DataBrowserItemDataRef itemData ) const
1694 {
1695 }
1696
1697
1698 wxMacDataItemBrowserControl::wxMacDataItemBrowserControl( wxWindow* peer , const wxPoint& pos, const wxSize& size, long style) :
1699 wxMacDataBrowserControl( peer, pos, size, style )
1700 {
1701 m_suppressSelection = false;
1702 m_sortOrder = SortOrder_None;
1703 m_clientDataItemsType = wxClientData_None;
1704 }
1705
1706 ListSortOrder wxMacDataItemBrowserControl::GetSortOrder() const
1707 {
1708 return m_sortOrder;
1709 }
1710
1711 void wxMacDataItemBrowserControl::SetSortOrder(const ListSortOrder sort)
1712 {
1713 m_sortOrder = sort;
1714 }
1715
1716 wxMacDataItem* wxMacDataItemBrowserControl::CreateItem()
1717 {
1718 return new wxMacDataItem();
1719 }
1720
1721 wxMacDataItemBrowserSelectionSuppressor::wxMacDataItemBrowserSelectionSuppressor(wxMacDataItemBrowserControl *browser)
1722 {
1723 m_former = browser->SuppressSelection(true);
1724 m_browser = browser;
1725 }
1726
1727 wxMacDataItemBrowserSelectionSuppressor::~wxMacDataItemBrowserSelectionSuppressor()
1728 {
1729 m_browser->SuppressSelection(m_former);
1730 }
1731
1732 bool wxMacDataItemBrowserControl::SuppressSelection( bool suppress )
1733 {
1734 bool former = m_suppressSelection;
1735 m_suppressSelection = suppress;
1736
1737 return former;
1738 }
1739
1740 Boolean wxMacDataItemBrowserControl::CompareItems(DataBrowserItemID itemOneID,
1741 DataBrowserItemID itemTwoID,
1742 DataBrowserPropertyID sortProperty)
1743 {
1744 wxMacDataItem* itemOne = (wxMacDataItem*) itemOneID;
1745 wxMacDataItem* itemTwo = (wxMacDataItem*) itemTwoID;
1746 return CompareItems( itemOne , itemTwo , sortProperty );
1747 }
1748
1749 Boolean wxMacDataItemBrowserControl::CompareItems(const wxMacDataItem* itemOne,
1750 const wxMacDataItem* itemTwo,
1751 DataBrowserPropertyID sortProperty)
1752 {
1753 Boolean retval = false;
1754 if ( itemOne != NULL )
1755 retval = itemOne->IsLessThan( this , itemTwo , sortProperty);
1756 return retval;
1757 }
1758
1759 OSStatus wxMacDataItemBrowserControl::GetSetItemData(
1760 DataBrowserItemID itemID,
1761 DataBrowserPropertyID property,
1762 DataBrowserItemDataRef itemData,
1763 Boolean changeValue )
1764 {
1765 wxMacDataItem* item = (wxMacDataItem*) itemID;
1766 return GetSetItemData(item, property, itemData , changeValue );
1767 }
1768
1769 OSStatus wxMacDataItemBrowserControl::GetSetItemData(
1770 wxMacDataItem* item,
1771 DataBrowserPropertyID property,
1772 DataBrowserItemDataRef itemData,
1773 Boolean changeValue )
1774 {
1775 OSStatus err = errDataBrowserPropertyNotSupported;
1776 switch( property )
1777 {
1778 case kDataBrowserContainerIsClosableProperty :
1779 case kDataBrowserContainerIsSortableProperty :
1780 case kDataBrowserContainerIsOpenableProperty :
1781 // right now default behaviour on these
1782 break;
1783 default :
1784
1785 if ( item != NULL ){
1786 err = item->GetSetData( this, property , itemData , changeValue );
1787 }
1788 break;
1789
1790 }
1791 return err;
1792 }
1793
1794 void wxMacDataItemBrowserControl::ItemNotification(
1795 DataBrowserItemID itemID,
1796 DataBrowserItemNotification message,
1797 DataBrowserItemDataRef itemData)
1798 {
1799 wxMacDataItem* item = (wxMacDataItem*) itemID;
1800 ItemNotification( item , message, itemData);
1801 }
1802
1803 void wxMacDataItemBrowserControl::ItemNotification(
1804 const wxMacDataItem* item,
1805 DataBrowserItemNotification message,
1806 DataBrowserItemDataRef itemData)
1807 {
1808 if (item != NULL)
1809 item->Notification( this, message, itemData);
1810 }
1811
1812 unsigned int wxMacDataItemBrowserControl::GetItemCount(const wxMacDataItem* container,
1813 bool recurse , DataBrowserItemState state) const
1814 {
1815 UInt32 numItems = 0;
1816 verify_noerr( wxMacDataBrowserControl::GetItemCount( (DataBrowserItemID)container,
1817 recurse, state, &numItems ) );
1818 return numItems;
1819 }
1820
1821 unsigned int wxMacDataItemBrowserControl::GetSelectedItemCount( const wxMacDataItem* container,
1822 bool recurse ) const
1823 {
1824 return GetItemCount( container, recurse, kDataBrowserItemIsSelected );
1825
1826 }
1827
1828 void wxMacDataItemBrowserControl::GetItems(const wxMacDataItem* container,
1829 bool recurse , DataBrowserItemState state, wxArrayMacDataItemPtr &items) const
1830 {
1831 Handle handle = NewHandle(0);
1832 verify_noerr( wxMacDataBrowserControl::GetItems( (DataBrowserItemID)container ,
1833 recurse , state, handle) );
1834
1835 int itemCount = GetHandleSize(handle)/sizeof(DataBrowserItemID);
1836 HLock( handle );
1837 wxMacDataItemPtr* itemsArray = (wxMacDataItemPtr*) *handle;
1838 for ( int i = 0; i < itemCount; ++i)
1839 {
1840 items.Add(itemsArray[i]);
1841 }
1842 HUnlock( handle );
1843 DisposeHandle( handle );
1844 }
1845
1846 unsigned int wxMacDataItemBrowserControl::GetLineFromItem(const wxMacDataItem* item) const
1847 {
1848 DataBrowserTableViewRowIndex row;
1849 OSStatus err = GetItemRow( (DataBrowserItemID) item , &row);
1850 wxASSERT( err == noErr);
1851 return row;
1852 }
1853
1854 wxMacDataItem* wxMacDataItemBrowserControl::GetItemFromLine(unsigned int n) const
1855 {
1856 DataBrowserItemID id;
1857 OSStatus err = GetItemID( (DataBrowserTableViewRowIndex) n , &id);
1858 wxASSERT( err == noErr);
1859 return (wxMacDataItem*) id;
1860 }
1861
1862 void wxMacDataItemBrowserControl::UpdateItem(const wxMacDataItem *container,
1863 const wxMacDataItem *item , DataBrowserPropertyID property) const
1864 {
1865 verify_noerr( wxMacDataBrowserControl::UpdateItems((DataBrowserItemID)container, 1,
1866 (DataBrowserItemID*) &item, kDataBrowserItemNoProperty /* notSorted */, property ) );
1867 }
1868
1869 void wxMacDataItemBrowserControl::UpdateItems(const wxMacDataItem *container,
1870 wxArrayMacDataItemPtr &itemArray , DataBrowserPropertyID property) const
1871 {
1872 unsigned int noItems = itemArray.GetCount();
1873 DataBrowserItemID *items = new DataBrowserItemID[noItems];
1874 for ( unsigned int i = 0; i < noItems; ++i )
1875 items[i] = (DataBrowserItemID) itemArray[i];
1876
1877 verify_noerr( wxMacDataBrowserControl::UpdateItems((DataBrowserItemID)container, noItems,
1878 items, kDataBrowserItemNoProperty /* notSorted */, property ) );
1879 delete [] items;
1880 }
1881
1882 void wxMacDataItemBrowserControl::InsertColumn(int colId, DataBrowserPropertyType colType,
1883 const wxString& title, SInt16 just, int defaultWidth)
1884 {
1885 DataBrowserListViewColumnDesc columnDesc;
1886 columnDesc.headerBtnDesc.titleOffset = 0;
1887 columnDesc.headerBtnDesc.version = kDataBrowserListViewLatestHeaderDesc;
1888
1889 columnDesc.headerBtnDesc.btnFontStyle.flags =
1890 kControlUseFontMask | kControlUseJustMask;
1891
1892 columnDesc.headerBtnDesc.btnContentInfo.contentType = kControlContentTextOnly;
1893 columnDesc.headerBtnDesc.btnFontStyle.just = just;
1894 columnDesc.headerBtnDesc.btnFontStyle.font = kControlFontViewSystemFont;
1895 columnDesc.headerBtnDesc.btnFontStyle.style = normal;
1896
1897 // TODO: Why is m_font not defined when we enter wxLC_LIST mode, but is
1898 // defined for other modes?
1899 wxFontEncoding enc;
1900 if ( m_font.Ok() )
1901 enc = m_font.GetEncoding();
1902 else
1903 enc = wxLocale::GetSystemEncoding();
1904 wxMacCFStringHolder cfTitle;
1905 cfTitle.Assign( title, enc );
1906 columnDesc.headerBtnDesc.titleString = cfTitle;
1907
1908 columnDesc.headerBtnDesc.minimumWidth = 0;
1909 columnDesc.headerBtnDesc.maximumWidth = 30000;
1910
1911 columnDesc.propertyDesc.propertyID = (kMinColumnId + colId);
1912 columnDesc.propertyDesc.propertyType = colType;
1913 columnDesc.propertyDesc.propertyFlags = kDataBrowserListViewDefaultColumnFlags | kDataBrowserListViewTypeSelectColumn;;
1914 #if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_4
1915 columnDesc.propertyDesc.propertyFlags = kDataBrowserListViewNoGapForIconInHeaderButton;
1916 #endif
1917
1918 verify_noerr( AddColumn( &columnDesc, kDataBrowserListViewAppendColumn ) );
1919
1920 if (defaultWidth > 0){
1921 SetColumnWidth(colId, defaultWidth);
1922 }
1923
1924 }
1925
1926 void wxMacDataItemBrowserControl::SetColumnWidth(int colId, int width)
1927 {
1928 DataBrowserPropertyID id;
1929 GetColumnIDFromIndex(colId, &id);
1930 verify_noerr( wxMacDataBrowserControl::SetColumnWidth(id, width));
1931 }
1932
1933 int wxMacDataItemBrowserControl::GetColumnWidth(int colId)
1934 {
1935 DataBrowserPropertyID id;
1936 GetColumnIDFromIndex(colId, &id);
1937 UInt16 result;
1938 verify_noerr( wxMacDataBrowserControl::GetColumnWidth(id, &result));
1939 return result;
1940 }
1941
1942 void wxMacDataItemBrowserControl::AddItem(wxMacDataItem *container, wxMacDataItem *item)
1943 {
1944 verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, 1,
1945 (DataBrowserItemID*) &item, kDataBrowserItemNoProperty ) );
1946 }
1947
1948 void wxMacDataItemBrowserControl::AddItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray )
1949 {
1950 unsigned int noItems = itemArray.GetCount();
1951 DataBrowserItemID *items = new DataBrowserItemID[noItems];
1952 for ( unsigned int i = 0; i < noItems; ++i )
1953 items[i] = (DataBrowserItemID) itemArray[i];
1954
1955 verify_noerr( wxMacDataBrowserControl::AddItems( (DataBrowserItemID)container, noItems,
1956 (DataBrowserItemID*) items, kDataBrowserItemNoProperty ) );
1957 delete [] items;
1958 }
1959
1960 void wxMacDataItemBrowserControl::RemoveItem(wxMacDataItem *container, wxMacDataItem* item)
1961 {
1962 OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 1,
1963 (UInt32*) &item, kDataBrowserItemNoProperty );
1964 verify_noerr( err );
1965 }
1966
1967 void wxMacDataItemBrowserControl::RemoveItems(wxMacDataItem *container, wxArrayMacDataItemPtr &itemArray)
1968 {
1969 unsigned int noItems = itemArray.GetCount();
1970 DataBrowserItemID *items = new DataBrowserItemID[noItems];
1971 for ( unsigned int i = 0; i < noItems; ++i )
1972 items[i] = (DataBrowserItemID) itemArray[i];
1973
1974 OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, noItems,
1975 (UInt32*) items, kDataBrowserItemNoProperty );
1976 verify_noerr( err );
1977 delete [] items;
1978 }
1979
1980 void wxMacDataItemBrowserControl::RemoveAllItems(wxMacDataItem *container)
1981 {
1982 OSStatus err = wxMacDataBrowserControl::RemoveItems( (DataBrowserItemID)container, 0 , NULL , kDataBrowserItemNoProperty );
1983 verify_noerr( err );
1984 }
1985
1986 void wxMacDataItemBrowserControl::SetSelectedItem(wxMacDataItem* item , DataBrowserSetOption option)
1987 {
1988 verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 1, (DataBrowserItemID*) &item, option ));
1989 }
1990
1991 void wxMacDataItemBrowserControl::SetSelectedAllItems(DataBrowserSetOption option)
1992 {
1993 verify_noerr(wxMacDataBrowserControl::SetSelectedItems( 0 , NULL , option ));
1994 }
1995
1996 void wxMacDataItemBrowserControl::SetSelectedItems(wxArrayMacDataItemPtr &itemArray , DataBrowserSetOption option)
1997 {
1998 unsigned int noItems = itemArray.GetCount();
1999 DataBrowserItemID *items = new DataBrowserItemID[noItems];
2000 for ( unsigned int i = 0; i < noItems; ++i )
2001 items[i] = (DataBrowserItemID) itemArray[i];
2002
2003 verify_noerr(wxMacDataBrowserControl::SetSelectedItems( noItems, (DataBrowserItemID*) items, option ));
2004 delete [] items;
2005 }
2006
2007 Boolean wxMacDataItemBrowserControl::IsItemSelected( const wxMacDataItem* item) const
2008 {
2009 return wxMacDataBrowserControl::IsItemSelected( (DataBrowserItemID) item);
2010 }
2011
2012 void wxMacDataItemBrowserControl::RevealItem( wxMacDataItem* item, DataBrowserRevealOptions options)
2013 {
2014 verify_noerr(wxMacDataBrowserControl::RevealItem( (DataBrowserItemID) item, kDataBrowserNoItem , options ) );
2015 }
2016
2017 void wxMacDataItemBrowserControl::GetSelectionAnchor( wxMacDataItemPtr* first , wxMacDataItemPtr* last) const
2018 {
2019 verify_noerr(wxMacDataBrowserControl::GetSelectionAnchor( (DataBrowserItemID*) first, (DataBrowserItemID*) last) );
2020 }
2021
2022 wxClientDataType wxMacDataItemBrowserControl::GetClientDataType() const
2023 {
2024 return m_clientDataItemsType;
2025 }
2026 void wxMacDataItemBrowserControl::SetClientDataType(wxClientDataType clientDataItemsType)
2027 {
2028 m_clientDataItemsType = clientDataItemsType;
2029 }
2030
2031 unsigned int wxMacDataItemBrowserControl::MacGetCount() const
2032 {
2033 return GetItemCount(wxMacDataBrowserRootContainer,false,kDataBrowserItemAnyState);
2034 }
2035
2036 void wxMacDataItemBrowserControl::MacDelete( unsigned int n )
2037 {
2038 wxMacDataItem* item = (wxMacDataItem*)GetItemFromLine( n );
2039 RemoveItem( wxMacDataBrowserRootContainer, item );
2040 }
2041
2042 void wxMacDataItemBrowserControl::MacInsert( unsigned int n, const wxString& text, int column )
2043 {
2044 wxMacDataItem* newItem = CreateItem();
2045 newItem->SetLabel( text );
2046 if ( column != -1 )
2047 newItem->SetColumn( kMinColumnId + column );
2048
2049 if ( m_sortOrder == SortOrder_None )
2050 {
2051 // increase the order of the lines to be shifted
2052 unsigned int lines = MacGetCount();
2053 for ( unsigned int i = n; i < lines; ++i)
2054 {
2055 wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(i);
2056 iter->SetOrder( iter->GetOrder() + 1 );
2057 }
2058
2059 SInt32 frontLineOrder = 0;
2060 if ( n > 0 )
2061 {
2062 wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(n-1);
2063 frontLineOrder = iter->GetOrder();
2064 }
2065 newItem->SetOrder( frontLineOrder + 1 );
2066 }
2067
2068 AddItem( wxMacDataBrowserRootContainer, newItem );
2069 }
2070
2071 void wxMacDataItemBrowserControl::MacInsert( unsigned int n, const wxArrayString& items, int column )
2072 {
2073 size_t itemsCount = items.GetCount();
2074 if ( itemsCount == 0 )
2075 return;
2076
2077 SInt32 frontLineOrder = 0;
2078
2079 if ( m_sortOrder == SortOrder_None )
2080 {
2081 // increase the order of the lines to be shifted
2082 unsigned int lines = MacGetCount();
2083 for ( unsigned int i = n; i < lines; ++i)
2084 {
2085 wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(i);
2086 iter->SetOrder( iter->GetOrder() + itemsCount );
2087 }
2088 if ( n > 0 )
2089 {
2090 wxMacDataItem* iter = (wxMacDataItem*) GetItemFromLine(n-1);
2091 frontLineOrder = iter->GetOrder();
2092 }
2093 }
2094
2095 wxArrayMacDataItemPtr ids;
2096 ids.SetCount( itemsCount );
2097
2098 for ( unsigned int i = 0; i < itemsCount; ++i )
2099 {
2100 wxMacDataItem* item = CreateItem();
2101 item->SetLabel( items[i]);
2102 if ( column != -1 )
2103 item->SetColumn( kMinColumnId + column );
2104
2105 if ( m_sortOrder == SortOrder_None )
2106 item->SetOrder( frontLineOrder + 1 + i );
2107
2108 ids[i] = item;
2109 }
2110
2111 AddItems( wxMacDataBrowserRootContainer, ids );
2112 }
2113
2114 int wxMacDataItemBrowserControl::MacAppend( const wxString& text)
2115 {
2116 wxMacDataItem* item = CreateItem();
2117 item->SetLabel( text );
2118 if ( m_sortOrder == SortOrder_None )
2119 {
2120 unsigned int lines = MacGetCount();
2121 if ( lines == 0 )
2122 item->SetOrder( 1 );
2123 else
2124 {
2125 wxMacDataItem* frontItem = (wxMacDataItem*) GetItemFromLine(lines-1);
2126 item->SetOrder( frontItem->GetOrder() + 1 );
2127 }
2128 }
2129 AddItem( wxMacDataBrowserRootContainer, item );
2130
2131 return GetLineFromItem(item);
2132 }
2133
2134 void wxMacDataItemBrowserControl::MacClear()
2135 {
2136 wxMacDataItemBrowserSelectionSuppressor suppressor(this);
2137 RemoveAllItems(wxMacDataBrowserRootContainer);
2138 }
2139
2140 void wxMacDataItemBrowserControl::MacDeselectAll()
2141 {
2142 wxMacDataItemBrowserSelectionSuppressor suppressor(this);
2143 SetSelectedAllItems( kDataBrowserItemsRemove );
2144 }
2145
2146 void wxMacDataItemBrowserControl::MacSetSelection( unsigned int n, bool select, bool multi )
2147 {
2148 wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine(n);
2149 wxMacDataItemBrowserSelectionSuppressor suppressor(this);
2150
2151 if ( IsItemSelected( item ) != select )
2152 {
2153 if ( select )
2154 SetSelectedItem( item, multi ? kDataBrowserItemsAdd : kDataBrowserItemsAssign );
2155 else
2156 SetSelectedItem( item, kDataBrowserItemsRemove );
2157 }
2158
2159 MacScrollTo( n );
2160 }
2161
2162 bool wxMacDataItemBrowserControl::MacIsSelected( unsigned int n ) const
2163 {
2164 wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine(n);
2165 return IsItemSelected( item );
2166 }
2167
2168 int wxMacDataItemBrowserControl::MacGetSelection() const
2169 {
2170 wxMacDataItemPtr first, last;
2171 GetSelectionAnchor( &first, &last );
2172
2173 if ( first != NULL )
2174 {
2175 return GetLineFromItem( first );
2176 }
2177
2178 return -1;
2179 }
2180
2181 int wxMacDataItemBrowserControl::MacGetSelections( wxArrayInt& aSelections ) const
2182 {
2183 aSelections.Empty();
2184 wxArrayMacDataItemPtr selectedItems;
2185 GetItems( wxMacDataBrowserRootContainer, false , kDataBrowserItemIsSelected, selectedItems);
2186
2187 int count = selectedItems.GetCount();
2188
2189 for ( int i = 0; i < count; ++i)
2190 {
2191 aSelections.Add(GetLineFromItem(selectedItems[i]));
2192 }
2193
2194 return count;
2195 }
2196
2197 void wxMacDataItemBrowserControl::MacSetString( unsigned int n, const wxString& text )
2198 {
2199 // as we don't store the strings we only have to issue a redraw
2200 wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine( n);
2201 item->SetLabel( text );
2202 UpdateItem( wxMacDataBrowserRootContainer, item , kTextColumnId );
2203 }
2204
2205 wxString wxMacDataItemBrowserControl::MacGetString( unsigned int n ) const
2206 {
2207 wxMacDataItem * item = (wxMacDataItem*) GetItemFromLine( n );
2208 return item->GetLabel();
2209 }
2210
2211 void wxMacDataItemBrowserControl::MacSetClientData( unsigned int n, void * data)
2212 {
2213 wxMacDataItem* item = (wxMacDataItem*) GetItemFromLine( n);
2214 item->SetData( data );
2215 // not displayed, therefore no Update infos to DataBrowser
2216 }
2217
2218 void * wxMacDataItemBrowserControl::MacGetClientData( unsigned int n) const
2219 {
2220 wxMacDataItem * item = (wxMacDataItem*) GetItemFromLine( n );
2221 return item->GetData();
2222 }
2223
2224 void wxMacDataItemBrowserControl::MacScrollTo( unsigned int n )
2225 {
2226 RevealItem( GetItemFromLine( n) , kDataBrowserRevealWithoutSelecting );
2227 }
2228
2229
2230
2231 //
2232 // Tab Control
2233 //
2234
2235 OSStatus wxMacControl::SetTabEnabled( SInt16 tabNo , bool enable )
2236 {
2237 return ::SetTabEnabled( m_controlRef , tabNo , enable );
2238 }
2239
2240 //
2241 // Quartz Support
2242 //
2243
2244 #ifdef __WXMAC_OSX__
2245 // snippets from Sketch Sample from Apple :
2246
2247 #define kGenericRGBProfilePathStr "/System/Library/ColorSync/Profiles/Generic RGB Profile.icc"
2248
2249 /*
2250 This function locates, opens, and returns the profile reference for the calibrated
2251 Generic RGB color space. It is up to the caller to call CMCloseProfile when done
2252 with the profile reference this function returns.
2253 */
2254 CMProfileRef wxMacOpenGenericProfile()
2255 {
2256 static CMProfileRef cachedRGBProfileRef = NULL;
2257
2258 // we only create the profile reference once
2259 if (cachedRGBProfileRef == NULL)
2260 {
2261 CMProfileLocation loc;
2262
2263 loc.locType = cmPathBasedProfile;
2264 strcpy(loc.u.pathLoc.path, kGenericRGBProfilePathStr);
2265
2266 verify_noerr( CMOpenProfile(&cachedRGBProfileRef, &loc) );
2267 }
2268
2269 // clone the profile reference so that the caller has their own reference, not our cached one
2270 if (cachedRGBProfileRef)
2271 CMCloneProfileRef(cachedRGBProfileRef);
2272
2273 return cachedRGBProfileRef;
2274 }
2275
2276 /*
2277 Return the generic RGB color space. This is a 'get' function and the caller should
2278 not release the returned value unless the caller retains it first. Usually callers
2279 of this routine will immediately use the returned colorspace with CoreGraphics
2280 so they typically do not need to retain it themselves.
2281
2282 This function creates the generic RGB color space once and hangs onto it so it can
2283 return it whenever this function is called.
2284 */
2285
2286 CGColorSpaceRef wxMacGetGenericRGBColorSpace()
2287 {
2288 static wxMacCFRefHolder<CGColorSpaceRef> genericRGBColorSpace;
2289
2290 if (genericRGBColorSpace == NULL)
2291 {
2292 if ( UMAGetSystemVersion() >= 0x1040 )
2293 {
2294 genericRGBColorSpace.Set( CGColorSpaceCreateWithName( CFSTR("kCGColorSpaceGenericRGB") ) );
2295 }
2296 else
2297 {
2298 CMProfileRef genericRGBProfile = wxMacOpenGenericProfile();
2299
2300 if (genericRGBProfile)
2301 {
2302 genericRGBColorSpace.Set( CGColorSpaceCreateWithPlatformColorSpace(genericRGBProfile) );
2303
2304 wxASSERT_MSG( genericRGBColorSpace != NULL, wxT("couldn't create the generic RGB color space") );
2305
2306 // we opened the profile so it is up to us to close it
2307 CMCloseProfile(genericRGBProfile);
2308 }
2309 }
2310 }
2311
2312 return genericRGBColorSpace;
2313 }
2314 #endif
2315
2316 wxMacPortSaver::wxMacPortSaver( GrafPtr port )
2317 {
2318 ::GetPort( &m_port );
2319 ::SetPort( port );
2320 }
2321
2322 wxMacPortSaver::~wxMacPortSaver()
2323 {
2324 ::SetPort( m_port );
2325 }
2326
2327 #endif // wxUSE_GUI