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