]> git.saurik.com Git - wxWidgets.git/blob - src/mac/utils.cpp
Implement GetValue() and SetValue() and send an event when clicked
[wxWidgets.git] / src / mac / 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 #ifdef __GNUG__
13 // Note: this is done in utilscmn.cpp now.
14 // #pragma implementation "utils.h"
15 #endif
16
17 #include "wx/setup.h"
18 #include "wx/utils.h"
19 #include "wx/app.h"
20 #include "wx/apptrait.h"
21
22 #if wxUSE_GUI
23 #include "wx/mac/uma.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 #ifdef __DARWIN__
34 # include "MoreFilesX.h"
35 #else
36 # include "MoreFiles.h"
37 # include "MoreFilesExtras.h"
38 #endif
39
40 #ifndef __DARWIN__
41 #include <Threads.h>
42 #include <Sound.h>
43 #endif
44
45 #include "ATSUnicode.h"
46 #include "TextCommon.h"
47 #include "TextEncodingConverter.h"
48
49 #if defined(__WXMAC__)
50 #include "wx/mac/private.h" // includes mac headers
51 #endif
52
53 #if defined(__MWERKS__) && wxUSE_UNICODE
54 #include <wtime.h>
55 #endif
56
57 // ---------------------------------------------------------------------------
58 // code used in both base and GUI compilation
59 // ---------------------------------------------------------------------------
60
61 // our OS version is the same in non GUI and GUI cases
62 static int DoGetOSVersion(int *majorVsn, int *minorVsn)
63 {
64 long theSystem ;
65
66 // are there x-platform conventions ?
67
68 Gestalt(gestaltSystemVersion, &theSystem) ;
69 if (minorVsn != NULL) {
70 *minorVsn = (theSystem & 0xFF ) ;
71 }
72 if (majorVsn != NULL) {
73 *majorVsn = (theSystem >> 8 ) ;
74 }
75 #ifdef __DARWIN__
76 return wxMAC_DARWIN;
77 #else
78 return wxMAC;
79 #endif
80 }
81
82 #if wxUSE_BASE
83
84 #ifndef __DARWIN__
85 // defined in unix/utilsunx.cpp for Mac OS X
86
87 // get full hostname (with domain name if possible)
88 bool wxGetFullHostName(wxChar *buf, int maxSize)
89 {
90 return wxGetHostName(buf, maxSize);
91 }
92
93 // Get hostname only (without domain name)
94 bool wxGetHostName(wxChar *buf, int maxSize)
95 {
96 // Gets Chooser name of user by examining a System resource.
97
98 const short kComputerNameID = -16413;
99
100 short oldResFile = CurResFile() ;
101 UseResFile(0);
102 StringHandle chooserName = (StringHandle)::GetString(kComputerNameID);
103 UseResFile(oldResFile);
104
105 if (chooserName && *chooserName)
106 {
107 HLock( (Handle) chooserName ) ;
108 wxString name = wxMacMakeStringFromPascal( *chooserName ) ;
109 HUnlock( (Handle) chooserName ) ;
110 ReleaseResource( (Handle) chooserName ) ;
111 wxStrncpy( buf , name , maxSize - 1 ) ;
112 }
113 else
114 buf[0] = 0 ;
115
116 return TRUE;
117 }
118
119 // Get user ID e.g. jacs
120 bool wxGetUserId(wxChar *buf, int maxSize)
121 {
122 return wxGetUserName( buf , maxSize ) ;
123 }
124
125 const wxChar* wxGetHomeDir(wxString *pstr)
126 {
127 *pstr = wxMacFindFolder( (short) kOnSystemDisk, kPreferencesFolderType, kDontCreateFolder ) ;
128 return pstr->c_str() ;
129 }
130
131 // Get user name e.g. Stefan Csomor
132 bool wxGetUserName(wxChar *buf, int maxSize)
133 {
134 // Gets Chooser name of user by examining a System resource.
135
136 const short kChooserNameID = -16096;
137
138 short oldResFile = CurResFile() ;
139 UseResFile(0);
140 StringHandle chooserName = (StringHandle)::GetString(kChooserNameID);
141 UseResFile(oldResFile);
142
143 if (chooserName && *chooserName)
144 {
145 HLock( (Handle) chooserName ) ;
146 wxString name = wxMacMakeStringFromPascal( *chooserName ) ;
147 HUnlock( (Handle) chooserName ) ;
148 ReleaseResource( (Handle) chooserName ) ;
149 wxStrncpy( buf , name , maxSize - 1 ) ;
150 }
151 else
152 buf[0] = 0 ;
153
154 return TRUE;
155 }
156
157 int wxKill(long pid, wxSignal sig , wxKillError *rc )
158 {
159 // TODO
160 return 0;
161 }
162
163 WXDLLEXPORT bool wxGetEnv(const wxString& var, wxString *value)
164 {
165 // TODO : under classic there is no environement support, under X yes
166 return false ;
167 }
168
169 // set the env var name to the given value, return TRUE on success
170 WXDLLEXPORT bool wxSetEnv(const wxString& var, const wxChar *value)
171 {
172 // TODO : under classic there is no environement support, under X yes
173 return false ;
174 }
175
176 //
177 // Execute a program in an Interactive Shell
178 //
179 bool wxShell(const wxString& command)
180 {
181 // TODO
182 return FALSE;
183 }
184
185 // Shutdown or reboot the PC
186 bool wxShutdown(wxShutdownFlags wFlags)
187 {
188 // TODO
189 return FALSE;
190 }
191
192 // Get free memory in bytes, or -1 if cannot determine amount (e.g. on UNIX)
193 long wxGetFreeMemory()
194 {
195 return FreeMem() ;
196 }
197
198 void wxUsleep(unsigned long milliseconds)
199 {
200 clock_t start = clock() ;
201 do
202 {
203 YieldToAnyThread() ;
204 } while( clock() - start < milliseconds / 1000.0 * CLOCKS_PER_SEC ) ;
205 }
206
207 void wxSleep(int nSecs)
208 {
209 wxUsleep(1000*nSecs);
210 }
211
212 // Consume all events until no more left
213 void wxFlushEvents()
214 {
215 }
216
217 #endif // !__DARWIN__
218
219 // Emit a beeeeeep
220 void wxBell()
221 {
222 SysBeep(30);
223 }
224
225 wxToolkitInfo& wxConsoleAppTraits::GetToolkitInfo()
226 {
227 static wxToolkitInfo info;
228 info.os = DoGetOSVersion(&info.versionMajor, &info.versionMinor);
229 info.name = _T("wxBase");
230 return info;
231 }
232
233 #endif // wxUSE_BASE
234
235 #if wxUSE_GUI
236
237 wxToolkitInfo& wxGUIAppTraits::GetToolkitInfo()
238 {
239 static wxToolkitInfo info;
240 info.os = DoGetOSVersion(&info.versionMajor, &info.versionMinor);
241 info.shortName = _T("mac");
242 info.name = _T("wxMac");
243 #ifdef __WXUNIVERSAL__
244 info.shortName << _T("univ");
245 info.name << _T("/wxUniversal");
246 #endif
247 return info;
248 }
249
250 // Reading and writing resources (eg WIN.INI, .Xdefaults)
251 #if wxUSE_RESOURCES
252 bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
253 {
254 // TODO
255 return FALSE;
256 }
257
258 bool wxWriteResource(const wxString& section, const wxString& entry, float value, const wxString& file)
259 {
260 wxString buf;
261 buf.Printf(wxT("%.4f"), value);
262
263 return wxWriteResource(section, entry, buf, file);
264 }
265
266 bool wxWriteResource(const wxString& section, const wxString& entry, long value, const wxString& file)
267 {
268 wxString buf;
269 buf.Printf(wxT("%ld"), value);
270
271 return wxWriteResource(section, entry, buf, file);
272 }
273
274 bool wxWriteResource(const wxString& section, const wxString& entry, int value, const wxString& file)
275 {
276 wxString buf;
277 buf.Printf(wxT("%d"), value);
278
279 return wxWriteResource(section, entry, buf, file);
280 }
281
282 bool wxGetResource(const wxString& section, const wxString& entry, char **value, const wxString& file)
283 {
284 // TODO
285 return FALSE;
286 }
287
288 bool wxGetResource(const wxString& section, const wxString& entry, float *value, const wxString& file)
289 {
290 char *s = NULL;
291 bool succ = wxGetResource(section, entry, (char **)&s, file);
292 if (succ)
293 {
294 *value = (float)strtod(s, NULL);
295 delete[] s;
296 return TRUE;
297 }
298 else return FALSE;
299 }
300
301 bool wxGetResource(const wxString& section, const wxString& entry, long *value, const wxString& file)
302 {
303 char *s = NULL;
304 bool succ = wxGetResource(section, entry, (char **)&s, file);
305 if (succ)
306 {
307 *value = strtol(s, NULL, 10);
308 delete[] s;
309 return TRUE;
310 }
311 else return FALSE;
312 }
313
314 bool wxGetResource(const wxString& section, const wxString& entry, int *value, const wxString& file)
315 {
316 char *s = NULL;
317 bool succ = wxGetResource(section, entry, (char **)&s, file);
318 if (succ)
319 {
320 *value = (int)strtol(s, NULL, 10);
321 delete[] s;
322 return TRUE;
323 }
324 else return FALSE;
325 }
326 #endif // wxUSE_RESOURCES
327
328 int gs_wxBusyCursorCount = 0;
329 extern wxCursor gMacCurrentCursor ;
330 wxCursor gMacStoredActiveCursor ;
331
332 // Set the cursor to the busy cursor for all windows
333 void wxBeginBusyCursor(wxCursor *cursor)
334 {
335 if (gs_wxBusyCursorCount++ == 0)
336 {
337 gMacStoredActiveCursor = gMacCurrentCursor ;
338 cursor->MacInstall() ;
339 }
340 //else: nothing to do, already set
341 }
342
343 // Restore cursor to normal
344 void wxEndBusyCursor()
345 {
346 wxCHECK_RET( gs_wxBusyCursorCount > 0,
347 wxT("no matching wxBeginBusyCursor() for wxEndBusyCursor()") );
348
349 if (--gs_wxBusyCursorCount == 0)
350 {
351 gMacStoredActiveCursor.MacInstall() ;
352 gMacStoredActiveCursor = wxNullCursor ;
353 }
354 }
355
356 // TRUE if we're between the above two calls
357 bool wxIsBusy()
358 {
359 return (gs_wxBusyCursorCount > 0);
360 }
361
362 wxString wxMacFindFolder( short vol,
363 OSType folderType,
364 Boolean createFolder)
365 {
366 short vRefNum ;
367 long dirID ;
368 wxString strDir ;
369
370 if ( FindFolder( vol, folderType, createFolder, &vRefNum, &dirID) == noErr)
371 {
372 FSSpec file ;
373 if ( FSMakeFSSpec( vRefNum , dirID , "\p" , &file ) == noErr )
374 {
375 strDir = wxMacFSSpec2MacFilename( &file ) + wxFILE_SEP_PATH ;
376 }
377 }
378 return strDir ;
379 }
380
381 // Check whether this window wants to process messages, e.g. Stop button
382 // in long calculations.
383 bool wxCheckForInterrupt(wxWindow *wnd)
384 {
385 // TODO
386 return FALSE;
387 }
388
389 void wxGetMousePosition( int* x, int* y )
390 {
391 Point pt ;
392
393 GetMouse( &pt ) ;
394 LocalToGlobal( &pt ) ;
395 *x = pt.h ;
396 *y = pt.v ;
397 };
398
399 // Return TRUE if we have a colour display
400 bool wxColourDisplay()
401 {
402 return TRUE;
403 }
404
405 // Returns depth of screen
406 int wxDisplayDepth()
407 {
408 Rect globRect ;
409 SetRect(&globRect, -32760, -32760, 32760, 32760);
410 GDHandle theMaxDevice;
411
412 int theDepth = 8;
413 theMaxDevice = GetMaxDevice(&globRect);
414 if (theMaxDevice != nil)
415 theDepth = (**(**theMaxDevice).gdPMap).pixelSize;
416
417 return theDepth ;
418 }
419
420 // Get size of display
421 void wxDisplaySize(int *width, int *height)
422 {
423 BitMap screenBits;
424 GetQDGlobalsScreenBits( &screenBits );
425
426 if (width != NULL) {
427 *width = screenBits.bounds.right - screenBits.bounds.left ;
428 }
429 if (height != NULL) {
430 *height = screenBits.bounds.bottom - screenBits.bounds.top ;
431 }
432 }
433
434 void wxDisplaySizeMM(int *width, int *height)
435 {
436 wxDisplaySize(width, height);
437 // on mac 72 is fixed (at least now ;-)
438 float cvPt2Mm = 25.4 / 72;
439
440 if (width != NULL) {
441 *width = int( *width * cvPt2Mm );
442 }
443 if (height != NULL) {
444 *height = int( *height * cvPt2Mm );
445 }
446 }
447
448 void wxClientDisplayRect(int *x, int *y, int *width, int *height)
449 {
450 BitMap screenBits;
451 GetQDGlobalsScreenBits( &screenBits );
452
453 if (x) *x = 0;
454 if (y) *y = 0;
455
456 if (width != NULL) {
457 *width = screenBits.bounds.right - screenBits.bounds.left ;
458 }
459 if (height != NULL) {
460 *height = screenBits.bounds.bottom - screenBits.bounds.top ;
461 }
462
463 SInt16 mheight ;
464 #if TARGET_CARBON
465 GetThemeMenuBarHeight( &mheight ) ;
466 #else
467 mheight = LMGetMBarHeight() ;
468 #endif
469 if (height != NULL) {
470 *height -= mheight ;
471 }
472 if (y)
473 *y = mheight ;
474 }
475
476 wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
477 {
478 return wxGenericFindWindowAtPoint(pt);
479 }
480
481 #endif // wxUSE_GUI
482
483 #if wxUSE_BASE
484
485 wxString wxGetOsDescription()
486 {
487 #ifdef WXWIN_OS_DESCRIPTION
488 // use configure generated description if available
489 return wxString(wxT("MacOS (")) + wxT(WXWIN_OS_DESCRIPTION) + wxString(wxT(")"));
490 #else
491 return wxT("MacOS") ; //TODO:define further
492 #endif
493 }
494
495 #ifndef __DARWIN__
496 wxChar *wxGetUserHome (const wxString& user)
497 {
498 // TODO
499 return NULL;
500 }
501
502 bool wxGetDiskSpace(const wxString& path, wxLongLong *pTotal, wxLongLong *pFree)
503 {
504 if ( path.empty() )
505 return FALSE;
506
507 wxString p = path ;
508 if (p[0] == ':' ) {
509 p = wxGetCwd() + p ;
510 }
511
512 int pos = p.Find(':') ;
513 if ( pos != wxNOT_FOUND ) {
514 p = p.Mid(1,pos) ;
515 }
516
517 p = p + wxT(":") ;
518
519 Str255 volumeName ;
520 XVolumeParam pb ;
521
522 wxMacStringToPascal( p , volumeName ) ;
523 OSErr err = XGetVolumeInfoNoName( volumeName , 0 , &pb ) ;
524 if ( err == noErr ) {
525 if ( pTotal ) {
526 (*pTotal) = wxLongLong( pb.ioVTotalBytes ) ;
527 }
528 if ( pFree ) {
529 (*pFree) = wxLongLong( pb.ioVFreeBytes ) ;
530 }
531 }
532
533 return err == noErr ;
534 }
535 #endif // !__DARWIN__
536
537 #endif // wxUSE_BASE
538
539 #if wxUSE_GUI
540
541 //---------------------------------------------------------------------------
542 // wxMac Specific utility functions
543 //---------------------------------------------------------------------------
544
545 char StringMac[] = "\x0d\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f"
546 "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f"
547 "\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa7\xa8\xa9\xaa\xab\xac\xae\xaf"
548 "\xb1\xb4\xb5\xb6\xbb\xbc\xbe\xbf"
549 "\xc0\xc1\xc2\xc4\xc7\xc8\xc9\xcb\xcc\xcd\xce\xcf"
550 "\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd8\xca\xdb" ;
551
552 char StringANSI[] = "\x0a\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8"
553 "\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC"
554 "\x86\xBA\xA2\xA3\xA7\x95\xB6\xDF\xAE\xA9\x99\xB4\xA8\xC6\xD8"
555 "\xB1\xA5\xB5\xF0\xAA\xBA\xE6\xF8"
556 "\xBF\xA1\xAC\x83\xAB\xBB\x85\xC0\xC3\xD5\x8C\x9C"
557 "\x96\x97\x93\x94\x91\x92\xF7\xFF\xA0\x80" ;
558
559 void wxMacConvertFromPC( const char *from , char *to , int len )
560 {
561 char *c ;
562 if ( from == to )
563 {
564 for( int i = 0 ; i < len ; ++ i )
565 {
566 c = strchr( StringANSI , *from ) ;
567 if ( c != NULL )
568 {
569 *to = StringMac[ c - StringANSI] ;
570 }
571 ++to ;
572 ++from ;
573 }
574 }
575 else
576 {
577 for( int i = 0 ; i < len ; ++ i )
578 {
579 c = strchr( StringANSI , *from ) ;
580 if ( c != NULL )
581 {
582 *to = StringMac[ c - StringANSI] ;
583 }
584 else
585 {
586 *to = *from ;
587 }
588 ++to ;
589 ++from ;
590 }
591 }
592 }
593
594 void wxMacConvertToPC( const char *from , char *to , int len )
595 {
596 char *c ;
597 if ( from == to )
598 {
599 for( int i = 0 ; i < len ; ++ i )
600 {
601 c = strchr( StringMac , *from ) ;
602 if ( c != NULL )
603 {
604 *to = StringANSI[ c - StringMac] ;
605 }
606 ++to ;
607 ++from ;
608 }
609 }
610 else
611 {
612 for( int i = 0 ; i < len ; ++ i )
613 {
614 c = strchr( StringMac , *from ) ;
615 if ( c != NULL )
616 {
617 *to = StringANSI[ c - StringMac] ;
618 }
619 else
620 {
621 *to = *from ;
622 }
623 ++to ;
624 ++from ;
625 }
626 }
627 }
628
629 TECObjectRef s_TECNativeCToUnicode = NULL ;
630 TECObjectRef s_TECUnicodeToNativeC = NULL ;
631 TECObjectRef s_TECPlatformToNativeC = NULL ;
632 TECObjectRef s_TECNativeCToPlatform = NULL ;
633 void wxMacSetupConverters()
634 {
635 // if we assume errors are happening here we need low level debugging
636 // since the high level assert will use the encoders that are not yet
637 // setup...
638 const int kEncoding = wxApp::s_macDefaultEncodingIsPC
639 ? (int)kTextEncodingWindowsLatin1
640 : (int)kTextEncodingMacRoman;
641
642 OSStatus status = noErr ;
643 status = TECCreateConverter(&s_TECNativeCToUnicode,
644 kEncoding,
645 kTextEncodingUnicodeDefault);
646
647
648 status = TECCreateConverter(&s_TECUnicodeToNativeC,
649 kTextEncodingUnicodeDefault,
650 kEncoding);
651
652 if ( wxApp::s_macDefaultEncodingIsPC )
653 {
654 status = TECCreateConverter(&s_TECPlatformToNativeC,
655 kTextEncodingMacRoman,
656 kTextEncodingWindowsLatin1);
657
658
659 status = TECCreateConverter(&s_TECNativeCToPlatform,
660 kTextEncodingWindowsLatin1,
661 kTextEncodingMacRoman);
662 }
663 }
664
665 void wxMacCleanupConverters()
666 {
667 OSStatus status = noErr ;
668 status = TECDisposeConverter(s_TECNativeCToUnicode);
669
670 status = TECDisposeConverter(s_TECUnicodeToNativeC);
671
672 status = TECDisposeConverter(s_TECPlatformToNativeC);
673
674 status = TECDisposeConverter(s_TECNativeCToPlatform);
675 }
676
677 wxWCharBuffer wxMacStringToWString( const wxString &from )
678 {
679 #if wxUSE_UNICODE
680 wxWCharBuffer result( from.wc_str() ) ;
681 #else
682 OSStatus status = noErr ;
683 ByteCount byteOutLen ;
684 ByteCount byteInLen = from.Length() ;
685 ByteCount byteBufferLen = byteInLen *2 ;
686 wxWCharBuffer result( from.Length() ) ;
687 status = TECConvertText(s_TECNativeCToUnicode, (ConstTextPtr)from.c_str() , byteInLen, &byteInLen,
688 (TextPtr)result.data(), byteBufferLen, &byteOutLen);
689 result.data()[byteOutLen/2] = 0 ;
690 #endif
691 return result ;
692 }
693
694 wxString wxMacMakeStringFromCString( const char * from , int len )
695 {
696 OSStatus status = noErr ;
697 wxString result ;
698 wxChar* buf = result.GetWriteBuf( len ) ;
699 #if wxUSE_UNICODE
700 ByteCount byteOutLen ;
701 ByteCount byteInLen = len ;
702 ByteCount byteBufferLen = len *2 ;
703
704 status = TECConvertText(s_TECNativeCToUnicode, (ConstTextPtr)from , byteInLen, &byteInLen,
705 (TextPtr)buf, byteBufferLen, &byteOutLen);
706 #else
707 if ( !wxApp::s_macDefaultEncodingIsPC )
708 memcpy( buf , from , len ) ;
709 else
710 {
711 ByteCount byteOutLen ;
712 ByteCount byteInLen = len ;
713 ByteCount byteBufferLen = byteInLen ;
714
715 status = TECConvertText(s_TECPlatformToNativeC, (ConstTextPtr)from , byteInLen, &byteInLen,
716 (TextPtr)buf, byteBufferLen, &byteOutLen);
717 }
718 #endif
719 buf[len] = 0 ;
720 result.UngetWriteBuf() ;
721 return result ;
722 }
723
724 wxString wxMacMakeStringFromCString( const char * from )
725 {
726 return wxMacMakeStringFromCString( from , strlen(from) ) ;
727 }
728
729 wxCharBuffer wxMacStringToCString( const wxString &from )
730 {
731 #if wxUSE_UNICODE
732 OSStatus status = noErr ;
733 ByteCount byteOutLen ;
734 ByteCount byteInLen = from.Length() * 2 ;
735 ByteCount byteBufferLen = from.Length() ;
736 wxCharBuffer result( from.Length() ) ;
737 status = TECConvertText(s_TECUnicodeToNativeC , (ConstTextPtr)from.wc_str() , byteInLen, &byteInLen,
738 (TextPtr)result.data(), byteBufferLen, &byteOutLen);
739 return result ;
740 #else
741 if ( !wxApp::s_macDefaultEncodingIsPC )
742 return wxCharBuffer( from.c_str() ) ;
743 else
744 {
745 wxCharBuffer result( from.Length() ) ;
746 OSStatus status = noErr ;
747 ByteCount byteOutLen ;
748 ByteCount byteInLen = from.Length() ;
749 ByteCount byteBufferLen = byteInLen ;
750
751 status = TECConvertText(s_TECNativeCToPlatform, (ConstTextPtr)from.c_str() , byteInLen, &byteInLen,
752 (TextPtr)result.data(), byteBufferLen, &byteOutLen);
753 return result ;
754 }
755 #endif
756 }
757
758 void wxMacStringToPascal( const wxString&from , StringPtr to )
759 {
760 wxCharBuffer buf = wxMacStringToCString( from ) ;
761 int len = strlen(buf) ;
762
763 if ( len > 255 )
764 len = 255 ;
765 to[0] = len ;
766 memcpy( (char*) &to[1] , buf , len ) ;
767 }
768
769 wxString wxMacMakeStringFromPascal( ConstStringPtr from )
770 {
771 return wxMacMakeStringFromCString( (char*) &from[1] , from[0] ) ;
772 }
773
774 //
775 // CFStringRefs (Carbon only)
776 //
777
778 #if TARGET_CARBON
779 // converts this string into a carbon foundation string with optional pc 2 mac encoding
780 void wxMacCFStringHolder::Assign( const wxString &str )
781 {
782 #if wxUSE_UNICODE
783 m_cfs = CFStringCreateWithCharacters( kCFAllocatorDefault,
784 (const unsigned short*)str.wc_str(), str.Len() );
785 #else
786 m_cfs = CFStringCreateWithCString( kCFAllocatorSystemDefault , str.c_str() ,
787 wxApp::s_macDefaultEncodingIsPC ?
788 kCFStringEncodingWindowsLatin1 : CFStringGetSystemEncoding() ) ;
789 #endif
790 m_release = true ;
791 }
792
793 wxString wxMacCFStringHolder::AsString()
794 {
795 wxString result ;
796 Size len = CFStringGetLength( m_cfs ) ;
797 wxChar* buf = result.GetWriteBuf( len ) ;
798 #if wxUSE_UNICODE
799 CFStringGetCharacters( m_cfs , CFRangeMake( 0 , len ) , (UniChar*) buf ) ;
800 #else
801 CFStringGetCString( m_cfs , buf , len+1 , wxApp::s_macDefaultEncodingIsPC ?
802 kCFStringEncodingWindowsLatin1 : CFStringGetSystemEncoding() ) ;
803 #endif
804 buf[len] = 0 ;
805 result.UngetWriteBuf() ;
806 return result ;
807 }
808
809 #if 0
810
811 wxString wxMacMakeMacStringFromPC( const wxChar * p )
812 {
813 wxString result ;
814 int len = wxStrlen ( p ) ;
815 if ( len > 0 )
816 {
817 wxChar* ptr = result.GetWriteBuf(len) ;
818 wxMacConvertFromPC( p , ptr , len ) ;
819 ptr[len] = 0 ;
820 result.UngetWriteBuf( len ) ;
821 }
822 return result ;
823 }
824
825 wxString wxMacMakePCStringFromMac( const wxChar * p )
826 {
827 wxString result ;
828 int len = wxStrlen ( p ) ;
829 if ( len > 0 )
830 {
831 wxChar* ptr = result.GetWriteBuf(len) ;
832 wxMacConvertToPC( p , ptr , len ) ;
833 ptr[len] = 0 ;
834 result.UngetWriteBuf( len ) ;
835 }
836 return result ;
837 }
838
839 wxString wxMacMakeStringFromMacString( const wxChar* from , bool mac2pcEncoding )
840 {
841 if (mac2pcEncoding)
842 {
843 return wxMacMakePCStringFromMac( from ) ;
844 }
845 else
846 {
847 return wxString( from ) ;
848 }
849 }
850
851 //
852 // Pascal Strings
853 //
854
855 wxString wxMacMakeStringFromPascal( ConstStringPtr from , bool mac2pcEncoding )
856 {
857 // this is safe since a pascal string can never be larger than 256 bytes
858 char s[256] ;
859 CopyPascalStringToC( from , s ) ;
860 if (mac2pcEncoding)
861 {
862 return wxMacMakePCStringFromMac( s ) ;
863 }
864 else
865 {
866 return wxString( s ) ;
867 }
868 }
869
870 void wxMacStringToPascal( const wxChar * from , StringPtr to , bool pc2macEncoding )
871 {
872 if (pc2macEncoding)
873 {
874 CopyCStringToPascal( wxMacMakeMacStringFromPC( from ) , to ) ;
875 }
876 else
877 {
878 CopyCStringToPascal( from , to ) ;
879 }
880 }
881 #endif
882
883
884 #endif //TARGET_CARBON
885
886 // ----------------------------------------------------------------------------
887 // debugging support
888 // ----------------------------------------------------------------------------
889
890 #if defined(__WXMAC__) && !defined(__DARWIN__) && defined(__MWERKS__) && (__MWERKS__ >= 0x2400)
891
892 // MetroNub stuff doesn't seem to work in CodeWarrior 5.3 Carbon builds...
893
894 #ifndef __MetroNubUtils__
895 #include "MetroNubUtils.h"
896 #endif
897
898 #ifndef __GESTALT__
899 #include <Gestalt.h>
900 #endif
901
902 #if TARGET_API_MAC_CARBON
903
904 #include <CodeFragments.h>
905
906 extern "C" long CallUniversalProc(UniversalProcPtr theProcPtr, ProcInfoType procInfo, ...);
907
908 ProcPtr gCallUniversalProc_Proc = NULL;
909
910 #endif
911
912 static MetroNubUserEntryBlock* gMetroNubEntry = NULL;
913
914 static long fRunOnce = false;
915
916 /* ---------------------------------------------------------------------------
917 IsMetroNubInstalled
918 --------------------------------------------------------------------------- */
919
920 Boolean IsMetroNubInstalled()
921 {
922 if (!fRunOnce)
923 {
924 long result, value;
925
926 fRunOnce = true;
927 gMetroNubEntry = NULL;
928
929 if (Gestalt(gestaltSystemVersion, &value) == noErr && value < 0x1000)
930 {
931 /* look for MetroNub's Gestalt selector */
932 if (Gestalt(kMetroNubUserSignature, &result) == noErr)
933 {
934
935 #if TARGET_API_MAC_CARBON
936 if (gCallUniversalProc_Proc == NULL)
937 {
938 CFragConnectionID connectionID;
939 Ptr mainAddress;
940 Str255 errorString;
941 ProcPtr symbolAddress;
942 OSErr err;
943 CFragSymbolClass symbolClass;
944
945 symbolAddress = NULL;
946 err = GetSharedLibrary("\pInterfaceLib", kPowerPCCFragArch, kFindCFrag,
947 &connectionID, &mainAddress, errorString);
948
949 if (err != noErr)
950 {
951 gCallUniversalProc_Proc = NULL;
952 goto end;
953 }
954
955 err = FindSymbol(connectionID, "\pCallUniversalProc",
956 (Ptr *) &gCallUniversalProc_Proc, &symbolClass);
957
958 if (err != noErr)
959 {
960 gCallUniversalProc_Proc = NULL;
961 goto end;
962 }
963 }
964 #endif
965
966 {
967 MetroNubUserEntryBlock* block = (MetroNubUserEntryBlock *)result;
968
969 /* make sure the version of the API is compatible */
970 if (block->apiLowVersion <= kMetroNubUserAPIVersion &&
971 kMetroNubUserAPIVersion <= block->apiHiVersion)
972 gMetroNubEntry = block; /* success! */
973 }
974
975 }
976 }
977 }
978
979 end:
980
981 #if TARGET_API_MAC_CARBON
982 return (gMetroNubEntry != NULL && gCallUniversalProc_Proc != NULL);
983 #else
984 return (gMetroNubEntry != NULL);
985 #endif
986 }
987
988 /* ---------------------------------------------------------------------------
989 IsMWDebuggerRunning [v1 API]
990 --------------------------------------------------------------------------- */
991
992 Boolean IsMWDebuggerRunning()
993 {
994 if (IsMetroNubInstalled())
995 return CallIsDebuggerRunningProc(gMetroNubEntry->isDebuggerRunning);
996 else
997 return false;
998 }
999
1000 /* ---------------------------------------------------------------------------
1001 AmIBeingMWDebugged [v1 API]
1002 --------------------------------------------------------------------------- */
1003
1004 Boolean AmIBeingMWDebugged()
1005 {
1006 if (IsMetroNubInstalled())
1007 return CallAmIBeingDebuggedProc(gMetroNubEntry->amIBeingDebugged);
1008 else
1009 return false;
1010 }
1011
1012 extern bool WXDLLEXPORT wxIsDebuggerRunning()
1013 {
1014 return IsMWDebuggerRunning() && AmIBeingMWDebugged();
1015 }
1016
1017 #else
1018
1019 extern bool WXDLLEXPORT wxIsDebuggerRunning()
1020 {
1021 return false;
1022 }
1023
1024 #endif // defined(__WXMAC__) && !defined(__DARWIN__) && (__MWERKS__ >= 0x2400)
1025
1026 #endif // wxUSE_GUI
1027