]> git.saurik.com Git - wxWidgets.git/blob - src/mac/carbon/utils.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
wx..._EX_METAL styles support
[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 static wxMacCarbonEvent s_wakeupEvent ;
739 OSStatus err = noErr ;
740 if ( !s_wakeupEvent.IsValid() )
741 {
742 err = s_wakeupEvent.Create( 'WXMC', 'WXMC', GetCurrentEventTime(),
743 kEventAttributeNone ) ;
744 }
745 if ( err == noErr )
746 {
747 if ( IsEventInQueue( GetMainEventQueue() , s_wakeupEvent ) )
748 return ;
749 s_wakeupEvent.SetCurrentTime() ;
750 err = PostEventToQueue(GetMainEventQueue(), s_wakeupEvent,
751 kEventPriorityHigh);
752 }
753 #else
754 PostEvent( nullEvent , 0 ) ;
755 #endif
756 }
757 else
758 {
759 WakeUpProcess( &gAppProcess ) ;
760 }
761 }
762
763 #endif // wxUSE_BASE
764
765 #if wxUSE_GUI
766
767 // ----------------------------------------------------------------------------
768 // Native Struct Conversions
769 // ----------------------------------------------------------------------------
770
771
772 void wxMacRectToNative( const wxRect *wx , Rect *n )
773 {
774 n->left = wx->x ;
775 n->top = wx->y ;
776 n->right = wx->x + wx->width ;
777 n->bottom = wx->y + wx->height ;
778 }
779
780 void wxMacNativeToRect( const Rect *n , wxRect* wx )
781 {
782 wx->x = n->left ;
783 wx->y = n->top ;
784 wx->width = n->right - n->left ;
785 wx->height = n->bottom - n->top ;
786 }
787
788 void wxMacPointToNative( const wxPoint* wx , Point *n )
789 {
790 n->h = wx->x ;
791 n->v = wx->y ;
792 }
793
794 void wxMacNativeToPoint( const Point *n , wxPoint* wx )
795 {
796 wx->x = n->h ;
797 wx->y = n->v ;
798 }
799
800 // ----------------------------------------------------------------------------
801 // Carbon Event Support
802 // ----------------------------------------------------------------------------
803
804
805 OSStatus wxMacCarbonEvent::GetParameter(EventParamName inName, EventParamType inDesiredType, UInt32 inBufferSize, void * outData)
806 {
807 return ::GetEventParameter( m_eventRef , inName , inDesiredType , NULL , inBufferSize , NULL , outData ) ;
808 }
809
810 OSStatus wxMacCarbonEvent::SetParameter(EventParamName inName, EventParamType inType, UInt32 inBufferSize, const void * inData)
811 {
812 return ::SetEventParameter( m_eventRef , inName , inType , inBufferSize , inData ) ;
813 }
814
815 // ----------------------------------------------------------------------------
816 // Control Access Support
817 // ----------------------------------------------------------------------------
818
819 wxMacControl::wxMacControl(wxWindow* peer , bool isRootControl )
820 {
821 Init() ;
822 m_peer = peer ;
823 m_isRootControl = isRootControl ;
824 m_isCompositing = peer->MacGetTopLevelWindow()->MacUsesCompositing() ;
825 }
826
827 wxMacControl::wxMacControl( wxWindow* peer , ControlRef control )
828 {
829 Init() ;
830 m_peer = peer ;
831 m_isCompositing = peer->MacGetTopLevelWindow()->MacUsesCompositing() ;
832 m_controlRef = control ;
833 }
834
835 wxMacControl::wxMacControl( wxWindow* peer , WXWidget control )
836 {
837 Init() ;
838 m_peer = peer ;
839 m_isCompositing = peer->MacGetTopLevelWindow()->MacUsesCompositing() ;
840 m_controlRef = (ControlRef) control ;
841 }
842
843 wxMacControl::~wxMacControl()
844 {
845 }
846
847 void wxMacControl::Init()
848 {
849 m_peer = NULL ;
850 m_controlRef = NULL ;
851 m_needsFocusRect = false ;
852 m_isCompositing = false ;
853 m_isRootControl = false ;
854 }
855
856 void wxMacControl::Dispose()
857 {
858 ::DisposeControl( m_controlRef ) ;
859 m_controlRef = NULL ;
860 }
861
862 void wxMacControl::SetReference( SInt32 data )
863 {
864 SetControlReference( m_controlRef , data ) ;
865 }
866
867 OSStatus wxMacControl::GetData(ControlPartCode inPartCode , ResType inTag , Size inBufferSize , void * inOutBuffer , Size * outActualSize ) const
868 {
869 return ::GetControlData( m_controlRef , inPartCode , inTag , inBufferSize , inOutBuffer , outActualSize ) ;
870 }
871
872 OSStatus wxMacControl::GetDataSize(ControlPartCode inPartCode , ResType inTag , Size * outActualSize ) const
873 {
874 return ::GetControlDataSize( m_controlRef , inPartCode , inTag , outActualSize ) ;
875 }
876
877 OSStatus wxMacControl::SetData(ControlPartCode inPartCode , ResType inTag , Size inSize , const void * inData)
878 {
879 return ::SetControlData( m_controlRef , inPartCode , inTag , inSize , inData ) ;
880 }
881
882 OSStatus wxMacControl::SendEvent( EventRef event , OptionBits inOptions )
883 {
884 #if TARGET_API_MAC_OSX
885 return SendEventToEventTargetWithOptions( event,
886 HIObjectGetEventTarget( (HIObjectRef) m_controlRef ), inOptions );
887 #else
888 #pragma unused(inOptions)
889 return SendEventToEventTarget(event,GetControlEventTarget( m_controlRef ) ) ;
890 #endif
891 }
892
893 OSStatus wxMacControl::SendHICommand( HICommand &command , OptionBits inOptions )
894 {
895 wxMacCarbonEvent event( kEventClassCommand , kEventCommandProcess ) ;
896 event.SetParameter<HICommand>(kEventParamDirectObject,command) ;
897 return SendEvent( event , inOptions ) ;
898 }
899
900 OSStatus wxMacControl::SendHICommand( UInt32 commandID , OptionBits inOptions )
901 {
902 HICommand command ;
903 memset( &command, 0 , sizeof(command) ) ;
904 command.commandID = commandID ;
905 return SendHICommand( command , inOptions ) ;
906 }
907
908 void wxMacControl::Flash( ControlPartCode part , UInt32 ticks )
909 {
910 HiliteControl( m_controlRef , part ) ;
911 unsigned long finalTicks ;
912 Delay( ticks , &finalTicks ) ;
913 HiliteControl( m_controlRef , kControlNoPart ) ;
914 }
915
916 SInt32 wxMacControl::GetValue() const
917 {
918 return ::GetControl32BitValue( m_controlRef ) ;
919 }
920
921 SInt32 wxMacControl::GetMaximum() const
922 {
923 return ::GetControl32BitMaximum( m_controlRef ) ;
924 }
925
926 SInt32 wxMacControl::GetMinimum() const
927 {
928 return ::GetControl32BitMinimum( m_controlRef ) ;
929 }
930
931 void wxMacControl::SetValue( SInt32 v )
932 {
933 ::SetControl32BitValue( m_controlRef , v ) ;
934 }
935
936 void wxMacControl::SetMinimum( SInt32 v )
937 {
938 ::SetControl32BitMinimum( m_controlRef , v ) ;
939 }
940
941 void wxMacControl::SetMaximum( SInt32 v )
942 {
943 ::SetControl32BitMaximum( m_controlRef , v ) ;
944 }
945
946 void wxMacControl::SetValueAndRange( SInt32 value , SInt32 minimum , SInt32 maximum )
947 {
948 ::SetControl32BitMinimum( m_controlRef , minimum ) ;
949 ::SetControl32BitMaximum( m_controlRef , maximum ) ;
950 ::SetControl32BitValue( m_controlRef , value ) ;
951 }
952
953 OSStatus wxMacControl::SetFocus( ControlFocusPart focusPart )
954 {
955 return SetKeyboardFocus( GetControlOwner( m_controlRef ) ,
956 m_controlRef , focusPart ) ;
957 }
958
959 bool wxMacControl::HasFocus() const
960 {
961 ControlRef control ;
962 GetKeyboardFocus( GetUserFocusWindow() , &control ) ;
963 return control == m_controlRef ;
964 }
965
966 void wxMacControl::SetNeedsFocusRect( bool needs )
967 {
968 m_needsFocusRect = needs ;
969 }
970
971 bool wxMacControl::NeedsFocusRect() const
972 {
973 return m_needsFocusRect ;
974 }
975
976 void wxMacControl::VisibilityChanged(bool shown)
977 {
978 }
979
980 void wxMacControl::SuperChangedPosition()
981 {
982 }
983
984 void wxMacControl::SetFont( const wxFont & font , const wxColour& foreground , long windowStyle )
985 {
986 m_font = font ;
987 ControlFontStyleRec fontStyle;
988 if ( font.MacGetThemeFontID() != kThemeCurrentPortFont )
989 {
990 switch( font.MacGetThemeFontID() )
991 {
992 case kThemeSmallSystemFont : fontStyle.font = kControlFontSmallSystemFont ; break ;
993 case 109 /*mini font */ : fontStyle.font = -5 ; break ;
994 case kThemeSystemFont : fontStyle.font = kControlFontBigSystemFont ; break ;
995 default : fontStyle.font = kControlFontBigSystemFont ; break ;
996 }
997 fontStyle.flags = kControlUseFontMask ;
998 }
999 else
1000 {
1001 fontStyle.font = font.MacGetFontNum() ;
1002 fontStyle.style = font.MacGetFontStyle() ;
1003 fontStyle.size = font.MacGetFontSize() ;
1004 fontStyle.flags = kControlUseFontMask | kControlUseFaceMask | kControlUseSizeMask ;
1005 }
1006
1007 fontStyle.just = teJustLeft ;
1008 fontStyle.flags |= kControlUseJustMask ;
1009 if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_CENTER_HORIZONTAL )
1010 fontStyle.just = teJustCenter ;
1011 else if ( ( windowStyle & wxALIGN_MASK ) & wxALIGN_RIGHT )
1012 fontStyle.just = teJustRight ;
1013
1014
1015 // we only should do this in case of a non-standard color, as otherwise 'disabled' controls
1016 // won't get grayed out by the system anymore
1017
1018 if ( foreground != *wxBLACK )
1019 {
1020 fontStyle.foreColor = MAC_WXCOLORREF(foreground.GetPixel() ) ;
1021 fontStyle.flags |= kControlUseForeColorMask ;
1022 }
1023
1024 ::SetControlFontStyle( m_controlRef , &fontStyle );
1025 }
1026
1027 void wxMacControl::SetBackground( const wxBrush &WXUNUSED(brush) )
1028 {
1029 // TODO
1030 // setting up a color proc is not recommended anymore
1031 }
1032
1033 void wxMacControl::SetRange( SInt32 minimum , SInt32 maximum )
1034 {
1035 ::SetControl32BitMinimum( m_controlRef , minimum ) ;
1036 ::SetControl32BitMaximum( m_controlRef , maximum ) ;
1037 }
1038
1039 short wxMacControl::HandleKey( SInt16 keyCode, SInt16 charCode, EventModifiers modifiers )
1040 {
1041 return HandleControlKey( m_controlRef , keyCode , charCode , modifiers ) ;
1042 }
1043
1044 void wxMacControl::SetActionProc( ControlActionUPP actionProc )
1045 {
1046 SetControlAction( m_controlRef , actionProc ) ;
1047 }
1048
1049 void wxMacControl::SetViewSize( SInt32 viewSize )
1050 {
1051 SetControlViewSize(m_controlRef , viewSize ) ;
1052 }
1053
1054 SInt32 wxMacControl::GetViewSize() const
1055 {
1056 return GetControlViewSize( m_controlRef ) ;
1057 }
1058
1059 bool wxMacControl::IsVisible() const
1060 {
1061 return IsControlVisible( m_controlRef ) ;
1062 }
1063
1064 void wxMacControl::SetVisibility( bool visible , bool redraw )
1065 {
1066 SetControlVisibility( m_controlRef , visible , redraw ) ;
1067 }
1068
1069 bool wxMacControl::IsEnabled() const
1070 {
1071 #if TARGET_API_MAC_OSX
1072 return IsControlEnabled( m_controlRef ) ;
1073 #else
1074 return IsControlActive( m_controlRef ) ;
1075 #endif
1076 }
1077
1078 bool wxMacControl::IsActive() const
1079 {
1080 return IsControlActive( m_controlRef ) ;
1081 }
1082
1083 void wxMacControl::Enable( bool enable )
1084 {
1085 #if TARGET_API_MAC_OSX
1086 if ( enable )
1087 EnableControl( m_controlRef ) ;
1088 else
1089 DisableControl( m_controlRef ) ;
1090 #else
1091 if ( enable )
1092 ActivateControl( m_controlRef ) ;
1093 else
1094 DeactivateControl( m_controlRef ) ;
1095 #endif
1096 }
1097
1098 void wxMacControl::SetDrawingEnabled( bool enable )
1099 {
1100 #if TARGET_API_MAC_OSX
1101 HIViewSetDrawingEnabled( m_controlRef , enable ) ;
1102 #endif
1103 }
1104
1105 #if TARGET_API_MAC_OSX
1106 bool wxMacControl::GetNeedsDisplay() const
1107 {
1108 #if TARGET_API_MAC_OSX
1109 if ( m_isCompositing )
1110 {
1111 return HIViewGetNeedsDisplay( m_controlRef ) ;
1112 }
1113 else
1114 #endif
1115 {
1116 if ( !IsVisible() )
1117 return false ;
1118
1119 Rect controlBounds ;
1120 GetControlBounds( m_controlRef, &controlBounds ) ;
1121 RgnHandle rgn = NewRgn() ;
1122 GetWindowRegion ( GetControlOwner( m_controlRef ) , kWindowUpdateRgn , rgn ) ;
1123 Boolean intersect = RectInRgn ( &controlBounds , rgn ) ;
1124 DisposeRgn( rgn ) ;
1125 return intersect ;
1126 }
1127
1128 }
1129 #endif
1130
1131 void wxMacControl::SetNeedsDisplay( RgnHandle where )
1132 {
1133 if ( !IsVisible() )
1134 return ;
1135
1136 #if TARGET_API_MAC_OSX
1137 if ( m_isCompositing )
1138 {
1139 HIViewSetNeedsDisplayInRegion( m_controlRef , where , true ) ;
1140 }
1141 else
1142 #endif
1143 {
1144 Rect controlBounds ;
1145 GetControlBounds( m_controlRef, &controlBounds ) ;
1146 RgnHandle update = NewRgn() ;
1147 CopyRgn( where , update ) ;
1148 OffsetRgn( update , controlBounds.left , controlBounds.top ) ;
1149 InvalWindowRgn( GetControlOwner( m_controlRef) , update ) ;
1150 }
1151 }
1152
1153 void wxMacControl::SetNeedsDisplay( Rect* where )
1154 {
1155 if ( !IsVisible() )
1156 return ;
1157
1158 #if TARGET_API_MAC_OSX
1159 if ( m_isCompositing )
1160 {
1161 if ( where != NULL )
1162 {
1163 RgnHandle update = NewRgn() ;
1164 RectRgn( update , where ) ;
1165 HIViewSetNeedsDisplayInRegion( m_controlRef , update , true ) ;
1166 DisposeRgn( update ) ;
1167 }
1168 else
1169 HIViewSetNeedsDisplay( m_controlRef , true ) ;
1170 }
1171 else
1172 #endif
1173 {
1174 Rect controlBounds ;
1175 GetControlBounds( m_controlRef, &controlBounds ) ;
1176 if ( where )
1177 {
1178 Rect whereLocal = *where ;
1179 OffsetRect( &whereLocal , controlBounds.left , controlBounds.top ) ;
1180 SectRect( &controlBounds , &whereLocal, &controlBounds ) ;
1181 }
1182 InvalWindowRect( GetControlOwner( m_controlRef) , &controlBounds ) ;
1183 }
1184 }
1185
1186 void wxMacControl::Convert( wxPoint *pt , wxMacControl *from , wxMacControl *to )
1187 {
1188 #if TARGET_API_MAC_OSX
1189 if ( from->m_peer->MacGetTopLevelWindow()->MacUsesCompositing() )
1190 {
1191 HIPoint hiPoint ;
1192 hiPoint.x = pt->x ;
1193 hiPoint.y = pt->y ;
1194 HIViewConvertPoint( &hiPoint , from->m_controlRef , to->m_controlRef ) ;
1195 pt->x = (int)hiPoint.x ;
1196 pt->y = (int)hiPoint.y ;
1197 }
1198 else
1199 #endif
1200 {
1201 Rect fromRect ;
1202 Rect toRect ;
1203 GetControlBounds( from->m_controlRef , &fromRect ) ;
1204 GetControlBounds( to->m_controlRef , &toRect ) ;
1205 if ( from->m_isRootControl )
1206 fromRect.left = fromRect.top = 0 ;
1207 if ( to->m_isRootControl )
1208 toRect.left = toRect.top = 0 ;
1209
1210 pt->x = pt->x + fromRect.left - toRect.left ;
1211 pt->y = pt->y + fromRect.top - toRect.top ;
1212 }
1213 }
1214
1215 void wxMacControl::SetRect( Rect *r )
1216 {
1217 #if TARGET_API_MAC_OSX
1218 if ( m_isCompositing )
1219 {
1220 //A HIRect is actually a CGRect on OSX - which consists of two structures -
1221 //CGPoint and CGSize, which have two floats each
1222 HIRect hir = { { r->left , r->top }, { r->right - r->left , r->bottom - r->top } } ;
1223 HIViewSetFrame ( m_controlRef , &hir ) ;
1224 // eventuall we might have to do a SetVisibility( false , true ) ;
1225 // before and a SetVisibility( true , true ) ; after
1226 }
1227 else
1228 #endif
1229 {
1230 bool vis = IsVisible() ;
1231 if ( vis )
1232 {
1233 Rect former ;
1234 GetControlBounds( m_controlRef , &former ) ;
1235 InvalWindowRect( GetControlOwner( m_controlRef ) , &former ) ;
1236 }
1237
1238 Rect controlBounds = *r ;
1239
1240 // since the rect passed in is always (even in non-compositing) relative
1241 // to the (native) parent, we have to adjust to window relative here
1242 wxMacControl* parent = m_peer->GetParent()->GetPeer() ;
1243 if( parent->m_isRootControl == false )
1244 {
1245 Rect superRect ;
1246 GetControlBounds( parent->m_controlRef , &superRect ) ;
1247 OffsetRect( &controlBounds , superRect.left , superRect.top ) ;
1248 }
1249
1250 SetControlBounds( m_controlRef , &controlBounds ) ;
1251 if ( vis )
1252 {
1253 InvalWindowRect( GetControlOwner( m_controlRef ) , &controlBounds ) ;
1254 }
1255 }
1256 }
1257
1258 void wxMacControl::GetRect( Rect *r )
1259 {
1260 GetControlBounds( m_controlRef , r ) ;
1261 if ( m_isCompositing == false )
1262 {
1263 // correct the case of the root control
1264 if ( m_isRootControl )
1265 {
1266 WindowRef wr = GetControlOwner( m_controlRef ) ;
1267 GetWindowBounds( wr , kWindowContentRgn , r ) ;
1268 r->right -= r->left ;
1269 r->bottom -= r->top ;
1270 r->left = 0 ;
1271 r->top = 0 ;
1272 }
1273 else
1274 {
1275 wxMacControl* parent = m_peer->GetParent()->GetPeer() ;
1276 if( parent->m_isRootControl == false )
1277 {
1278 Rect superRect ;
1279 GetControlBounds( parent->m_controlRef , &superRect ) ;
1280 OffsetRect( r , -superRect.left , -superRect.top ) ;
1281 }
1282 }
1283 }
1284 }
1285
1286 void wxMacControl::GetRectInWindowCoords( Rect *r )
1287 {
1288 UMAGetControlBoundsInWindowCoords( m_controlRef , r ) ;
1289 }
1290
1291 void wxMacControl::GetBestRect( Rect *r )
1292 {
1293 short baselineoffset ;
1294 GetBestControlRect( m_controlRef , r , &baselineoffset ) ;
1295 }
1296
1297 void wxMacControl::SetLabel( const wxString &title )
1298 {
1299 wxFontEncoding encoding;
1300
1301 if ( m_font.Ok() )
1302 encoding = m_font.GetEncoding();
1303 else
1304 encoding = wxFont::GetDefaultEncoding();
1305
1306 UMASetControlTitle( m_controlRef , title , encoding ) ;
1307 }
1308
1309 void wxMacControl::GetFeatures( UInt32 * features )
1310 {
1311 GetControlFeatures( m_controlRef , features ) ;
1312 }
1313
1314 OSStatus wxMacControl::GetRegion( ControlPartCode partCode , RgnHandle region )
1315 {
1316 OSStatus err = GetControlRegion( m_controlRef , partCode , region ) ;
1317 if ( m_isCompositing == false )
1318 {
1319 if ( !m_isRootControl )
1320 {
1321 Rect r ;
1322 GetControlBounds(m_controlRef, &r ) ;
1323 if ( !EmptyRgn( region ) )
1324 OffsetRgn( region , -r.left , -r.top ) ;
1325 }
1326 }
1327 return err ;
1328 }
1329
1330 OSStatus wxMacControl::SetZOrder( bool above , wxMacControl* other )
1331 {
1332 #if TARGET_API_MAC_OSX
1333 return HIViewSetZOrder( m_controlRef,above ? kHIViewZOrderAbove : kHIViewZOrderBelow,
1334 (other != NULL) ? other->m_controlRef : NULL) ;
1335 #else
1336 return 0 ;
1337 #endif
1338 }
1339
1340
1341 #if TARGET_API_MAC_OSX
1342 // SetNeedsDisplay would not invalidate the children
1343 static void InvalidateControlAndChildren( HIViewRef control )
1344 {
1345 HIViewSetNeedsDisplay( control , true ) ;
1346 UInt16 childrenCount = 0 ;
1347 OSStatus err = CountSubControls( control , &childrenCount ) ;
1348 if ( err == errControlIsNotEmbedder )
1349 return ;
1350 wxASSERT_MSG( err == noErr , wxT("Unexpected error when accessing subcontrols") ) ;
1351
1352 for ( UInt16 i = childrenCount ; i >=1 ; --i )
1353 {
1354 HIViewRef child ;
1355 err = GetIndexedSubControl( control , i , & child ) ;
1356 if ( err == errControlIsNotEmbedder )
1357 return ;
1358 InvalidateControlAndChildren( child ) ;
1359 }
1360 }
1361 #endif
1362
1363 void wxMacControl::InvalidateWithChildren()
1364 {
1365 #if TARGET_API_MAC_OSX
1366 InvalidateControlAndChildren( m_controlRef ) ;
1367 #endif
1368 }
1369
1370 void wxMacControl::ScrollRect( wxRect *r , int dx , int dy )
1371 {
1372 wxASSERT( r != NULL ) ;
1373 #if TARGET_API_MAC_OSX
1374 if ( m_isCompositing )
1375 {
1376 HIRect scrollarea = CGRectMake( r->x , r->y , r->width , r->height) ;
1377 HIViewScrollRect ( m_controlRef , &scrollarea , dx ,dy ) ;
1378 }
1379 else
1380 #endif
1381 {
1382 Rect bounds ;
1383 GetControlBounds( m_controlRef , &bounds ) ;
1384 bounds.left += r->x ;
1385 bounds.top += r->y ;
1386 bounds.bottom = bounds.top + r->height ;
1387 bounds.right = bounds.left + r->width ;
1388 wxMacWindowClipper clip( m_peer ) ;
1389 RgnHandle updateRgn = NewRgn() ;
1390 ::ScrollRect( &bounds , dx , dy , updateRgn ) ;
1391 InvalWindowRgn( GetControlOwner( m_controlRef ) , updateRgn ) ;
1392 }
1393 }
1394
1395
1396 // SetNeedsDisplay would not invalidate the children
1397
1398 //
1399 // Databrowser
1400 //
1401
1402 OSStatus wxMacControl::SetSelectionFlags( DataBrowserSelectionFlags options )
1403 {
1404 return SetDataBrowserSelectionFlags( m_controlRef , options ) ;
1405 }
1406
1407 OSStatus wxMacControl::AddListViewColumn( DataBrowserListViewColumnDesc *columnDesc,
1408 DataBrowserTableViewColumnIndex position )
1409 {
1410 return AddDataBrowserListViewColumn( m_controlRef , columnDesc, position ) ;
1411 }
1412
1413 OSStatus wxMacControl::AutoSizeListViewColumns()
1414 {
1415 return AutoSizeDataBrowserListViewColumns(m_controlRef) ;
1416 }
1417
1418 OSStatus wxMacControl::SetHasScrollBars( bool horiz , bool vert )
1419 {
1420 return SetDataBrowserHasScrollBars( m_controlRef , horiz , vert ) ;
1421 }
1422
1423 OSStatus wxMacControl::SetTableViewHiliteStyle( DataBrowserTableViewHiliteStyle hiliteStyle )
1424 {
1425 return SetDataBrowserTableViewHiliteStyle( m_controlRef , hiliteStyle ) ;
1426 }
1427
1428 OSStatus wxMacControl::SetListViewHeaderBtnHeight(UInt16 height)
1429 {
1430 return SetDataBrowserListViewHeaderBtnHeight( m_controlRef ,height ) ;
1431 }
1432
1433 OSStatus wxMacControl::SetCallbacks(const DataBrowserCallbacks * callbacks)
1434 {
1435 return SetDataBrowserCallbacks( m_controlRef , callbacks ) ;
1436 }
1437
1438 OSStatus wxMacControl::UpdateItems( DataBrowserItemID container, UInt32 numItems,
1439 const DataBrowserItemID* items,
1440 DataBrowserPropertyID preSortProperty,
1441 DataBrowserPropertyID propertyID )
1442 {
1443 return UpdateDataBrowserItems( m_controlRef , container, numItems, items, preSortProperty, propertyID ) ;
1444 }
1445
1446 bool wxMacControl::IsItemSelected( DataBrowserItemID item )
1447 {
1448 return IsDataBrowserItemSelected( m_controlRef , item ) ;
1449 }
1450
1451 OSStatus wxMacControl::AddItems( DataBrowserItemID container, UInt32 numItems,
1452 const DataBrowserItemID* items,
1453 DataBrowserPropertyID preSortProperty )
1454 {
1455 return AddDataBrowserItems( m_controlRef , container, numItems, items, preSortProperty ) ;
1456 }
1457
1458 OSStatus wxMacControl::RemoveItems( DataBrowserItemID container, UInt32 numItems,
1459 const DataBrowserItemID* items,
1460 DataBrowserPropertyID preSortProperty )
1461 {
1462 return RemoveDataBrowserItems( m_controlRef , container, numItems, items, preSortProperty ) ;
1463 }
1464
1465 OSStatus wxMacControl::RevealItem( DataBrowserItemID item,
1466 DataBrowserPropertyID propertyID,
1467 DataBrowserRevealOptions options )
1468 {
1469 return RevealDataBrowserItem( m_controlRef , item , propertyID , options ) ;
1470 }
1471
1472 OSStatus wxMacControl::SetSelectedItems(UInt32 numItems,
1473 const DataBrowserItemID * items,
1474 DataBrowserSetOption operation )
1475 {
1476 return SetDataBrowserSelectedItems( m_controlRef , numItems , items, operation ) ;
1477 }
1478
1479 OSStatus wxMacControl::GetSelectionAnchor( DataBrowserItemID * first, DataBrowserItemID * last )
1480 {
1481 return GetDataBrowserSelectionAnchor( m_controlRef , first , last ) ;
1482 }
1483
1484 //
1485 // Tab Control
1486 //
1487
1488 OSStatus wxMacControl::SetTabEnabled( SInt16 tabNo , bool enable )
1489 {
1490 return ::SetTabEnabled( m_controlRef , tabNo , enable ) ;
1491 }
1492
1493 //
1494 // Quartz Support
1495 //
1496
1497 #ifdef __WXMAC_OSX__
1498 // snippets from Sketch Sample from Apple :
1499
1500 #define kGenericRGBProfilePathStr "/System/Library/ColorSync/Profiles/Generic RGB Profile.icc"
1501 /*
1502 This function locates, opens, and returns the profile reference for the calibrated
1503 Generic RGB color space. It is up to the caller to call CMCloseProfile when done
1504 with the profile reference this function returns.
1505 */
1506 CMProfileRef wxMacOpenGenericProfile(void)
1507 {
1508 static CMProfileRef cachedRGBProfileRef = NULL;
1509
1510 // we only create the profile reference once
1511 if (cachedRGBProfileRef == NULL)
1512 {
1513 CMProfileLocation loc;
1514
1515 loc.locType = cmPathBasedProfile;
1516 strcpy(loc.u.pathLoc.path, kGenericRGBProfilePathStr);
1517
1518 verify_noerr( CMOpenProfile(&cachedRGBProfileRef, &loc) );
1519 }
1520
1521 if (cachedRGBProfileRef)
1522 {
1523 // clone the profile reference so that the caller has their own reference, not our cached one
1524 CMCloneProfileRef(cachedRGBProfileRef);
1525 }
1526
1527 return cachedRGBProfileRef;
1528 }
1529
1530 /*
1531 Return the generic RGB color space. This is a 'get' function and the caller should
1532 not release the returned value unless the caller retains it first. Usually callers
1533 of this routine will immediately use the returned colorspace with CoreGraphics
1534 so they typically do not need to retain it themselves.
1535
1536 This function creates the generic RGB color space once and hangs onto it so it can
1537 return it whenever this function is called.
1538 */
1539
1540 #if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_4
1541 #define kCGColorSpaceGenericRGB CFSTR("kCGColorSpaceGenericRGB")
1542 #endif
1543
1544 CGColorSpaceRef wxMacGetGenericRGBColorSpace()
1545 {
1546 static wxMacCFRefHolder<CGColorSpaceRef> genericRGBColorSpace ;
1547
1548 if (genericRGBColorSpace == NULL)
1549 {
1550 if ( UMAGetSystemVersion() >= 0x1040 )
1551 {
1552 genericRGBColorSpace.Set( CGColorSpaceCreateWithName( kCGColorSpaceGenericRGB ) ) ;
1553 }
1554 else
1555 {
1556 CMProfileRef genericRGBProfile = wxMacOpenGenericProfile();
1557
1558 if (genericRGBProfile)
1559 {
1560 genericRGBColorSpace.Set( CGColorSpaceCreateWithPlatformColorSpace(genericRGBProfile) ) ;
1561 wxASSERT_MSG( genericRGBColorSpace != NULL, wxT("couldn't create the generic RGB color space") ) ;
1562
1563 // we opened the profile so it is up to us to close it
1564 CMCloseProfile(genericRGBProfile);
1565 }
1566 }
1567 }
1568 return genericRGBColorSpace;
1569 }
1570 #endif
1571
1572 #endif // wxUSE_GUI
wxWidgets (Impactor)