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