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