]> git.saurik.com Git - wxWidgets.git/blame_incremental - src/mac/carbon/utils.cpp
support undo patch applied
[wxWidgets.git] / src / mac / carbon / utils.cpp
... / ...
CommitLineData
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)
49bool wxGetFullHostName(wxChar *buf, int maxSize)
50{
51 return wxGetHostName(buf, maxSize);
52}
53
54// Get hostname only (without domain name)
55bool 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
81bool wxGetUserId(wxChar *buf, int maxSize)
82{
83 return wxGetUserName( buf , maxSize ) ;
84}
85
86const 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
93bool 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
118int wxKill(long pid, wxSignal sig , wxKillError *rc )
119{
120 // TODO
121 return 0;
122}
123
124WXDLLEXPORT 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
131WXDLLEXPORT 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//
140bool wxShell(const wxString& command)
141{
142 // TODO
143 return FALSE;
144}
145
146// Shutdown or reboot the PC
147bool 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)
154long wxGetFreeMemory()
155{
156 return FreeMem() ;
157}
158
159void 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
168void wxSleep(int nSecs)
169{
170 wxUsleep(1000*nSecs);
171}
172
173// Consume all events until no more left
174void wxFlushEvents()
175{
176}
177
178#if WXWIN_COMPATIBILITY_2_2
179
180// Output a debug message, in a system dependent fashion.
181void 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
200void 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
207void 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
218void wxBell()
219{
220 SysBeep(30);
221}
222
223int 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
245bool wxWriteResource(const wxString& section, const wxString& entry, const wxString& value, const wxString& file)
246{
247 // TODO
248 return FALSE;
249}
250
251bool 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
259bool 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
267bool 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
275bool wxGetResource(const wxString& section, const wxString& entry, char **value, const wxString& file)
276{
277 // TODO
278 return FALSE;
279}
280
281bool 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
294bool 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
307bool 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
321int gs_wxBusyCursorCount = 0;
322extern wxCursor gMacCurrentCursor ;
323wxCursor gMacStoredActiveCursor ;
324
325// Set the cursor to the busy cursor for all windows
326void 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
337void 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
350bool wxIsBusy()
351{
352 return (gs_wxBusyCursorCount > 0);
353}
354
355wxString 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__
375wxChar *wxGetUserHome (const wxString& user)
376{
377 // TODO
378 return NULL;
379}
380
381bool 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.
418bool wxCheckForInterrupt(wxWindow *wnd)
419{
420 // TODO
421 return FALSE;
422}
423
424void 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
435bool wxColourDisplay()
436{
437 return TRUE;
438}
439
440// Returns depth of screen
441int 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
456void 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
469void 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
483void 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
511wxWindow* wxFindWindowAtPoint(const wxPoint& pt)
512{
513 return wxGenericFindWindowAtPoint(pt);
514}
515
516wxString 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
530char 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
537char 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
544void 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
579void 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
614TECObjectRef s_TECNativeCToUnicode = NULL ;
615TECObjectRef s_TECUnicodeToNativeC = NULL ;
616TECObjectRef s_TECPlatformToNativeC = NULL ;
617TECObjectRef s_TECNativeCToPlatform = NULL ;
618void 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
650void 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
662wxWCharBuffer 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
679wxString 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
709wxString wxMacMakeStringFromCString( const char * from )
710{
711 return wxMacMakeStringFromCString( from , strlen(from) ) ;
712}
713
714wxCharBuffer 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
743void 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
754wxString 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
765void 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
778wxString 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
796wxString 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
810wxString 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
824wxString 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
840wxString 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
855void 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