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