]> git.saurik.com Git - wxWidgets.git/blob - src/mac/carbon/utils.cpp
protect separators against inappropriate state changes
[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 #include "wx/app.h"
16 #include "wx/apptrait.h"
17
18 #if wxUSE_GUI
19 #include "wx/mac/uma.h"
20 #include "wx/font.h"
21 #include "wx/toplevel.h"
22 #else
23 #include "wx/intl.h"
24 #endif
25
26 #include <ctype.h>
27
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <stdarg.h>
32
33 #include "MoreFilesX.h"
34
35 #ifndef __DARWIN__
36 #include <Threads.h>
37 #include <Sound.h>
38 #endif
39
40 #if wxUSE_GUI
41 #if TARGET_API_MAC_OSX
42 #include <CoreServices/CoreServices.h>
43 #else
44 #include <DriverServices.h>
45 #include <Multiprocessing.h>
46 #endif
47
48 #ifdef __DARWIN__
49 #include <Carbon/Carbon.h>
50 #else
51 #include <ATSUnicode.h>
52 #include <TextCommon.h>
53 #include <TextEncodingConverter.h>
54 #endif
55 #endif // wxUSE_GUI
56
57 #include "wx/mac/private.h" // includes mac headers
58
59 #if defined(__MWERKS__) && wxUSE_UNICODE
60 #include <wtime.h>
61 #endif
62
63 // ---------------------------------------------------------------------------
64 // code used in both base and GUI compilation
65 // ---------------------------------------------------------------------------
66
67 // our OS version is the same in non GUI and GUI cases
68 static int DoGetOSVersion(int *majorVsn, int *minorVsn)
69 {
70 long theSystem ;
71
72 // are there x-platform conventions ?
73
74 Gestalt(gestaltSystemVersion, &theSystem) ;
75 if (minorVsn != NULL) {
76 *minorVsn = (theSystem & 0xFF ) ;
77 }
78 if (majorVsn != NULL) {
79 *majorVsn = (theSystem >> 8 ) ;
80 }
81 #ifdef __DARWIN__
82 return wxMAC_DARWIN;
83 #else
84 return wxMAC;
85 #endif
86 }
87
88
89 #if wxUSE_BASE
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 IsMetroNubInstalled
123 --------------------------------------------------------------------------- */
124
125 Boolean IsMetroNubInstalled()
126 {
127 if (!fRunOnce)
128 {
129 long result, value;
130
131 fRunOnce = true;
132 gMetroNubEntry = NULL;
133
134 if (Gestalt(gestaltSystemVersion, &value) == noErr && value < 0x1000)
135 {
136 /* look for MetroNub's Gestalt selector */
137 if (Gestalt(kMetroNubUserSignature, &result) == noErr)
138 {
139
140 #if TARGET_API_MAC_CARBON
141 if (gCallUniversalProc_Proc == NULL)
142 {
143 CFragConnectionID connectionID;
144 Ptr mainAddress;
145 Str255 errorString;
146 ProcPtr symbolAddress;
147 OSErr err;
148 CFragSymbolClass symbolClass;
149
150 symbolAddress = NULL;
151 err = GetSharedLibrary("\pInterfaceLib", kPowerPCCFragArch, kFindCFrag,
152 &connectionID, &mainAddress, errorString);
153
154 if (err != noErr)
155 {
156 gCallUniversalProc_Proc = NULL;
157 goto end;
158 }
159
160 err = FindSymbol(connectionID, "\pCallUniversalProc",
161 (Ptr *) &gCallUniversalProc_Proc, &symbolClass);
162
163 if (err != noErr)
164 {
165 gCallUniversalProc_Proc = NULL;
166 goto end;
167 }
168 }
169 #endif
170
171 {
172 MetroNubUserEntryBlock* block = (MetroNubUserEntryBlock *)result;
173
174 /* make sure the version of the API is compatible */
175 if (block->apiLowVersion <= kMetroNubUserAPIVersion &&
176 kMetroNubUserAPIVersion <= block->apiHiVersion)
177 gMetroNubEntry = block; /* success! */
178 }
179
180 }
181 }
182 }
183
184 end:
185
186 #if TARGET_API_MAC_CARBON
187 return (gMetroNubEntry != NULL && gCallUniversalProc_Proc != NULL);
188 #else
189 return (gMetroNubEntry != NULL);
190 #endif
191 }
192
193 /* ---------------------------------------------------------------------------
194 IsMWDebuggerRunning [v1 API]
195 --------------------------------------------------------------------------- */
196
197 Boolean IsMWDebuggerRunning()
198 {
199 if (IsMetroNubInstalled())
200 return CallIsDebuggerRunningProc(gMetroNubEntry->isDebuggerRunning);
201 else
202 return false;
203 }
204
205 /* ---------------------------------------------------------------------------
206 AmIBeingMWDebugged [v1 API]
207 --------------------------------------------------------------------------- */
208
209 Boolean AmIBeingMWDebugged()
210 {
211 if (IsMetroNubInstalled())
212 return CallAmIBeingDebuggedProc(gMetroNubEntry->amIBeingDebugged);
213 else
214 return false;
215 }
216
217 extern bool WXDLLEXPORT wxIsDebuggerRunning()
218 {
219 return IsMWDebuggerRunning() && AmIBeingMWDebugged();
220 }
221
222 #else
223
224 extern bool WXDLLEXPORT wxIsDebuggerRunning()
225 {
226 return false;
227 }
228
229 #endif // defined(__WXMAC__) && !defined(__DARWIN__) && (__MWERKS__ >= 0x2400)
230
231
232 #ifndef __DARWIN__
233 // defined in unix/utilsunx.cpp for Mac OS X
234
235 // get full hostname (with domain name if possible)
236 bool wxGetFullHostName(wxChar *buf, int maxSize)
237 {
238 return wxGetHostName(buf, maxSize);
239 }
240
241 // Get hostname only (without domain name)
242 bool wxGetHostName(wxChar *buf, int maxSize)
243 {
244 // Gets Chooser name of user by examining a System resource.
245
246 const short kComputerNameID = -16413;
247
248 short oldResFile = CurResFile() ;
249 UseResFile(0);
250 StringHandle chooserName = (StringHandle)::GetString(kComputerNameID);
251 UseResFile(oldResFile);
252
253 if (chooserName && *chooserName)
254 {
255 HLock( (Handle) chooserName ) ;
256 wxString name = wxMacMakeStringFromPascal( *chooserName ) ;
257 HUnlock( (Handle) chooserName ) ;
258 ReleaseResource( (Handle) chooserName ) ;
259 wxStrncpy( buf , name , maxSize - 1 ) ;
260 }
261 else
262 buf[0] = 0 ;
263
264 return true;
265 }
266
267 // Get user ID e.g. jacs
268 bool wxGetUserId(wxChar *buf, int maxSize)
269 {
270 return wxGetUserName( buf , maxSize ) ;
271 }
272
273 const wxChar* wxGetHomeDir(wxString *pstr)
274 {
275 *pstr = wxMacFindFolder( (short) kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder ) ;
276 return pstr->c_str() ;
277 }
278
279 // Get user name e.g. Stefan Csomor
280 bool wxGetUserName(wxChar *buf, int maxSize)
281 {
282 // Gets Chooser name of user by examining a System resource.
283
284 const short kChooserNameID = -16096;
285
286 short oldResFile = CurResFile() ;
287 UseResFile(0);
288 StringHandle chooserName = (StringHandle)::GetString(kChooserNameID);
289 UseResFile(oldResFile);
290
291 if (chooserName && *chooserName)
292 {
293 HLock( (Handle) chooserName ) ;
294 wxString name = wxMacMakeStringFromPascal( *chooserName ) ;
295 HUnlock( (Handle) chooserName ) ;
296 ReleaseResource( (Handle) chooserName ) ;
297 wxStrncpy( buf , name , maxSize - 1 ) ;
298 }
299 else
300 buf[0] = 0 ;
301
302 return true;
303 }
304
305 int wxKill(long pid, wxSignal sig , wxKillError *rc, int flags)
306 {
307 // TODO
308 return 0;
309 }
310
311 WXDLLEXPORT bool wxGetEnv(const wxString& var, wxString *value)
312 {
313 // TODO : under classic there is no environement support, under X yes
314 return false ;
315 }
316
317 // set the env var name to the given value, return true on success
318 WXDLLEXPORT bool wxSetEnv(const wxString& var, const wxChar *value)
319 {
320 // TODO : under classic there is no environement support, under X yes
321 return false ;
322 }
323
324 //
325 // Execute a program in an Interactive Shell
326 //
327 bool wxShell(const wxString& command)
328 {
329 // TODO
330 return false;
331 }
332
333 // Shutdown or reboot the PC
334 bool wxShutdown(wxShutdownFlags wFlags)
335 {
336 // TODO
337 return false;
338 }
339
340 wxPowerType wxGetPowerType()
341 {
342 // TODO
343 return wxPOWER_UNKNOWN;
344 }
345
346 wxBatteryState wxGetBatteryState()
347 {
348 // TODO
349 return wxBATTERY_UNKNOWN_STATE;
350 }
351
352 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
353 wxMemorySize wxGetFreeMemory()
354 {
355 return (wxMemorySize)FreeMem() ;
356 }
357
358 #ifndef __DARWIN__
359
360 void wxMicroSleep(unsigned long microseconds)
361 {
362 AbsoluteTime wakeup = AddDurationToAbsolute( microseconds * durationMicrosecond , UpTime());
363 MPDelayUntil( & wakeup);
364 }
365
366 void wxMilliSleep(unsigned long milliseconds)
367 {
368 AbsoluteTime wakeup = AddDurationToAbsolute( milliseconds, UpTime());
369 MPDelayUntil( & wakeup);
370 }
371
372 void wxSleep(int nSecs)
373 {
374 wxMilliSleep(1000*nSecs);
375 }
376
377 #endif
378
379 // Consume all events until no more left
380 void wxFlushEvents()
381 {
382 }
383
384 #endif // !__DARWIN__
385
386 // Emit a beeeeeep
387 void wxBell()
388 {
389 SysBeep(30);
390 }
391
392 wxToolkitInfo& wxConsoleAppTraits::GetToolkitInfo()
393 {
394 static wxToolkitInfo info;
395 info.os = DoGetOSVersion(&info.versionMajor, &info.versionMinor);
396 info.name = _T("wxBase");
397 return info;
398 }
399
400 #endif // wxUSE_BASE
401
402 #if wxUSE_GUI
403
404 wxToolkitInfo& wxGUIAppTraits::GetToolkitInfo()
405 {
406 static wxToolkitInfo info;
407 info.os = DoGetOSVersion(&info.versionMajor, &info.versionMinor);
408 info.shortName = _T("mac");
409 info.name = _T("wxMac");
410 #ifdef __WXUNIVERSAL__
411 info.shortName << _T("univ");
412 info.name << _T("/wxUniversal");
413 #endif
414 return info;
415 }
416
417 // Reading and writing resources (eg WIN.INI, .Xdefaults)
418 #if wxUSE_RESOURCES
419 bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
420 {
421 // TODO
422 return false;
423 }
424
425 bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
426 {
427 wxString buf;
428 buf.Printf(wxT("%.4f"), value);
429
430 return wxWriteResource(section, entry, buf, file);
431 }
432
433 bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
434 {
435 wxString buf;
436 buf.Printf(wxT("%ld"), value);
437
438 return wxWriteResource(section, entry, buf, file);
439 }
440
441 bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
442 {
443 wxString buf;
444 buf.Printf(wxT("%d"), value);
445
446 return wxWriteResource(section, entry, buf, file);
447 }
448
449 bool wxGetResource(const wxString& section, const wxString& entry, char **value, const wxString& file)
450 {
451 // TODO
452 return false;
453 }
454
455 bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file)
456 {
457 char *s = NULL;
458 bool succ = wxGetResource(section, entry, (char **)&s, file);
459 if (succ)
460 {
461 *value = (float)strtod(s, NULL);
462 delete[] s;
463 return true;
464 }
465 else return false;
466 }
467
468 bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file)
469 {
470 char *s = NULL;
471 bool succ = wxGetResource(section, entry, (char **)&s, file);
472 if (succ)
473 {
474 *value = strtol(s, NULL, 10);
475 delete[] s;
476 return true;
477 }
478 else return false;
479 }
480
481 bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
482 {
483 char *s = NULL;
484 bool succ = wxGetResource(section, entry, (char **)&s, file);
485 if (succ)
486 {
487 *value = (int)strtol(s, NULL, 10);
488 delete[] s;
489 return true;
490 }
491 else return false;
492 }
493 #endif // wxUSE_RESOURCES
494
495 int gs_wxBusyCursorCount = 0;
496 extern wxCursor gMacCurrentCursor ;
497 wxCursor gMacStoredActiveCursor ;
498
499 // Set the cursor to the busy cursor for all windows
500 void wxBeginBusyCursor(wxCursor *cursor)
501 {
502 if (gs_wxBusyCursorCount++ == 0)
503 {
504 gMacStoredActiveCursor = gMacCurrentCursor ;
505 cursor->MacInstall() ;
506 }
507 //else: nothing to do, already set
508 }
509
510 // Restore cursor to normal
511 void wxEndBusyCursor()
512 {
513 wxCHECK_RET( gs_wxBusyCursorCount > 0,
514 wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );
515
516 if (--gs_wxBusyCursorCount == 0)
517 {
518 gMacStoredActiveCursor.MacInstall() ;
519 gMacStoredActiveCursor = wxNullCursor ;
520 }
521 }
522
523 // true if we're between the above two calls
524 bool wxIsBusy()
525 {
526 return (gs_wxBusyCursorCount > 0);
527 }
528
529 #endif // wxUSE_GUI
530
531 #if wxUSE_BASE
532
533 wxString wxMacFindFolder( short vol,
534 OSType folderType,
535 Boolean createFolder)
536 {
537 FSRef fsRef ;
538 wxString strDir ;
539
540 if ( FSFindFolder( vol, folderType, createFolder, &fsRef) == noErr)
541 strDir = wxMacFSRefToPath( &fsRef ) + wxFILE_SEP_PATH ;
542
543 return strDir ;
544 }
545
546 #endif // wxUSE_BASE
547
548 #if wxUSE_GUI
549
550 // Check whether this window wants to process messages, e.g. Stop button
551 // in long calculations.
552 bool wxCheckForInterrupt(wxWindow *wnd)
553 {
554 // TODO
555 return false;
556 }
557
558 void wxGetMousePosition( int* x, int* y )
559 {
560 Point pt ;
561
562 GetMouse( &pt ) ;
563 LocalToGlobal( &pt ) ;
564 *x = pt.h ;
565 *y = pt.v ;
566 };
567
568 // Return true if we have a colour display
569 bool wxColourDisplay()
570 {
571 return true;
572 }
573
574 // Returns depth of screen
575 int wxDisplayDepth()
576 {
577 Rect globRect ;
578 SetRect(&globRect, -32760, -32760, 32760, 32760);
579 GDHandle theMaxDevice;
580
581 int theDepth = 8;
582 theMaxDevice = GetMaxDevice(&globRect);
583 if (theMaxDevice != nil)
584 theDepth = (**(**theMaxDevice).gdPMap).pixelSize;
585
586 return theDepth ;
587 }
588
589 // Get size of display
590 void wxDisplaySize(int *width, int *height)
591 {
592 BitMap screenBits;
593 GetQDGlobalsScreenBits( &screenBits );
594
595 if (width != NULL) {
596 *width = screenBits.bounds.right - screenBits.bounds.left ;
597 }
598 if (height != NULL) {
599 *height = screenBits.bounds.bottom - screenBits.bounds.top ;
600 }
601 }
602
603 void wxDisplaySizeMM(int *width, int *height)
604 {
605 wxDisplaySize(width, height);
606 // on mac 72 is fixed (at least now ;-)
607 float cvPt2Mm = 25.4 / 72;
608
609 if (width != NULL) {
610 *width = int( *width * cvPt2Mm );
611 }
612 if (height != NULL) {
613 *height = int( *height * cvPt2Mm );
614 }
615 }
616
617 void wxClientDisplayRect(int *x, int *y, int *width, int *height)
618 {
619 Rect r ;
620 GetAvailableWindowPositioningBounds( GetMainDevice() , &r ) ;
621 if ( x )
622 *x = r.left ;
623 if ( y )
624 *y = r.top ;
625 if ( width )
626 *width = r.right - r.left ;
627 if ( height )
628 *height = r.bottom - r.top ;
629 }
630
631 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
632 {
633 return wxGenericFindWindowAtPoint(pt);
634 }
635
636 #endif // wxUSE_GUI
637
638 #if wxUSE_BASE
639
640 wxString wxGetOsDescription()
641 {
642 #ifdef WXWIN_OS_DESCRIPTION
643 // use configure generated description if available
644 return wxString(wxT("MacOS (")) + wxT(WXWIN_OS_DESCRIPTION) + wxString(wxT(")"));
645 #else
646 return wxT("MacOS") ; //TODO:define further
647 #endif
648 }
649
650 #ifndef __DARWIN__
651 wxChar *wxGetUserHome (const wxString& user)
652 {
653 // TODO
654 return NULL;
655 }
656
657 bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
658 {
659 if ( path.empty() )
660 return false;
661
662 wxString p = path ;
663 if (p[0u] == ':' ) {
664 p = wxGetCwd() + p ;
665 }
666
667 int pos = p.Find(':') ;
668 if ( pos != wxNOT_FOUND ) {
669 p = p.Mid(1,pos) ;
670 }
671
672 p = p + wxT(":") ;
673
674 OSErr err = noErr ;
675
676 FSRef fsRef ;
677 err = wxMacPathToFSRef( p , &fsRef ) ;
678 if ( noErr == err )
679 {
680 FSVolumeRefNum vRefNum ;
681 err = FSGetVRefNum( &fsRef , &vRefNum ) ;
682 if ( noErr == err )
683 {
684 UInt64 freeBytes , totalBytes ;
685 err = FSGetVInfo( vRefNum , NULL , &freeBytes , &totalBytes ) ;
686 if ( noErr == err )
687 {
688 if ( pTotal )
689 *pTotal = wxLongLong( totalBytes ) ;
690 if ( pFree )
691 *pFree = wxLongLong( freeBytes ) ;
692 }
693 }
694 }
695
696 return err == noErr ;
697 }
698 #endif // !__DARWIN__
699
700 //---------------------------------------------------------------------------
701 // wxMac Specific utility functions
702 //---------------------------------------------------------------------------
703
704 void wxMacStringToPascal( const wxString&from , StringPtr to )
705 {
706 wxCharBuffer buf = from.mb_str( wxConvLocal ) ;
707 int len = strlen(buf) ;
708
709 if ( len > 255 )
710 len = 255 ;
711 to[0] = len ;
712 memcpy( (char*) &to[1] , buf , len ) ;
713 }
714
715 wxString wxMacMakeStringFromPascal( ConstStringPtr from )
716 {
717 return wxString( (char*) &from[1] , wxConvLocal , from[0] ) ;
718 }
719
720
721 // ----------------------------------------------------------------------------
722 // Common Event Support
723 // ----------------------------------------------------------------------------
724
725
726 extern ProcessSerialNumber gAppProcess ;
727
728 void wxMacWakeUp()
729 {
730 ProcessSerialNumber psn ;
731 Boolean isSame ;
732 psn.highLongOfPSN = 0 ;
733 psn.lowLongOfPSN = kCurrentProcess ;
734 SameProcess( &gAppProcess , &psn , &isSame ) ;
735 if ( isSame )
736 {
737 #if TARGET_CARBON
738 OSStatus err = noErr ;
739 #if 0
740 // lead sometimes to race conditions, although all calls used should be thread safe ...
741 static wxMacCarbonEvent s_wakeupEvent ;
742 if ( !s_wakeupEvent.IsValid() )
743 {
744 err = s_wakeupEvent.Create( 'WXMC', 'WXMC', GetCurrentEventTime(),
745 kEventAttributeNone ) ;
746 }
747 if ( err == noErr )
748 {
749
750 if ( IsEventInQueue( GetMainEventQueue() , s_wakeupEvent ) )
751 return ;
752 s_wakeupEvent.SetCurrentTime() ;
753 err = PostEventToQueue(GetMainEventQueue(), s_wakeupEvent,
754 kEventPriorityHigh );
755 }
756 #else
757 wxMacCarbonEvent wakeupEvent ;
758 wakeupEvent.Create( 'WXMC', 'WXMC', GetCurrentEventTime(),
759 kEventAttributeNone ) ;
760 err = PostEventToQueue(GetMainEventQueue(), wakeupEvent,
761 kEventPriorityHigh );
762 #endif
763 #else
764 PostEvent( nullEvent , 0 ) ;
765 #endif
766 }
767 else
768 {
769 WakeUpProcess( &gAppProcess ) ;
770 }
771 }
772
773 #endif // wxUSE_BASE
774
775 #if wxUSE_GUI
776
777 // ----------------------------------------------------------------------------
778 // Native Struct Conversions
779 // ----------------------------------------------------------------------------
780
781
782 void wxMacRectToNative( const wxRect *wx , Rect *n )
783 {
784 n->left = wx->x ;
785 n->top = wx->y ;
786 n->right = wx->x + wx->width ;
787 n->bottom = wx->y + wx->height ;
788 }
789
790 void wxMacNativeToRect( const Rect *n , wxRect* wx )
791 {
792 wx->x = n->left ;
793 wx->y = n->top ;
794 wx->width = n->right - n->left ;
795 wx->height = n->bottom - n->top ;
796 }
797
798 void wxMacPointToNative( const wxPoint* wx , Point *n )
799 {
800 n->h = wx->x ;
801 n->v = wx->y ;
802 }
803
804 void wxMacNativeToPoint( const Point *n , wxPoint* wx )
805 {
806 wx->x = n->h ;
807 wx->y = n->v ;
808 }
809
810 // ----------------------------------------------------------------------------
811 // Carbon Event Support
812 // ----------------------------------------------------------------------------
813
814
815 OSStatus wxMacCarbonEvent::GetParameter(EventParamName inName, EventParamType inDesiredType, UInt32 inBufferSize, void * outData)
816 {
817 return ::GetEventParameter( m_eventRef , inName , inDesiredType , NULL , inBufferSize , NULL , outData ) ;
818 }
819
820 OSStatus wxMacCarbonEvent::SetParameter(EventParamName inName, EventParamType inType, UInt32 inBufferSize, const void * inData)
821 {
822 return ::SetEventParameter( m_eventRef , inName , inType , inBufferSize , inData ) ;
823 }
824
825 // ----------------------------------------------------------------------------
826 // Control Access Support
827 // ----------------------------------------------------------------------------
828
829 wxMacControl::wxMacControl(wxWindow* peer , bool isRootControl )
830 {
831 Init() ;
832 m_peer = peer ;
833 m_isRootControl = isRootControl ;
834 m_isCompositing = peer->MacGetTopLevelWindow()->MacUsesCompositing() ;
835 }
836
837 wxMacControl::wxMacControl( wxWindow* peer , ControlRef control )
838 {
839 Init() ;
840 m_peer = peer ;
841 m_isCompositing = peer->MacGetTopLevelWindow()->MacUsesCompositing() ;
842 m_controlRef = control ;
843 }
844
845 wxMacControl::wxMacControl( wxWindow* peer , WXWidget control )
846 {
847 Init() ;
848 m_peer = peer ;
849 m_isCompositing = peer->MacGetTopLevelWindow()->MacUsesCompositing() ;
850 m_controlRef = (ControlRef) control ;
851 }
852
853 wxMacControl::~wxMacControl()
854 {
855 }
856
857 void wxMacControl::Init()
858 {
859 m_peer = NULL ;
860 m_controlRef = NULL ;
861 m_needsFocusRect = false ;
862 m_isCompositing = false ;
863 m_isRootControl = false ;
864 }
865
866 void wxMacControl::Dispose()
867 {
868 ::DisposeControl( m_controlRef ) ;
869 m_controlRef = NULL ;
870 }
871
872 void wxMacControl::SetReference( SInt32 data )
873 {
874 SetControlReference( m_controlRef , data ) ;
875 }
876
877 OSStatus wxMacControl::GetData(ControlPartCode inPartCode , ResType inTag , Size inBufferSize , void * inOutBuffer , Size * outActualSize ) const
878 {
879 return ::GetControlData( m_controlRef , inPartCode , inTag , inBufferSize , inOutBuffer , outActualSize ) ;
880 }
881
882 OSStatus wxMacControl::GetDataSize(ControlPartCode inPartCode , ResType inTag , Size * outActualSize ) const
883 {
884 return ::GetControlDataSize( m_controlRef , inPartCode , inTag , outActualSize ) ;
885 }
886
887 OSStatus wxMacControl::SetData(ControlPartCode inPartCode , ResType inTag , Size inSize , const void * inData)
888 {
889 return ::SetControlData( m_controlRef , inPartCode , inTag , inSize , inData ) ;
890 }
891
892 OSStatus wxMacControl::SendEvent( EventRef event , OptionBits inOptions )
893 {
894 #if TARGET_API_MAC_OSX
895 return SendEventToEventTargetWithOptions( event,
896 HIObjectGetEventTarget( (HIObjectRef) m_controlRef ), inOptions );
897 #else
898 #pragma unused(inOptions)
899 return SendEventToEventTarget(event,GetControlEventTarget( m_controlRef ) ) ;
900 #endif
901 }
902
903 OSStatus wxMacControl::SendHICommand( HICommand &command , OptionBits inOptions )
904 {
905 wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess ) ;
906 event.SetParameter<HICommand>(kEventParamDirectObject,command) ;
907 return SendEvent( event , inOptions ) ;
908 }
909
910 OSStatus wxMacControl::SendHICommand( UInt32 commandID , OptionBits inOptions )
911 {
912 HICommand command ;
913 memset( &command, 0 , sizeof(command) ) ;
914 command.commandID = commandID ;
915 return SendHICommand( command , inOptions ) ;
916 }
917
918 void wxMacControl::Flash( ControlPartCode part , UInt32 ticks )
919 {
920 HiliteControl( m_controlRef , part ) ;
921 unsigned long finalTicks ;
922 Delay( ticks , &finalTicks ) ;
923 HiliteControl( m_controlRef , kControlNoPart ) ;
924 }
925
926 SInt32 wxMacControl::GetValue() const
927 {
928 return ::GetControl32BitValue( m_controlRef ) ;
929 }
930
931 SInt32 wxMacControl::GetMaximum() const
932 {
933 return ::GetControl32BitMaximum( m_controlRef ) ;
934 }
935
936 SInt32 wxMacControl::GetMinimum() const
937 {
938 return ::GetControl32BitMinimum( m_controlRef ) ;
939 }
940
941 void wxMacControl::SetValue( SInt32 v )
942 {
943 ::SetControl32BitValue( m_controlRef , v ) ;
944 }
945
946 void wxMacControl::SetMinimum( SInt32 v )
947 {
948 ::SetControl32BitMinimum( m_controlRef , v ) ;
949 }
950
951 void wxMacControl::SetMaximum( SInt32 v )
952 {
953 ::SetControl32BitMaximum( m_controlRef , v ) ;
954 }
955
956 void wxMacControl::SetValueAndRange( SInt32 value , SInt32 minimum , SInt32 maximum )
957 {
958 ::SetControl32BitMinimum( m_controlRef , minimum ) ;
959 ::SetControl32BitMaximum( m_controlRef , maximum ) ;
960 ::SetControl32BitValue( m_controlRef , value ) ;
961 }
962
963 OSStatus wxMacControl::SetFocus( ControlFocusPart focusPart )
964 {
965 return SetKeyboardFocus( GetControlOwner( m_controlRef ) ,
966 m_controlRef , focusPart ) ;
967 }
968
969 bool wxMacControl::HasFocus() const
970 {
971 ControlRef control ;
972 GetKeyboardFocus( GetUserFocusWindow() , &control ) ;
973 return control == m_controlRef ;
974 }
975
976 void wxMacControl::SetNeedsFocusRect( bool needs )
977 {
978 m_needsFocusRect = needs ;
979 }
980
981 bool wxMacControl::NeedsFocusRect() const
982 {
983 return m_needsFocusRect ;
984 }
985
986 void wxMacControl::VisibilityChanged(bool shown)
987 {
988 }
989
990 void wxMacControl::SuperChangedPosition()
991 {
992 }
993
994 void wxMacControl::SetFont( const wxFont & font , const wxColour& foreground , long windowStyle )
995 {
996 m_font = font ;
997 ControlFontStyleRec fontStyle;
998 if ( font.MacGetThemeFontID() != kThemeCurrentPortFont )
999 {
1000 switch( font.MacGetThemeFontID() )
1001 {
1002 case kThemeSmallSystemFont : fontStyle.font = kControlFontSmallSystemFont ; break ;
1003 case 109 /*mini font */ : fontStyle.font = -5 ; break ;
1004 case kThemeSystemFont : fontStyle.font = kControlFontBigSystemFont ; break ;
1005 default : fontStyle.font = kControlFontBigSystemFont ; break ;
1006 }
1007 fontStyle.flags = kControlUseFontMask ;
1008 }
1009 else
1010 {
1011 fontStyle.font = font.MacGetFontNum() ;
1012 fontStyle.style = font.MacGetFontStyle() ;
1013 fontStyle.size = font.MacGetFontSize() ;
1014 fontStyle.flags = kControlUseFontMask | kControlUseFaceMask | kControlUseSizeMask ;
1015 }
1016
1017 fontStyle.just = teJustLeft ;
1018 fontStyle.flags |= kControlUseJustMask ;
1019 if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_CENTER_HORIZONTAL )
1020 fontStyle.just = teJustCenter ;
1021 else if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_RIGHT )
1022 fontStyle.just = teJustRight ;
1023
1024
1025 // we only should do this in case of a non-standard color, as otherwise 'disabled' controls
1026 // won't get grayed out by the system anymore
1027
1028 if ( foreground != *wxBLACK )
1029 {
1030 fontStyle.foreColor = MAC_WXCOLORREF(foreground.GetPixel() ) ;
1031 fontStyle.flags |= kControlUseForeColorMask ;
1032 }
1033
1034 ::SetControlFontStyle( m_controlRef , &fontStyle );
1035 }
1036
1037 void wxMacControl::SetBackground( const wxBrush &WXUNUSED(brush) )
1038 {
1039 // TODO
1040 // setting up a color proc is not recommended anymore
1041 }
1042
1043 void wxMacControl::SetRange( SInt32 minimum , SInt32 maximum )
1044 {
1045 ::SetControl32BitMinimum( m_controlRef , minimum ) ;
1046 ::SetControl32BitMaximum( m_controlRef , maximum ) ;
1047 }
1048
1049 short wxMacControl::HandleKey( SInt16 keyCode, SInt16 charCode, EventModifiers modifiers )
1050 {
1051 return HandleControlKey( m_controlRef , keyCode , charCode , modifiers ) ;
1052 }
1053
1054 void wxMacControl::SetActionProc( ControlActionUPP actionProc )
1055 {
1056 SetControlAction( m_controlRef , actionProc ) ;
1057 }
1058
1059 void wxMacControl::SetViewSize( SInt32 viewSize )
1060 {
1061 SetControlViewSize(m_controlRef , viewSize ) ;
1062 }
1063
1064 SInt32 wxMacControl::GetViewSize() const
1065 {
1066 return GetControlViewSize( m_controlRef ) ;
1067 }
1068
1069 bool wxMacControl::IsVisible() const
1070 {
1071 return IsControlVisible( m_controlRef ) ;
1072 }
1073
1074 void wxMacControl::SetVisibility( bool visible , bool redraw )
1075 {
1076 SetControlVisibility( m_controlRef , visible , redraw ) ;
1077 }
1078
1079 bool wxMacControl::IsEnabled() const
1080 {
1081 #if TARGET_API_MAC_OSX
1082 return IsControlEnabled( m_controlRef ) ;
1083 #else
1084 return IsControlActive( m_controlRef ) ;
1085 #endif
1086 }
1087
1088 bool wxMacControl::IsActive() const
1089 {
1090 return IsControlActive( m_controlRef ) ;
1091 }
1092
1093 void wxMacControl::Enable( bool enable )
1094 {
1095 #if TARGET_API_MAC_OSX
1096 if ( enable )
1097 EnableControl( m_controlRef ) ;
1098 else
1099 DisableControl( m_controlRef ) ;
1100 #else
1101 if ( enable )
1102 ActivateControl( m_controlRef ) ;
1103 else
1104 DeactivateControl( m_controlRef ) ;
1105 #endif
1106 }
1107
1108 void wxMacControl::SetDrawingEnabled( bool enable )
1109 {
1110 #if TARGET_API_MAC_OSX
1111 HIViewSetDrawingEnabled( m_controlRef , enable ) ;
1112 #endif
1113 }
1114
1115 #if TARGET_API_MAC_OSX
1116 bool wxMacControl::GetNeedsDisplay() const
1117 {
1118 #if TARGET_API_MAC_OSX
1119 if ( m_isCompositing )
1120 {
1121 return HIViewGetNeedsDisplay( m_controlRef ) ;
1122 }
1123 else
1124 #endif
1125 {
1126 if ( !IsVisible() )
1127 return false ;
1128
1129 Rect controlBounds ;
1130 GetControlBounds( m_controlRef, &controlBounds ) ;
1131 RgnHandle rgn = NewRgn() ;
1132 GetWindowRegion ( GetControlOwner( m_controlRef ) , kWindowUpdateRgn , rgn ) ;
1133 Boolean intersect = RectInRgn ( &controlBounds , rgn ) ;
1134 DisposeRgn( rgn ) ;
1135 return intersect ;
1136 }
1137
1138 }
1139 #endif
1140
1141 void wxMacControl::SetNeedsDisplay( RgnHandle where )
1142 {
1143 if ( !IsVisible() )
1144 return ;
1145
1146 #if TARGET_API_MAC_OSX
1147 if ( m_isCompositing )
1148 {
1149 HIViewSetNeedsDisplayInRegion( m_controlRef , where , true ) ;
1150 }
1151 else
1152 #endif
1153 {
1154 Rect controlBounds ;
1155 GetControlBounds( m_controlRef, &controlBounds ) ;
1156 RgnHandle update = NewRgn() ;
1157 CopyRgn( where , update ) ;
1158 OffsetRgn( update , controlBounds.left , controlBounds.top ) ;
1159 InvalWindowRgn( GetControlOwner( m_controlRef) , update ) ;
1160 }
1161 }
1162
1163 void wxMacControl::SetNeedsDisplay( Rect* where )
1164 {
1165 if ( !IsVisible() )
1166 return ;
1167
1168 #if TARGET_API_MAC_OSX
1169 if ( m_isCompositing )
1170 {
1171 if ( where != NULL )
1172 {
1173 RgnHandle update = NewRgn() ;
1174 RectRgn( update , where ) ;
1175 HIViewSetNeedsDisplayInRegion( m_controlRef , update , true ) ;
1176 DisposeRgn( update ) ;
1177 }
1178 else
1179 HIViewSetNeedsDisplay( m_controlRef , true ) ;
1180 }
1181 else
1182 #endif
1183 {
1184 Rect controlBounds ;
1185 GetControlBounds( m_controlRef, &controlBounds ) ;
1186 if ( where )
1187 {
1188 Rect whereLocal = *where ;
1189 OffsetRect( &whereLocal , controlBounds.left , controlBounds.top ) ;
1190 SectRect( &controlBounds , &whereLocal, &controlBounds ) ;
1191 }
1192 InvalWindowRect( GetControlOwner( m_controlRef) , &controlBounds ) ;
1193 }
1194 }
1195
1196 void wxMacControl::Convert( wxPoint *pt , wxMacControl *from , wxMacControl *to )
1197 {
1198 #if TARGET_API_MAC_OSX
1199 if ( from->m_peer->MacGetTopLevelWindow()->MacUsesCompositing() )
1200 {
1201 HIPoint hiPoint ;
1202 hiPoint.x = pt->x ;
1203 hiPoint.y = pt->y ;
1204 HIViewConvertPoint( &hiPoint , from->m_controlRef , to->m_controlRef ) ;
1205 pt->x = (int)hiPoint.x ;
1206 pt->y = (int)hiPoint.y ;
1207 }
1208 else
1209 #endif
1210 {
1211 Rect fromRect ;
1212 Rect toRect ;
1213 GetControlBounds( from->m_controlRef , &fromRect ) ;
1214 GetControlBounds( to->m_controlRef , &toRect ) ;
1215 if ( from->m_isRootControl )
1216 fromRect.left = fromRect.top = 0 ;
1217 if ( to->m_isRootControl )
1218 toRect.left = toRect.top = 0 ;
1219
1220 pt->x = pt->x + fromRect.left - toRect.left ;
1221 pt->y = pt->y + fromRect.top - toRect.top ;
1222 }
1223 }
1224
1225 void wxMacControl::SetRect( Rect *r )
1226 {
1227 #if TARGET_API_MAC_OSX
1228 if ( m_isCompositing )
1229 {
1230 //A HIRect is actually a CGRect on OSX - which consists of two structures -
1231 //CGPoint and CGSize, which have two floats each
1232 HIRect hir = { { r->left , r->top }, { r->right - r->left , r->bottom - r->top } } ;
1233 HIViewSetFrame ( m_controlRef , &hir ) ;
1234 // eventuall we might have to do a SetVisibility( false , true ) ;
1235 // before and a SetVisibility( true , true ) ; after
1236 }
1237 else
1238 #endif
1239 {
1240 bool vis = IsVisible() ;
1241 if ( vis )
1242 {
1243 Rect former ;
1244 GetControlBounds( m_controlRef , &former ) ;
1245 InvalWindowRect( GetControlOwner( m_controlRef ) , &former ) ;
1246 }
1247
1248 Rect controlBounds = *r ;
1249
1250 // since the rect passed in is always (even in non-compositing) relative
1251 // to the (native) parent, we have to adjust to window relative here
1252 wxMacControl* parent = m_peer->GetParent()->GetPeer() ;
1253 if( parent->m_isRootControl == false )
1254 {
1255 Rect superRect ;
1256 GetControlBounds( parent->m_controlRef , &superRect ) ;
1257 OffsetRect( &controlBounds , superRect.left , superRect.top ) ;
1258 }
1259
1260 SetControlBounds( m_controlRef , &controlBounds ) ;
1261 if ( vis )
1262 {
1263 InvalWindowRect( GetControlOwner( m_controlRef ) , &controlBounds ) ;
1264 }
1265 }
1266 }
1267
1268 void wxMacControl::GetRect( Rect *r )
1269 {
1270 GetControlBounds( m_controlRef , r ) ;
1271 if ( m_isCompositing == false )
1272 {
1273 // correct the case of the root control
1274 if ( m_isRootControl )
1275 {
1276 WindowRef wr = GetControlOwner( m_controlRef ) ;
1277 GetWindowBounds( wr , kWindowContentRgn , r ) ;
1278 r->right -= r->left ;
1279 r->bottom -= r->top ;
1280 r->left = 0 ;
1281 r->top = 0 ;
1282 }
1283 else
1284 {
1285 wxMacControl* parent = m_peer->GetParent()->GetPeer() ;
1286 if( parent->m_isRootControl == false )
1287 {
1288 Rect superRect ;
1289 GetControlBounds( parent->m_controlRef , &superRect ) ;
1290 OffsetRect( r , -superRect.left , -superRect.top ) ;
1291 }
1292 }
1293 }
1294 }
1295
1296 void wxMacControl::GetRectInWindowCoords( Rect *r )
1297 {
1298 UMAGetControlBoundsInWindowCoords( m_controlRef , r ) ;
1299 }
1300
1301 void wxMacControl::GetBestRect( Rect *r )
1302 {
1303 short baselineoffset ;
1304 GetBestControlRect( m_controlRef , r , &baselineoffset ) ;
1305 }
1306
1307 void wxMacControl::SetLabel( const wxString &title )
1308 {
1309 wxFontEncoding encoding;
1310
1311 if ( m_font.Ok() )
1312 encoding = m_font.GetEncoding();
1313 else
1314 encoding = wxFont::GetDefaultEncoding();
1315
1316 UMASetControlTitle( m_controlRef , title , encoding ) ;
1317 }
1318
1319 void wxMacControl::GetFeatures( UInt32 * features )
1320 {
1321 GetControlFeatures( m_controlRef , features ) ;
1322 }
1323
1324 OSStatus wxMacControl::GetRegion( ControlPartCode partCode , RgnHandle region )
1325 {
1326 OSStatus err = GetControlRegion( m_controlRef , partCode , region ) ;
1327 if ( m_isCompositing == false )
1328 {
1329 if ( !m_isRootControl )
1330 {
1331 Rect r ;
1332 GetControlBounds(m_controlRef, &r ) ;
1333 if ( !EmptyRgn( region ) )
1334 OffsetRgn( region , -r.left , -r.top ) ;
1335 }
1336 }
1337 return err ;
1338 }
1339
1340 OSStatus wxMacControl::SetZOrder( bool above , wxMacControl* other )
1341 {
1342 #if TARGET_API_MAC_OSX
1343 return HIViewSetZOrder( m_controlRef,above ? kHIViewZOrderAbove : kHIViewZOrderBelow,
1344 (other != NULL) ? other->m_controlRef : NULL) ;
1345 #else
1346 return 0 ;
1347 #endif
1348 }
1349
1350
1351 #if TARGET_API_MAC_OSX
1352 // SetNeedsDisplay would not invalidate the children
1353 static void InvalidateControlAndChildren( HIViewRef control )
1354 {
1355 HIViewSetNeedsDisplay( control , true ) ;
1356 UInt16 childrenCount = 0 ;
1357 OSStatus err = CountSubControls( control , &childrenCount ) ;
1358 if ( err == errControlIsNotEmbedder )
1359 return ;
1360 wxASSERT_MSG( err == noErr , wxT("Unexpected error when accessing subcontrols") ) ;
1361
1362 for ( UInt16 i = childrenCount ; i >=1 ; --i )
1363 {
1364 HIViewRef child ;
1365 err = GetIndexedSubControl( control , i , & child ) ;
1366 if ( err == errControlIsNotEmbedder )
1367 return ;
1368 InvalidateControlAndChildren( child ) ;
1369 }
1370 }
1371 #endif
1372
1373 void wxMacControl::InvalidateWithChildren()
1374 {
1375 #if TARGET_API_MAC_OSX
1376 InvalidateControlAndChildren( m_controlRef ) ;
1377 #endif
1378 }
1379
1380 void wxMacControl::ScrollRect( wxRect *r , int dx , int dy )
1381 {
1382 wxASSERT( r != NULL ) ;
1383 #if TARGET_API_MAC_OSX
1384 if ( m_isCompositing )
1385 {
1386 HIRect scrollarea = CGRectMake( r->x , r->y , r->width , r->height) ;
1387 HIViewScrollRect ( m_controlRef , &scrollarea , dx ,dy ) ;
1388 }
1389 else
1390 #endif
1391 {
1392 Rect bounds ;
1393 GetControlBounds( m_controlRef , &bounds ) ;
1394 bounds.left += r->x ;
1395 bounds.top += r->y ;
1396 bounds.bottom = bounds.top + r->height ;
1397 bounds.right = bounds.left + r->width ;
1398 wxMacWindowClipper clip( m_peer ) ;
1399 RgnHandle updateRgn = NewRgn() ;
1400 ::ScrollRect( &bounds , dx , dy , updateRgn ) ;
1401 InvalWindowRgn( GetControlOwner( m_controlRef ) , updateRgn ) ;
1402 }
1403 }
1404
1405
1406 // SetNeedsDisplay would not invalidate the children
1407
1408 //
1409 // Databrowser
1410 //
1411
1412 OSStatus wxMacControl::SetSelectionFlags( DataBrowserSelectionFlags options )
1413 {
1414 return SetDataBrowserSelectionFlags( m_controlRef , options ) ;
1415 }
1416
1417 OSStatus wxMacControl::AddListViewColumn( DataBrowserListViewColumnDesc *columnDesc,
1418 DataBrowserTableViewColumnIndex position )
1419 {
1420 return AddDataBrowserListViewColumn( m_controlRef , columnDesc, position ) ;
1421 }
1422
1423 OSStatus wxMacControl::AutoSizeListViewColumns()
1424 {
1425 return AutoSizeDataBrowserListViewColumns(m_controlRef) ;
1426 }
1427
1428 OSStatus wxMacControl::SetHasScrollBars( bool horiz , bool vert )
1429 {
1430 return SetDataBrowserHasScrollBars( m_controlRef , horiz , vert ) ;
1431 }
1432
1433 OSStatus wxMacControl::SetTableViewHiliteStyle( DataBrowserTableViewHiliteStyle hiliteStyle )
1434 {
1435 return SetDataBrowserTableViewHiliteStyle( m_controlRef , hiliteStyle ) ;
1436 }
1437
1438 OSStatus wxMacControl::SetListViewHeaderBtnHeight(UInt16 height)
1439 {
1440 return SetDataBrowserListViewHeaderBtnHeight( m_controlRef ,height ) ;
1441 }
1442
1443 OSStatus wxMacControl::SetCallbacks(const DataBrowserCallbacks * callbacks)
1444 {
1445 return SetDataBrowserCallbacks( m_controlRef , callbacks ) ;
1446 }
1447
1448 OSStatus wxMacControl::UpdateItems( DataBrowserItemID container, UInt32 numItems,
1449 const DataBrowserItemID* items,
1450 DataBrowserPropertyID preSortProperty,
1451 DataBrowserPropertyID propertyID )
1452 {
1453 return UpdateDataBrowserItems( m_controlRef , container, numItems, items, preSortProperty, propertyID ) ;
1454 }
1455
1456 bool wxMacControl::IsItemSelected( DataBrowserItemID item )
1457 {
1458 return IsDataBrowserItemSelected( m_controlRef , item ) ;
1459 }
1460
1461 OSStatus wxMacControl::AddItems( DataBrowserItemID container, UInt32 numItems,
1462 const DataBrowserItemID* items,
1463 DataBrowserPropertyID preSortProperty )
1464 {
1465 return AddDataBrowserItems( m_controlRef , container, numItems, items, preSortProperty ) ;
1466 }
1467
1468 OSStatus wxMacControl::RemoveItems( DataBrowserItemID container, UInt32 numItems,
1469 const DataBrowserItemID* items,
1470 DataBrowserPropertyID preSortProperty )
1471 {
1472 return RemoveDataBrowserItems( m_controlRef , container, numItems, items, preSortProperty ) ;
1473 }
1474
1475 OSStatus wxMacControl::RevealItem( DataBrowserItemID item,
1476 DataBrowserPropertyID propertyID,
1477 DataBrowserRevealOptions options )
1478 {
1479 return RevealDataBrowserItem( m_controlRef , item , propertyID , options ) ;
1480 }
1481
1482 OSStatus wxMacControl::SetSelectedItems(UInt32 numItems,
1483 const DataBrowserItemID * items,
1484 DataBrowserSetOption operation )
1485 {
1486 return SetDataBrowserSelectedItems( m_controlRef , numItems , items, operation ) ;
1487 }
1488
1489 OSStatus wxMacControl::GetSelectionAnchor( DataBrowserItemID * first, DataBrowserItemID * last )
1490 {
1491 return GetDataBrowserSelectionAnchor( m_controlRef , first , last ) ;
1492 }
1493
1494 //
1495 // Tab Control
1496 //
1497
1498 OSStatus wxMacControl::SetTabEnabled( SInt16 tabNo , bool enable )
1499 {
1500 return ::SetTabEnabled( m_controlRef , tabNo , enable ) ;
1501 }
1502
1503 //
1504 // Quartz Support
1505 //
1506
1507 #ifdef __WXMAC_OSX__
1508 // snippets from Sketch Sample from Apple :
1509
1510 #define kGenericRGBProfilePathStr "/System/Library/ColorSync/Profiles/Generic RGB Profile.icc"
1511 /*
1512 This function locates, opens, and returns the profile reference for the calibrated
1513 Generic RGB color space. It is up to the caller to call CMCloseProfile when done
1514 with the profile reference this function returns.
1515 */
1516 CMProfileRef wxMacOpenGenericProfile(void)
1517 {
1518 static CMProfileRef cachedRGBProfileRef = NULL;
1519
1520 // we only create the profile reference once
1521 if (cachedRGBProfileRef == NULL)
1522 {
1523 CMProfileLocation loc;
1524
1525 loc.locType = cmPathBasedProfile;
1526 strcpy(loc.u.pathLoc.path, kGenericRGBProfilePathStr);
1527
1528 verify_noerr( CMOpenProfile(&cachedRGBProfileRef, &loc) );
1529 }
1530
1531 if (cachedRGBProfileRef)
1532 {
1533 // clone the profile reference so that the caller has their own reference, not our cached one
1534 CMCloneProfileRef(cachedRGBProfileRef);
1535 }
1536
1537 return cachedRGBProfileRef;
1538 }
1539
1540 /*
1541 Return the generic RGB color space. This is a 'get' function and the caller should
1542 not release the returned value unless the caller retains it first. Usually callers
1543 of this routine will immediately use the returned colorspace with CoreGraphics
1544 so they typically do not need to retain it themselves.
1545
1546 This function creates the generic RGB color space once and hangs onto it so it can
1547 return it whenever this function is called.
1548 */
1549
1550 #if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_4
1551 #define kCGColorSpaceGenericRGB CFSTR("kCGColorSpaceGenericRGB")
1552 #endif
1553
1554 CGColorSpaceRef wxMacGetGenericRGBColorSpace()
1555 {
1556 static wxMacCFRefHolder<CGColorSpaceRef> genericRGBColorSpace ;
1557
1558 if (genericRGBColorSpace == NULL)
1559 {
1560 if ( UMAGetSystemVersion() >= 0x1040 )
1561 {
1562 genericRGBColorSpace.Set( CGColorSpaceCreateWithName( kCGColorSpaceGenericRGB ) ) ;
1563 }
1564 else
1565 {
1566 CMProfileRef genericRGBProfile = wxMacOpenGenericProfile();
1567
1568 if (genericRGBProfile)
1569 {
1570 genericRGBColorSpace.Set( CGColorSpaceCreateWithPlatformColorSpace(genericRGBProfile) ) ;
1571 wxASSERT_MSG( genericRGBColorSpace != NULL, wxT("couldn't create the generic RGB color space") ) ;
1572
1573 // we opened the profile so it is up to us to close it
1574 CMCloseProfile(genericRGBProfile);
1575 }
1576 }
1577 }
1578 return genericRGBColorSpace;
1579 }
1580 #endif
1581
1582 #endif // wxUSE_GUI