--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: src/mac/corefoundation/cfstring.cpp
+// Purpose: wxCFStringHolder and other string functions
+// Author: Stefan Csomor
+// Modified by:
+// Created: 2004-10-29 (from code in src/mac/carbon/utils.cpp)
+// RCS-ID: $Id$
+// Copyright: (c) Stefan Csomor
+// Licence: wxWindows licence
+// Usage: Darwin (base library)
+/////////////////////////////////////////////////////////////////////////////
+
+#include "wx/wxprec.h"
+
+#ifndef WX_PRECOMP
+ #include "wx/string.h"
+ #include "wx/intl.h"
+ #if wxUSE_GUI
+ #include "wx/font.h"
+ #endif
+#endif
+
+#include "wx/mac/corefoundation/cfstring.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+
+void wxMacConvertNewlines13To10( char * data )
+{
+ char * buf = data ;
+ while( (buf=strchr(buf,0x0d)) != NULL )
+ {
+ *buf = 0x0a ;
+ buf++ ;
+ }
+}
+
+void wxMacConvertNewlines10To13( char * data )
+{
+ char * buf = data ;
+ while( (buf=strchr(buf,0x0a)) != NULL )
+ {
+ *buf = 0x0d ;
+ buf++ ;
+ }
+}
+
+const wxString sCR((wxChar)13);
+const wxString sLF((wxChar)10);
+
+void wxMacConvertNewlines13To10( wxString * data )
+{
+ data->Replace( sCR,sLF);
+}
+
+void wxMacConvertNewlines10To13( wxString * data )
+{
+ data->Replace( sLF,sCR);
+}
+
+wxUint32 wxMacGetSystemEncFromFontEnc(wxFontEncoding encoding)
+{
+ CFStringEncoding enc = 0 ;
+ if ( encoding == wxFONTENCODING_DEFAULT )
+ {
+#if wxUSE_GUI
+ encoding = wxFont::GetDefaultEncoding() ;
+#else
+ encoding = wxFONTENCODING_SYSTEM; // to be set below
+#endif
+ }
+
+ if ( encoding == wxFONTENCODING_SYSTEM )
+ {
+ enc = CFStringGetSystemEncoding();
+ }
+
+ switch( encoding)
+ {
+ case wxFONTENCODING_ISO8859_1 :
+ enc = kCFStringEncodingISOLatin1 ;
+ break ;
+ case wxFONTENCODING_ISO8859_2 :
+ enc = kCFStringEncodingISOLatin2;
+ break ;
+ case wxFONTENCODING_ISO8859_3 :
+ enc = kCFStringEncodingISOLatin3 ;
+ break ;
+ case wxFONTENCODING_ISO8859_4 :
+ enc = kCFStringEncodingISOLatin4;
+ break ;
+ case wxFONTENCODING_ISO8859_5 :
+ enc = kCFStringEncodingISOLatinCyrillic;
+ break ;
+ case wxFONTENCODING_ISO8859_6 :
+ enc = kCFStringEncodingISOLatinArabic;
+ break ;
+ case wxFONTENCODING_ISO8859_7 :
+ enc = kCFStringEncodingISOLatinGreek;
+ break ;
+ case wxFONTENCODING_ISO8859_8 :
+ enc = kCFStringEncodingISOLatinHebrew;
+ break ;
+ case wxFONTENCODING_ISO8859_9 :
+ enc = kCFStringEncodingISOLatin5;
+ break ;
+ case wxFONTENCODING_ISO8859_10 :
+ enc = kCFStringEncodingISOLatin6;
+ break ;
+ case wxFONTENCODING_ISO8859_13 :
+ enc = kCFStringEncodingISOLatin7;
+ break ;
+ case wxFONTENCODING_ISO8859_14 :
+ enc = kCFStringEncodingISOLatin8;
+ break ;
+ case wxFONTENCODING_ISO8859_15 :
+ enc = kCFStringEncodingISOLatin9;
+ break ;
+
+ case wxFONTENCODING_KOI8 :
+ enc = kCFStringEncodingKOI8_R;
+ break ;
+ case wxFONTENCODING_ALTERNATIVE : // MS-DOS CP866
+ enc = kCFStringEncodingDOSRussian;
+ break ;
+/*
+ case wxFONTENCODING_BULGARIAN :
+ enc = ;
+ break ;
+*/
+ case wxFONTENCODING_CP437 :
+ enc =kCFStringEncodingDOSLatinUS ;
+ break ;
+ case wxFONTENCODING_CP850 :
+ enc = kCFStringEncodingDOSLatin1;
+ break ;
+ case wxFONTENCODING_CP852 :
+ enc = kCFStringEncodingDOSLatin2;
+ break ;
+ case wxFONTENCODING_CP855 :
+ enc = kCFStringEncodingDOSCyrillic;
+ break ;
+ case wxFONTENCODING_CP866 :
+ enc =kCFStringEncodingDOSRussian ;
+ break ;
+ case wxFONTENCODING_CP874 :
+ enc = kCFStringEncodingDOSThai;
+ break ;
+ case wxFONTENCODING_CP932 :
+ enc = kCFStringEncodingDOSJapanese;
+ break ;
+ case wxFONTENCODING_CP936 :
+ enc = kCFStringEncodingDOSChineseSimplif ;
+ break ;
+ case wxFONTENCODING_CP949 :
+ enc = kCFStringEncodingDOSKorean;
+ break ;
+ case wxFONTENCODING_CP950 :
+ enc = kCFStringEncodingDOSChineseTrad;
+ break ;
+
+ case wxFONTENCODING_CP1250 :
+ enc = kCFStringEncodingWindowsLatin2;
+ break ;
+ case wxFONTENCODING_CP1251 :
+ enc =kCFStringEncodingWindowsCyrillic ;
+ break ;
+ case wxFONTENCODING_CP1252 :
+ enc =kCFStringEncodingWindowsLatin1 ;
+ break ;
+ case wxFONTENCODING_CP1253 :
+ enc = kCFStringEncodingWindowsGreek;
+ break ;
+ case wxFONTENCODING_CP1254 :
+ enc = kCFStringEncodingWindowsLatin5;
+ break ;
+ case wxFONTENCODING_CP1255 :
+ enc =kCFStringEncodingWindowsHebrew ;
+ break ;
+ case wxFONTENCODING_CP1256 :
+ enc =kCFStringEncodingWindowsArabic ;
+ break ;
+ case wxFONTENCODING_CP1257 :
+ enc = kCFStringEncodingWindowsBalticRim;
+ break ;
+#if 0
+ case wxFONTENCODING_UTF7 :
+ enc = CreateTextEncoding(kCFStringEncodingUnicodeDefault,0,kUnicodeUTF7Format) ;
+#endif
+ break ;
+ case wxFONTENCODING_UTF8 :
+ enc = kCFStringEncodingUTF8;
+ break ;
+ case wxFONTENCODING_EUC_JP :
+ enc = kCFStringEncodingEUC_JP;
+ break ;
+ case wxFONTENCODING_UTF16BE :
+ enc = kCFStringEncodingUTF16BE;
+ break ;
+ case wxFONTENCODING_UTF16LE :
+ enc = kCFStringEncodingUTF16LE;
+ break ;
+ case wxFONTENCODING_UTF32BE :
+ enc = kCFStringEncodingUTF32BE;
+ break ;
+ case wxFONTENCODING_UTF32LE :
+ enc = kCFStringEncodingUTF32LE;
+ break ;
+
+ case wxFONTENCODING_MACROMAN :
+ enc = kCFStringEncodingMacRoman ;
+ break ;
+ case wxFONTENCODING_MACJAPANESE :
+ enc = kCFStringEncodingMacJapanese ;
+ break ;
+ case wxFONTENCODING_MACCHINESETRAD :
+ enc = kCFStringEncodingMacChineseTrad ;
+ break ;
+ case wxFONTENCODING_MACKOREAN :
+ enc = kCFStringEncodingMacKorean ;
+ break ;
+ case wxFONTENCODING_MACARABIC :
+ enc = kCFStringEncodingMacArabic ;
+ break ;
+ case wxFONTENCODING_MACHEBREW :
+ enc = kCFStringEncodingMacHebrew ;
+ break ;
+ case wxFONTENCODING_MACGREEK :
+ enc = kCFStringEncodingMacGreek ;
+ break ;
+ case wxFONTENCODING_MACCYRILLIC :
+ enc = kCFStringEncodingMacCyrillic ;
+ break ;
+ case wxFONTENCODING_MACDEVANAGARI :
+ enc = kCFStringEncodingMacDevanagari ;
+ break ;
+ case wxFONTENCODING_MACGURMUKHI :
+ enc = kCFStringEncodingMacGurmukhi ;
+ break ;
+ case wxFONTENCODING_MACGUJARATI :
+ enc = kCFStringEncodingMacGujarati ;
+ break ;
+ case wxFONTENCODING_MACORIYA :
+ enc = kCFStringEncodingMacOriya ;
+ break ;
+ case wxFONTENCODING_MACBENGALI :
+ enc = kCFStringEncodingMacBengali ;
+ break ;
+ case wxFONTENCODING_MACTAMIL :
+ enc = kCFStringEncodingMacTamil ;
+ break ;
+ case wxFONTENCODING_MACTELUGU :
+ enc = kCFStringEncodingMacTelugu ;
+ break ;
+ case wxFONTENCODING_MACKANNADA :
+ enc = kCFStringEncodingMacKannada ;
+ break ;
+ case wxFONTENCODING_MACMALAJALAM :
+ enc = kCFStringEncodingMacMalayalam ;
+ break ;
+ case wxFONTENCODING_MACSINHALESE :
+ enc = kCFStringEncodingMacSinhalese ;
+ break ;
+ case wxFONTENCODING_MACBURMESE :
+ enc = kCFStringEncodingMacBurmese ;
+ break ;
+ case wxFONTENCODING_MACKHMER :
+ enc = kCFStringEncodingMacKhmer ;
+ break ;
+ case wxFONTENCODING_MACTHAI :
+ enc = kCFStringEncodingMacThai ;
+ break ;
+ case wxFONTENCODING_MACLAOTIAN :
+ enc = kCFStringEncodingMacLaotian ;
+ break ;
+ case wxFONTENCODING_MACGEORGIAN :
+ enc = kCFStringEncodingMacGeorgian ;
+ break ;
+ case wxFONTENCODING_MACARMENIAN :
+ enc = kCFStringEncodingMacArmenian ;
+ break ;
+ case wxFONTENCODING_MACCHINESESIMP :
+ enc = kCFStringEncodingMacChineseSimp ;
+ break ;
+ case wxFONTENCODING_MACTIBETAN :
+ enc = kCFStringEncodingMacTibetan ;
+ break ;
+ case wxFONTENCODING_MACMONGOLIAN :
+ enc = kCFStringEncodingMacMongolian ;
+ break ;
+ case wxFONTENCODING_MACETHIOPIC :
+ enc = kCFStringEncodingMacEthiopic ;
+ break ;
+ case wxFONTENCODING_MACCENTRALEUR :
+ enc = kCFStringEncodingMacCentralEurRoman ;
+ break ;
+ case wxFONTENCODING_MACVIATNAMESE :
+ enc = kCFStringEncodingMacVietnamese ;
+ break ;
+ case wxFONTENCODING_MACARABICEXT :
+ enc = kCFStringEncodingMacExtArabic ;
+ break ;
+ case wxFONTENCODING_MACSYMBOL :
+ enc = kCFStringEncodingMacSymbol ;
+ break ;
+ case wxFONTENCODING_MACDINGBATS :
+ enc = kCFStringEncodingMacDingbats ;
+ break ;
+ case wxFONTENCODING_MACTURKISH :
+ enc = kCFStringEncodingMacTurkish ;
+ break ;
+ case wxFONTENCODING_MACCROATIAN :
+ enc = kCFStringEncodingMacCroatian ;
+ break ;
+ case wxFONTENCODING_MACICELANDIC :
+ enc = kCFStringEncodingMacIcelandic ;
+ break ;
+ case wxFONTENCODING_MACROMANIAN :
+ enc = kCFStringEncodingMacRomanian ;
+ break ;
+ case wxFONTENCODING_MACCELTIC :
+ enc = kCFStringEncodingMacCeltic ;
+ break ;
+ case wxFONTENCODING_MACGAELIC :
+ enc = kCFStringEncodingMacGaelic ;
+ break ;
+ case wxFONTENCODING_MACKEYBOARD :
+ enc = 41; /* kTextEncodingMacKeyboardGlyphs ; */
+ break ;
+ default : // to make gcc happy
+ break ;
+ };
+ return enc ;
+}
+
+wxFontEncoding wxMacGetFontEncFromSystemEnc(wxUint32 encoding)
+{
+ wxFontEncoding enc = wxFONTENCODING_DEFAULT ;
+
+ switch( encoding)
+ {
+ case kCFStringEncodingISOLatin1 :
+ enc = wxFONTENCODING_ISO8859_1 ;
+ break ;
+ case kCFStringEncodingISOLatin2 :
+ enc = wxFONTENCODING_ISO8859_2;
+ break ;
+ case kCFStringEncodingISOLatin3 :
+ enc = wxFONTENCODING_ISO8859_3 ;
+ break ;
+ case kCFStringEncodingISOLatin4 :
+ enc = wxFONTENCODING_ISO8859_4;
+ break ;
+ case kCFStringEncodingISOLatinCyrillic :
+ enc = wxFONTENCODING_ISO8859_5;
+ break ;
+ case kCFStringEncodingISOLatinArabic :
+ enc = wxFONTENCODING_ISO8859_6;
+ break ;
+ case kCFStringEncodingISOLatinGreek :
+ enc = wxFONTENCODING_ISO8859_7;
+ break ;
+ case kCFStringEncodingISOLatinHebrew :
+ enc = wxFONTENCODING_ISO8859_8;
+ break ;
+ case kCFStringEncodingISOLatin5 :
+ enc = wxFONTENCODING_ISO8859_9;
+ break ;
+ case kCFStringEncodingISOLatin6 :
+ enc = wxFONTENCODING_ISO8859_10;
+ break ;
+ case kCFStringEncodingISOLatin7 :
+ enc = wxFONTENCODING_ISO8859_13;
+ break ;
+ case kCFStringEncodingISOLatin8 :
+ enc = wxFONTENCODING_ISO8859_14;
+ break ;
+ case kCFStringEncodingISOLatin9 :
+ enc =wxFONTENCODING_ISO8859_15 ;
+ break ;
+
+ case kCFStringEncodingKOI8_R :
+ enc = wxFONTENCODING_KOI8;
+ break ;
+/*
+ case :
+ enc = wxFONTENCODING_BULGARIAN;
+ break ;
+*/
+ case kCFStringEncodingDOSLatinUS :
+ enc = wxFONTENCODING_CP437;
+ break ;
+ case kCFStringEncodingDOSLatin1 :
+ enc = wxFONTENCODING_CP850;
+ break ;
+ case kCFStringEncodingDOSLatin2 :
+ enc =wxFONTENCODING_CP852 ;
+ break ;
+ case kCFStringEncodingDOSCyrillic :
+ enc = wxFONTENCODING_CP855;
+ break ;
+ case kCFStringEncodingDOSRussian :
+ enc = wxFONTENCODING_CP866;
+ break ;
+ case kCFStringEncodingDOSThai :
+ enc =wxFONTENCODING_CP874 ;
+ break ;
+ case kCFStringEncodingDOSJapanese :
+ enc = wxFONTENCODING_CP932;
+ break ;
+ case kCFStringEncodingDOSChineseSimplif :
+ enc = wxFONTENCODING_CP936;
+ break ;
+ case kCFStringEncodingDOSKorean :
+ enc = wxFONTENCODING_CP949;
+ break ;
+ case kCFStringEncodingDOSChineseTrad :
+ enc = wxFONTENCODING_CP950;
+ break ;
+
+ case kCFStringEncodingWindowsLatin2 :
+ enc = wxFONTENCODING_CP1250;
+ break ;
+ case kCFStringEncodingWindowsCyrillic :
+ enc = wxFONTENCODING_CP1251;
+ break ;
+ case kCFStringEncodingWindowsLatin1 :
+ enc = wxFONTENCODING_CP1252;
+ break ;
+ case kCFStringEncodingWindowsGreek :
+ enc = wxFONTENCODING_CP1253;
+ break ;
+ case kCFStringEncodingWindowsLatin5 :
+ enc = wxFONTENCODING_CP1254;
+ break ;
+ case kCFStringEncodingWindowsHebrew :
+ enc = wxFONTENCODING_CP1255;
+ break ;
+ case kCFStringEncodingWindowsArabic :
+ enc = wxFONTENCODING_CP1256;
+ break ;
+ case kCFStringEncodingWindowsBalticRim :
+ enc =wxFONTENCODING_CP1257 ;
+ break ;
+ case kCFStringEncodingEUC_JP :
+ enc = wxFONTENCODING_EUC_JP;
+ break ;
+
+ case kCFStringEncodingUTF8 :
+ enc = wxFONTENCODING_UTF8;
+ break ;
+ case kCFStringEncodingUTF16BE :
+ enc = wxFONTENCODING_UTF16BE;
+ break ;
+ case kCFStringEncodingUTF16LE :
+ enc = wxFONTENCODING_UTF16LE;
+ break ;
+ case kCFStringEncodingUTF32BE :
+ enc = wxFONTENCODING_UTF32BE;
+ break ;
+ case kCFStringEncodingUTF32LE :
+ enc = wxFONTENCODING_UTF32LE;
+ break ;
+
+#if 0
+ case wxFONTENCODING_UTF7 :
+ enc = CreateTextEncoding(kCFStringEncodingUnicodeDefault,0,kUnicodeUTF7Format) ;
+ break ;
+#endif
+ case kCFStringEncodingMacRoman :
+ enc = wxFONTENCODING_MACROMAN ;
+ break ;
+ case kCFStringEncodingMacJapanese :
+ enc = wxFONTENCODING_MACJAPANESE ;
+ break ;
+ case kCFStringEncodingMacChineseTrad :
+ enc = wxFONTENCODING_MACCHINESETRAD ;
+ break ;
+ case kCFStringEncodingMacKorean :
+ enc = wxFONTENCODING_MACKOREAN ;
+ break ;
+ case kCFStringEncodingMacArabic :
+ enc =wxFONTENCODING_MACARABIC ;
+ break ;
+ case kCFStringEncodingMacHebrew :
+ enc = wxFONTENCODING_MACHEBREW ;
+ break ;
+ case kCFStringEncodingMacGreek :
+ enc = wxFONTENCODING_MACGREEK ;
+ break ;
+ case kCFStringEncodingMacCyrillic :
+ enc = wxFONTENCODING_MACCYRILLIC ;
+ break ;
+ case kCFStringEncodingMacDevanagari :
+ enc = wxFONTENCODING_MACDEVANAGARI ;
+ break ;
+ case kCFStringEncodingMacGurmukhi :
+ enc = wxFONTENCODING_MACGURMUKHI ;
+ break ;
+ case kCFStringEncodingMacGujarati :
+ enc = wxFONTENCODING_MACGUJARATI ;
+ break ;
+ case kCFStringEncodingMacOriya :
+ enc =wxFONTENCODING_MACORIYA ;
+ break ;
+ case kCFStringEncodingMacBengali :
+ enc =wxFONTENCODING_MACBENGALI ;
+ break ;
+ case kCFStringEncodingMacTamil :
+ enc = wxFONTENCODING_MACTAMIL ;
+ break ;
+ case kCFStringEncodingMacTelugu :
+ enc = wxFONTENCODING_MACTELUGU ;
+ break ;
+ case kCFStringEncodingMacKannada :
+ enc = wxFONTENCODING_MACKANNADA ;
+ break ;
+ case kCFStringEncodingMacMalayalam :
+ enc = wxFONTENCODING_MACMALAJALAM ;
+ break ;
+ case kCFStringEncodingMacSinhalese :
+ enc = wxFONTENCODING_MACSINHALESE ;
+ break ;
+ case kCFStringEncodingMacBurmese :
+ enc = wxFONTENCODING_MACBURMESE ;
+ break ;
+ case kCFStringEncodingMacKhmer :
+ enc = wxFONTENCODING_MACKHMER ;
+ break ;
+ case kCFStringEncodingMacThai :
+ enc = wxFONTENCODING_MACTHAI ;
+ break ;
+ case kCFStringEncodingMacLaotian :
+ enc = wxFONTENCODING_MACLAOTIAN ;
+ break ;
+ case kCFStringEncodingMacGeorgian :
+ enc = wxFONTENCODING_MACGEORGIAN ;
+ break ;
+ case kCFStringEncodingMacArmenian :
+ enc = wxFONTENCODING_MACARMENIAN ;
+ break ;
+ case kCFStringEncodingMacChineseSimp :
+ enc = wxFONTENCODING_MACCHINESESIMP ;
+ break ;
+ case kCFStringEncodingMacTibetan :
+ enc = wxFONTENCODING_MACTIBETAN ;
+ break ;
+ case kCFStringEncodingMacMongolian :
+ enc = wxFONTENCODING_MACMONGOLIAN ;
+ break ;
+ case kCFStringEncodingMacEthiopic :
+ enc = wxFONTENCODING_MACETHIOPIC ;
+ break ;
+ case kCFStringEncodingMacCentralEurRoman:
+ enc = wxFONTENCODING_MACCENTRALEUR ;
+ break ;
+ case kCFStringEncodingMacVietnamese:
+ enc = wxFONTENCODING_MACVIATNAMESE ;
+ break ;
+ case kCFStringEncodingMacExtArabic :
+ enc = wxFONTENCODING_MACARABICEXT ;
+ break ;
+ case kCFStringEncodingMacSymbol :
+ enc = wxFONTENCODING_MACSYMBOL ;
+ break ;
+ case kCFStringEncodingMacDingbats :
+ enc = wxFONTENCODING_MACDINGBATS ;
+ break ;
+ case kCFStringEncodingMacTurkish :
+ enc = wxFONTENCODING_MACTURKISH ;
+ break ;
+ case kCFStringEncodingMacCroatian :
+ enc = wxFONTENCODING_MACCROATIAN ;
+ break ;
+ case kCFStringEncodingMacIcelandic :
+ enc = wxFONTENCODING_MACICELANDIC ;
+ break ;
+ case kCFStringEncodingMacRomanian :
+ enc = wxFONTENCODING_MACROMANIAN ;
+ break ;
+ case kCFStringEncodingMacCeltic :
+ enc = wxFONTENCODING_MACCELTIC ;
+ break ;
+ case kCFStringEncodingMacGaelic :
+ enc = wxFONTENCODING_MACGAELIC ;
+ break ;
+ case 41 /* kTextEncodingMacKeyboardGlyphs */ :
+ enc = wxFONTENCODING_MACKEYBOARD ;
+ break ;
+ } ;
+ return enc ;
+}
+
+
+//
+// CFStringRefs
+//
+
+// converts this string into a core foundation string with optional pc 2 mac encoding
+
+wxCFStringRef::wxCFStringRef( const wxString &st , wxFontEncoding WXUNUSED_IN_UNICODE(encoding) )
+{
+ if (st.IsEmpty())
+ {
+ reset( wxCFRetain( CFSTR("") ) );
+ }
+ else
+ {
+ wxString str = st ;
+ wxMacConvertNewlines13To10( &str ) ;
+#if wxUSE_UNICODE
+#if SIZEOF_WCHAR_T == 2
+ reset( CFStringCreateWithCharacters( kCFAllocatorDefault,
+ (UniChar*)str.wc_str() , str.Len() ) );
+#else
+ wxMBConvUTF16 converter ;
+ size_t unicharbytes = converter.FromWChar( NULL , 0 , str.wc_str() , str.Length() ) ;
+ wxASSERT( unicharbytes != wxCONV_FAILED );
+ if ( unicharbytes == wxCONV_FAILED )
+ {
+ // create an empty string
+ reset( wxCFRetain( CFSTR("") ) );
+ }
+ else
+ {
+ // unicharbytes: number of bytes needed for UTF-16 encoded string (without terminating null)
+ // unichars: number of UTF-16 characters (without terminating null)
+ size_t unichars = unicharbytes / sizeof(UniChar) ;
+ UniChar *unibuf = new UniChar[ unichars ] ;
+ converter.FromWChar( (char*)unibuf , unicharbytes , str.wc_str() , str.Length() ) ;
+ reset( CFStringCreateWithCharacters( kCFAllocatorDefault , unibuf , unichars ) ) ;
+ delete[] unibuf ;
+ }
+#endif
+#else // not wxUSE_UNICODE
+ reset( CFStringCreateWithCString( kCFAllocatorSystemDefault , str.c_str() ,
+ wxMacGetSystemEncFromFontEnc( encoding ) ) );
+#endif
+ }
+}
+
+wxString wxCFStringRef::AsString(wxFontEncoding WXUNUSED_IN_UNICODE(encoding))
+{
+ if ( !get() )
+ return wxEmptyString ;
+
+ Size cflen = CFStringGetLength( get() ) ;
+ size_t noChars ;
+ wxChar* buf = NULL ;
+
+#if wxUSE_UNICODE
+#if SIZEOF_WCHAR_T == 2
+ buf = new wxChar[ cflen + 1 ] ;
+ CFStringGetCharacters( get() , CFRangeMake( 0 , cflen ) , (UniChar*) buf ) ;
+ noChars = cflen ;
+#else
+ UniChar* unibuf = new UniChar[ cflen + 1 ] ;
+ CFStringGetCharacters( get() , CFRangeMake( 0 , cflen ) , (UniChar*) unibuf ) ;
+ unibuf[cflen] = 0 ;
+ wxMBConvUTF16 converter ;
+ noChars = converter.MB2WC( NULL , (const char*)unibuf , 0 ) ;
+ wxASSERT_MSG( noChars != wxCONV_FAILED, _T("Unable to count the number of characters in this string!") );
+ buf = new wxChar[ noChars + 1 ] ;
+ noChars = converter.MB2WC( buf , (const char*)unibuf , noChars + 1 ) ;
+ wxASSERT_MSG( noChars != wxCONV_FAILED, _T("Conversion of string failed!") );
+ delete[] unibuf ;
+#endif
+#else
+ CFIndex cStrLen ;
+ CFStringGetBytes( get() , CFRangeMake(0, cflen) , wxMacGetSystemEncFromFontEnc( encoding ) ,
+ '?' , false , NULL , 0 , &cStrLen ) ;
+ buf = new wxChar[ cStrLen + 1 ] ;
+ CFStringGetBytes( get() , CFRangeMake(0, cflen) , wxMacGetSystemEncFromFontEnc( encoding ) ,
+ '?' , false , (unsigned char*) buf , cStrLen , &cStrLen) ;
+ noChars = cStrLen ;
+#endif
+
+ buf[noChars] = 0 ;
+ wxString result(buf) ;
+ delete[] buf ;
+ wxMacConvertNewlines10To13( &result);
+ return result ;
+}
+
+//
+// wxMacUniCharBuffer
+//
+
+wxMacUniCharBuffer::wxMacUniCharBuffer( const wxString &str )
+{
+ m_chars = str.length() ;
+ m_ubuf = NULL ;
+
+#if SIZEOF_WCHAR_T == 4
+ wxMBConvUTF16 converter ;
+#if wxUSE_UNICODE
+ size_t unicharlen = converter.WC2MB( NULL , str.wc_str() , 0 ) ;
+ m_ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
+ converter.WC2MB( (char*) m_ubuf , str.wc_str(), unicharlen + 2 ) ;
+#else
+ const wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
+ size_t unicharlen = converter.WC2MB( NULL , wchar.data() , 0 ) ;
+ m_ubuf = (UniChar*) malloc( unicharlen + 2 ) ;
+ converter.WC2MB( (char*) m_ubuf , wchar.data() , unicharlen + 2 ) ;
+#endif
+ m_chars = unicharlen / 2 ;
+#else // SIZEOF_WCHAR_T is then 2
+#if wxUSE_UNICODE
+ m_ubuf = malloc( m_chars * 2 + 2 ) ;
+ memcpy( m_ubuf , (UniChar*) str.wc_str() , m_chars * 2 + 2 ) ;
+#else
+ wxWCharBuffer wchar = str.wc_str( wxConvLocal ) ;
+ m_chars = wxWcslen( wchar.data() ) ;
+ m_ubuf = malloc( m_chars * 2 + 2 ) ;
+ memcpy( m_ubuf , (UniChar*) wchar.data() , m_chars * 2 + 2 ) ;
+#endif
+#endif
+}
+
+wxMacUniCharBuffer::~wxMacUniCharBuffer()
+{
+ free( m_ubuf ) ;
+}
+
+UniCharPtr wxMacUniCharBuffer::GetBuffer()
+{
+ return m_ubuf ;
+}
+
+UniCharCount wxMacUniCharBuffer::GetChars()
+{
+ return m_chars ;
+}
--- /dev/null
+/* -------------------------------------------------------------------------
+ * Project: GSocket (Generic Socket) for WX
+ * Name: src/mac/corefoundation/gsockosx.c
+ * Purpose: GSocket: Mac OS X mach-o part
+ * CVSID: $Id$
+ * Mac code by Brian Victor, February 2002. Email comments to bhv1@psu.edu
+ * ------------------------------------------------------------------------- */
+
+#include "wx/wxprec.h"
+
+#if wxUSE_SOCKETS
+
+#include "wx/gsocket.h"
+#include "wx/apptrait.h"
+
+#include <CoreFoundation/CoreFoundation.h>
+
+// ----------------------------------------------------------------------------
+// Mac-specific data associated with each socket by GSocketCFManager
+// ----------------------------------------------------------------------------
+
+class MacGSocketData
+{
+public:
+ // default ctor creates the object in uninitialized state, use Initialize()
+ // later to make it usable
+ MacGSocketData()
+ {
+ m_socket = NULL;
+ m_source = NULL;
+ }
+
+ // initialize the data associated with the given socket
+ bool Initialize(GSocket *socket)
+ {
+ wxASSERT_MSG( !IsInitialized(), "shouldn't be called twice" );
+
+ // we need a valid Unix socket to create a CFSocket
+ if ( socket->m_fd < 0 )
+ return false;
+
+ CFSocketContext cont;
+ cont.version = 0; // this currently must be 0
+ cont.info = socket; // pointer passed to our callback
+ cont.retain = NULL; // no need to retain/release/copy the
+ cont.release = NULL; // socket pointer, so all callbacks
+ cont.copyDescription = NULL; // can be left NULL
+
+ m_socket = CFSocketCreateWithNative
+ (
+ NULL, // default allocator
+ socket->m_fd,
+ kCFSocketReadCallBack |
+ kCFSocketWriteCallBack |
+ kCFSocketConnectCallBack,
+ SocketCallback,
+ &cont
+ );
+ if ( !m_socket )
+ return false;
+
+ m_source = CFSocketCreateRunLoopSource(NULL, m_socket, 0);
+
+ return m_source != NULL;
+ }
+
+ // free the objects created by Initialize()
+ ~MacGSocketData()
+ {
+ if ( m_source )
+ CFRelease(m_source);
+ if ( m_socket )
+ CFRelease(m_socket);
+ }
+
+ // return true if Initialize() had already been called successfully
+ bool IsInitialized() const { return m_source && m_socket; }
+
+
+ // accessors: should only be called if IsInitialized()
+ CFSocketRef GetSocket() const
+ {
+ wxASSERT( IsInitialized() );
+
+ return m_socket;
+ }
+
+ CFRunLoopSourceRef GetSource() const
+ {
+ wxASSERT( IsInitialized() );
+
+ return m_source;
+ }
+
+private:
+ static void SocketCallback(CFSocketRef WXUNUSED(s),
+ CFSocketCallBackType callbackType,
+ CFDataRef WXUNUSED(address),
+ const void* data,
+ void* info)
+ {
+ GSocket * const socket = wx_static_cast(GSocket *, info);
+ MacGSocketData * const
+ macdata = wx_static_cast(MacGSocketData *, socket->m_gui_dependent);
+ if ( !macdata )
+ return;
+
+ switch (callbackType)
+ {
+ case kCFSocketConnectCallBack:
+ wxASSERT(!socket->m_server);
+ // KH: If data is non-NULL, the connect failed, do not call Detected_Write,
+ // which will only end up creating a spurious connect event because the
+ // call to getsocketopt SO_ERROR inexplicably returns no error.
+ // The change in behavior cannot be traced to any particular commit or
+ // timeframe so I'm not sure what to think, but after so many hours,
+ // this seems to address the issue and it's time to move on.
+ if (data == NULL)
+ socket->Detected_Write();
+ break;
+
+ case kCFSocketReadCallBack:
+ socket->Detected_Read();
+ break;
+
+ case kCFSocketWriteCallBack:
+ socket->Detected_Write();
+ break;
+
+ default:
+ wxFAIL_MSG( "unexpected socket callback" );
+ }
+ }
+
+ CFSocketRef m_socket;
+ CFRunLoopSourceRef m_source;
+
+ DECLARE_NO_COPY_CLASS(MacGSocketData);
+};
+
+// ----------------------------------------------------------------------------
+// CoreFoundation implementation of GSocketManager
+// ----------------------------------------------------------------------------
+
+class GSocketCFManager : public GSocketManager
+{
+public:
+ virtual bool OnInit();
+ virtual void OnExit();
+
+ virtual bool Init_Socket(GSocket *socket);
+ virtual void Destroy_Socket(GSocket *socket);
+
+ virtual void Install_Callback(GSocket *socket, GSocketEvent event);
+ virtual void Uninstall_Callback(GSocket *socket, GSocketEvent event);
+
+ virtual void Enable_Events(GSocket *socket);
+ virtual void Disable_Events(GSocket *socket);
+
+private:
+ // retrieve our custom data associated with the given socket
+ //
+ // this is a low level function, use GetInitializedData() instead if the
+ // data pointer should also be correctly initialized if it hadn't been done
+ // yet
+ //
+ // may return NULL if we hadn't created the data for this socket yet
+ MacGSocketData *GetData(GSocket *socket) const
+ {
+ return wx_static_cast(MacGSocketData *, socket->m_gui_dependent);
+ }
+
+ // return the custom data pointer initializing it if it hadn't been done
+ // yet
+ //
+ // may return NULL if there is no associated data
+ MacGSocketData *GetInitializedData(GSocket *socket) const
+ {
+ MacGSocketData * const data = GetData(socket);
+ if ( data && !data->IsInitialized() )
+ {
+ if ( !data->Initialize(socket) )
+ return NULL;
+ }
+
+ return data;
+ }
+
+ // return CFSocket callback mask corresponding to the given event (the
+ // socket parameter is needed because some events are interpreted
+ // differently depending on whether they happen on a server or on a client
+ // socket)
+ static int GetCFCallback(GSocket *socket, GSocketEvent event);
+
+
+ // Sockets must use the event loop on the main thread so we store a
+ // reference to the main loop here in OnInit()
+ static CFRunLoopRef ms_mainRunLoop;
+};
+
+CFRunLoopRef GSocketCFManager::ms_mainRunLoop = NULL;
+
+bool GSocketCFManager::OnInit()
+{
+ // No need to store the main loop again
+ if (ms_mainRunLoop != NULL)
+ return true;
+
+ // Get the loop for the main thread so our events will actually fire.
+ // The common socket.cpp code will assert if initialize is called from a
+ // secondary thread, otherwise Mac would have the same problems as MSW
+ ms_mainRunLoop = CFRunLoopGetCurrent();
+ if ( !ms_mainRunLoop )
+ return false;
+
+ CFRetain(ms_mainRunLoop);
+
+ return true;
+}
+
+void GSocketCFManager::OnExit()
+{
+ // Release the reference count, and set the reference back to NULL
+ CFRelease(ms_mainRunLoop);
+ ms_mainRunLoop = NULL;
+}
+
+bool GSocketCFManager::Init_Socket(GSocket *socket)
+{
+ socket->m_gui_dependent = new MacGSocketData;
+ return true;
+}
+
+void GSocketCFManager::Destroy_Socket(GSocket *socket)
+{
+ MacGSocketData * const data = GetData(socket);
+ if ( data )
+ {
+ delete data;
+ socket->m_gui_dependent = NULL;
+ }
+}
+
+/* static */
+int GSocketCFManager::GetCFCallback(GSocket *socket, GSocketEvent event)
+{
+ switch ( event )
+ {
+ case GSOCK_CONNECTION:
+ return socket->m_server ? kCFSocketReadCallBack
+ : kCFSocketConnectCallBack;
+
+ case GSOCK_LOST:
+ case GSOCK_INPUT:
+ return kCFSocketReadCallBack;
+
+ case GSOCK_OUTPUT:
+ return kCFSocketWriteCallBack;
+
+ case GSOCK_MAX_EVENT:
+ wxFAIL_MSG( "invalid GSocketEvent" );
+ return 0;
+
+ default:
+ wxFAIL_MSG( "unknown GSocketEvent" );
+ return 0;
+ }
+}
+
+void GSocketCFManager::Install_Callback(GSocket *socket, GSocketEvent event)
+{
+ const MacGSocketData * const data = GetInitializedData(socket);
+ if ( !data )
+ return;
+
+ CFSocketEnableCallBacks(data->GetSocket(), GetCFCallback(socket, event));
+}
+
+void GSocketCFManager::Uninstall_Callback(GSocket *socket, GSocketEvent event)
+{
+ const MacGSocketData * const data = GetInitializedData(socket);
+ if ( !data )
+ return;
+
+ CFSocketDisableCallBacks(data->GetSocket(), GetCFCallback(socket, event));
+}
+
+void GSocketCFManager::Enable_Events(GSocket *socket)
+{
+ const MacGSocketData * const data = GetInitializedData(socket);
+ if ( !data )
+ return;
+
+ CFRunLoopAddSource(ms_mainRunLoop, data->GetSource(), kCFRunLoopCommonModes);
+}
+
+void GSocketCFManager::Disable_Events(GSocket *socket)
+{
+ const MacGSocketData * const data = GetInitializedData(socket);
+ if ( !data )
+ return;
+
+ // CFSocketInvalidate does CFRunLoopRemoveSource anyway
+ CFRunLoopRemoveSource(ms_mainRunLoop, data->GetSource(), kCFRunLoopCommonModes);
+ CFSocketInvalidate(data->GetSocket());
+
+ // CFSocketInvalidate has closed the socket so we want to make sure GSocket knows this
+ socket->m_fd = -1;
+}
+
+GSocketManager *wxAppTraits::GetSocketManager()
+{
+ static GSocketCFManager s_manager;
+
+ return &s_manager;
+};
+
+#endif // wxUSE_SOCKETS
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: src/mac/corefoundation/hid.cpp
+// Purpose: DARWIN HID layer for WX Implementation
+// Author: Ryan Norton
+// Modified by:
+// Created: 11/11/2003
+// RCS-ID: $Id$
+// Copyright: (c) Ryan Norton
+// Licence: wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+// ===========================================================================
+// declarations
+// ===========================================================================
+
+// ---------------------------------------------------------------------------
+// headers
+// ---------------------------------------------------------------------------
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifdef __BORLANDC__
+ #pragma hdrstop
+#endif
+
+//DARWIN _ONLY_
+#ifdef __DARWIN__
+
+#include "wx/mac/corefoundation/hid.h"
+
+#ifndef WX_PRECOMP
+ #include "wx/dynarray.h"
+ #include "wx/string.h"
+ #include "wx/log.h"
+ #include "wx/utils.h"
+ #include "wx/module.h"
+#endif
+
+#include "wx/mac/corefoundation/cfstring.h"
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//
+// wxHIDDevice
+//
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+// ----------------------------------------------------------------------------
+// wxHIDDevice::Create
+//
+// nClass is the HID Page such as
+// kHIDPage_GenericDesktop
+// nType is the HID Usage such as
+// kHIDUsage_GD_Joystick,kHIDUsage_GD_Mouse,kHIDUsage_GD_Keyboard
+// nDev is the device number to use
+//
+// ----------------------------------------------------------------------------
+bool wxHIDDevice::Create (int nClass, int nType, int nDev)
+{
+ //Create the mach port
+ if(IOMasterPort(bootstrap_port, &m_pPort) != kIOReturnSuccess)
+ {
+ wxLogSysError(wxT("Could not create mach port"));
+ return false;
+ }
+
+ //Dictionary that will hold first
+ //the matching dictionary for determining which kind of devices we want,
+ //then later some registry properties from an iterator (see below)
+ //
+ //The call to IOServiceMatching filters down the
+ //the services we want to hid services (and also eats the
+ //dictionary up for us (consumes one reference))
+ CFMutableDictionaryRef pDictionary = IOServiceMatching(kIOHIDDeviceKey);
+ if(pDictionary == NULL)
+ {
+ wxLogSysError( _T("IOServiceMatching(kIOHIDDeviceKey) failed") );
+ return false;
+ }
+
+ //Here we'll filter down the services to what we want
+ if (nType != -1)
+ {
+ CFNumberRef pType = CFNumberCreate(kCFAllocatorDefault,
+ kCFNumberIntType, &nType);
+ CFDictionarySetValue(pDictionary, CFSTR(kIOHIDPrimaryUsageKey), pType);
+ CFRelease(pType);
+ }
+ if (nClass != -1)
+ {
+ CFNumberRef pClass = CFNumberCreate(kCFAllocatorDefault,
+ kCFNumberIntType, &nClass);
+ CFDictionarySetValue(pDictionary, CFSTR(kIOHIDPrimaryUsagePageKey), pClass);
+ CFRelease(pClass);
+ }
+
+ //Now get the maching services
+ io_iterator_t pIterator;
+ if( IOServiceGetMatchingServices(m_pPort,
+ pDictionary, &pIterator) != kIOReturnSuccess )
+ {
+ wxLogSysError(_T("No Matching HID Services"));
+ return false;
+ }
+
+ //Were there any devices matched?
+ if(pIterator == 0)
+ return false; // No devices found
+
+ //Now we iterate through them
+ io_object_t pObject;
+ while ( (pObject = IOIteratorNext(pIterator)) != 0)
+ {
+ if(--nDev != 0)
+ {
+ IOObjectRelease(pObject);
+ continue;
+ }
+
+ if ( IORegistryEntryCreateCFProperties
+ (
+ pObject,
+ &pDictionary,
+ kCFAllocatorDefault,
+ kNilOptions
+ ) != KERN_SUCCESS )
+ {
+ wxLogDebug(_T("IORegistryEntryCreateCFProperties failed"));
+ }
+
+ //
+ // Now we get the attributes of each "product" in the iterator
+ //
+
+ //Get [product] name
+ CFStringRef cfsProduct = (CFStringRef)
+ CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDProductKey));
+ m_szProductName =
+ wxCFStringRef( wxCFRetain(cfsProduct)
+ ).AsString();
+
+ //Get the Product ID Key
+ CFNumberRef cfnProductId = (CFNumberRef)
+ CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDProductIDKey));
+ if (cfnProductId)
+ {
+ CFNumberGetValue(cfnProductId, kCFNumberIntType, &m_nProductId);
+ }
+
+ //Get the Vendor ID Key
+ CFNumberRef cfnVendorId = (CFNumberRef)
+ CFDictionaryGetValue(pDictionary, CFSTR(kIOHIDVendorIDKey));
+ if (cfnVendorId)
+ {
+ CFNumberGetValue(cfnVendorId, kCFNumberIntType, &m_nManufacturerId);
+ }
+
+ //
+ // End attribute getting
+ //
+
+ //Create the interface (good grief - long function names!)
+ SInt32 nScore;
+ IOCFPlugInInterface** ppPlugin;
+ if(IOCreatePlugInInterfaceForService(pObject,
+ kIOHIDDeviceUserClientTypeID,
+ kIOCFPlugInInterfaceID, &ppPlugin,
+ &nScore) != kIOReturnSuccess)
+ {
+ wxLogSysError(wxT("Could not create HID Interface for product"));
+ return false;
+ }
+
+ //Now, the final thing we can check before we fall back to asserts
+ //(because the dtor only checks if the device is ok, so if anything
+ //fails from now on the dtor will delete the device anyway, so we can't break from this).
+
+ //Get the HID interface from the plugin to the mach port
+ if((*ppPlugin)->QueryInterface(ppPlugin,
+ CFUUIDGetUUIDBytes(kIOHIDDeviceInterfaceID),
+ (void**) &m_ppDevice) != S_OK)
+ {
+ wxLogSysError(wxT("Could not get device interface from HID interface"));
+ return false;
+ }
+
+ //release the plugin
+ (*ppPlugin)->Release(ppPlugin);
+
+ //open the HID interface...
+ if ( (*m_ppDevice)->open(m_ppDevice, 0) != S_OK )
+ wxLogDebug(_T("HID device: open failed"));
+
+ //
+ //Now the hard part - in order to scan things we need "cookies"
+ //
+ CFArrayRef cfaCookies = (CFArrayRef)CFDictionaryGetValue(pDictionary,
+ CFSTR(kIOHIDElementKey));
+ BuildCookies(cfaCookies);
+
+ //cleanup
+ CFRelease(pDictionary);
+ IOObjectRelease(pObject);
+
+ //iterator cleanup
+ IOObjectRelease(pIterator);
+
+ return true;
+ }
+
+ //iterator cleanup
+ IOObjectRelease(pIterator);
+
+ return false; //no device
+}//end Create()
+
+// ----------------------------------------------------------------------------
+// wxHIDDevice::GetCount [static]
+//
+// Obtains the number of devices on a system for a given HID Page (nClass)
+// and HID Usage (nType).
+// ----------------------------------------------------------------------------
+size_t wxHIDDevice::GetCount (int nClass, int nType)
+{
+ //Create the mach port
+ mach_port_t pPort;
+ if(IOMasterPort(bootstrap_port, &pPort) != kIOReturnSuccess)
+ {
+ wxLogSysError(wxT("Could not create mach port"));
+ return false;
+ }
+
+ //Dictionary that will hold first
+ //the matching dictionary for determining which kind of devices we want,
+ //then later some registry properties from an iterator (see below)
+ CFMutableDictionaryRef pDictionary = IOServiceMatching(kIOHIDDeviceKey);
+ if(pDictionary == NULL)
+ {
+ wxLogSysError( _T("IOServiceMatching(kIOHIDDeviceKey) failed") );
+ return false;
+ }
+
+ //Here we'll filter down the services to what we want
+ if (nType != -1)
+ {
+ CFNumberRef pType = CFNumberCreate(kCFAllocatorDefault,
+ kCFNumberIntType, &nType);
+ CFDictionarySetValue(pDictionary, CFSTR(kIOHIDPrimaryUsageKey), pType);
+ CFRelease(pType);
+ }
+ if (nClass != -1)
+ {
+ CFNumberRef pClass = CFNumberCreate(kCFAllocatorDefault,
+ kCFNumberIntType, &nClass);
+ CFDictionarySetValue(pDictionary, CFSTR(kIOHIDPrimaryUsagePageKey), pClass);
+ CFRelease(pClass);
+ }
+
+ //Now get the maching services
+ io_iterator_t pIterator;
+ if( IOServiceGetMatchingServices(pPort,
+ pDictionary, &pIterator) != kIOReturnSuccess )
+ {
+ wxLogSysError(_T("No Matching HID Services"));
+ return false;
+ }
+
+ //If the iterator doesn't exist there are no devices :)
+ if ( !pIterator )
+ return 0;
+
+ //Now we iterate through them
+ size_t nCount = 0;
+ io_object_t pObject;
+ while ( (pObject = IOIteratorNext(pIterator)) != 0)
+ {
+ ++nCount;
+ IOObjectRelease(pObject);
+ }
+
+ //cleanup
+ IOObjectRelease(pIterator);
+ mach_port_deallocate(mach_task_self(), pPort);
+
+ return nCount;
+}//end Create()
+
+// ----------------------------------------------------------------------------
+// wxHIDDevice::AddCookie
+//
+// Adds a cookie to the internal cookie array from a CFType
+// ----------------------------------------------------------------------------
+void wxHIDDevice::AddCookie(CFTypeRef Data, int i)
+{
+ CFNumberGetValue(
+ (CFNumberRef) CFDictionaryGetValue ( (CFDictionaryRef) Data
+ , CFSTR(kIOHIDElementCookieKey)
+ ),
+ kCFNumberIntType,
+ &m_pCookies[i]
+ );
+}
+
+// ----------------------------------------------------------------------------
+// wxHIDDevice::AddCookieInQueue
+//
+// Adds a cookie to the internal cookie array from a CFType and additionally
+// adds it to the internal HID Queue
+// ----------------------------------------------------------------------------
+void wxHIDDevice::AddCookieInQueue(CFTypeRef Data, int i)
+{
+ //3rd Param flags (none yet)
+ AddCookie(Data, i);
+ if ( (*m_ppQueue)->addElement(m_ppQueue, m_pCookies[i], 0) != S_OK )
+ wxLogDebug(_T("HID device: adding element failed"));
+}
+
+// ----------------------------------------------------------------------------
+// wxHIDDevice::InitCookies
+//
+// Create the internal cookie array, optionally creating a HID Queue
+// ----------------------------------------------------------------------------
+void wxHIDDevice::InitCookies(size_t dwSize, bool bQueue)
+{
+ m_pCookies = new IOHIDElementCookie[dwSize];
+ if (bQueue)
+ {
+ wxASSERT( m_ppQueue == NULL);
+ m_ppQueue = (*m_ppDevice)->allocQueue(m_ppDevice);
+ if ( !m_ppQueue )
+ {
+ wxLogDebug(_T("HID device: allocQueue failed"));
+ return;
+ }
+
+ //Param 2, flags, none yet
+ if ( (*m_ppQueue)->create(m_ppQueue, 0, 512) != S_OK )
+ {
+ wxLogDebug(_T("HID device: create failed"));
+ }
+ }
+
+ //make sure that cookie array is clear
+ memset(m_pCookies, 0, sizeof(*m_pCookies) * dwSize);
+}
+
+// ----------------------------------------------------------------------------
+// wxHIDDevice::IsActive
+//
+// Returns true if a cookie of the device is active - for example if a key is
+// held down, joystick button pressed, caps lock active, etc..
+// ----------------------------------------------------------------------------
+bool wxHIDDevice::IsActive(int nIndex)
+{
+ if(!HasElement(nIndex))
+ {
+ //cookie at index does not exist - getElementValue
+ //could return true which would be incorrect so we
+ //check here
+ return false;
+ }
+
+ IOHIDEventStruct Event;
+ (*m_ppDevice)->getElementValue(m_ppDevice, m_pCookies[nIndex], &Event);
+ return !!Event.value;
+}
+
+// ----------------------------------------------------------------------------
+// wxHIDDevice::HasElement
+//
+// Returns true if the element in the internal cookie array exists
+// ----------------------------------------------------------------------------
+bool wxHIDDevice::HasElement(int nIndex)
+{
+ return m_pCookies[nIndex] != NULL;
+}
+
+// ----------------------------------------------------------------------------
+// wxHIDDevice Destructor
+//
+// Frees all memory and objects from the structure
+// ----------------------------------------------------------------------------
+wxHIDDevice::~wxHIDDevice()
+{
+ if (m_ppDevice != NULL)
+ {
+ if (m_ppQueue != NULL)
+ {
+ (*m_ppQueue)->stop(m_ppQueue);
+ (*m_ppQueue)->dispose(m_ppQueue);
+ (*m_ppQueue)->Release(m_ppQueue);
+ }
+ (*m_ppDevice)->close(m_ppDevice);
+ (*m_ppDevice)->Release(m_ppDevice);
+ mach_port_deallocate(mach_task_self(), m_pPort);
+ }
+
+ if (m_pCookies != NULL)
+ {
+ delete [] m_pCookies;
+ }
+}
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//
+// wxHIDKeyboard
+//
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//There are no right shift, alt etc. in the wx headers yet so just sort
+//of "define our own" for now
+enum
+{
+ WXK_RSHIFT = 400,
+ WXK_RALT,
+ WXK_RCONTROL,
+ WXK_RMENU
+};
+
+// ----------------------------------------------------------------------------
+// wxHIDKeyboard::GetCount [static]
+//
+// Get number of HID keyboards available
+// ----------------------------------------------------------------------------
+int wxHIDKeyboard::GetCount()
+{
+ return wxHIDDevice::GetCount(kHIDPage_GenericDesktop,
+ kHIDUsage_GD_Keyboard);
+}
+
+// ----------------------------------------------------------------------------
+// wxHIDKeyboard::Create
+//
+// Create the HID Keyboard
+// ----------------------------------------------------------------------------
+bool wxHIDKeyboard::Create(int nDev /* = 1*/)
+{
+ return wxHIDDevice::Create(kHIDPage_GenericDesktop,
+ kHIDUsage_GD_Keyboard,
+ nDev);
+}
+
+// ----------------------------------------------------------------------------
+// wxHIDKeyboard::AddCookie
+//
+// Overloaded version of wxHIDDevice::AddCookie that simply does not
+// add a cookie if a duplicate is found
+// ----------------------------------------------------------------------------
+void wxHIDKeyboard::AddCookie(CFTypeRef Data, int i)
+{
+ if(!HasElement(i))
+ wxHIDDevice::AddCookie(Data, i);
+}
+
+// ----------------------------------------------------------------------------
+// wxHIDKeyboard::BuildCookies
+//
+// Callback from Create() to build the HID cookies for the internal cookie
+// array
+// ----------------------------------------------------------------------------
+void wxHIDKeyboard::BuildCookies(CFArrayRef Array)
+{
+ //Create internal cookie array
+ InitCookies(500);
+
+ //Begin recursing in array
+ DoBuildCookies(Array);
+}
+
+void wxHIDKeyboard::DoBuildCookies(CFArrayRef Array)
+{
+ //Now go through each possible cookie
+ int i,
+ nUsage;
+// bool bEOTriggered = false;
+ for (i = 0; i < CFArrayGetCount(Array); ++i)
+ {
+ const void* ref = CFDictionaryGetValue(
+ (CFDictionaryRef)CFArrayGetValueAtIndex(Array, i),
+ CFSTR(kIOHIDElementKey)
+ );
+
+ if (ref != NULL)
+ {
+ DoBuildCookies((CFArrayRef) ref);
+ }
+ else
+ {
+
+ //
+ // Get the usage #
+ //
+ CFNumberGetValue(
+ (CFNumberRef)
+ CFDictionaryGetValue((CFDictionaryRef)
+ CFArrayGetValueAtIndex(Array, i),
+ CFSTR(kIOHIDElementUsageKey)
+ ),
+ kCFNumberLongType,
+ &nUsage);
+
+ //
+ // Now translate the usage # into a wx keycode
+ //
+
+ //
+ // OK, this is strange - basically this kind of strange -
+ // Starting from 0xEO these elements (like shift) appear twice in
+ // the array! The ones at the end are bogus I guess - the funny part
+ // is that besides the fact that the ones at the front have a Unit
+ // and UnitExponent key with a value of 0 and a different cookie value,
+ // there is no discernable difference between the two...
+ //
+ // Will the real shift please stand up?
+ //
+ // Something to spend a support request on, if I had one, LOL.
+ //
+ //if(nUsage == 0xE0)
+ //{
+ // if(bEOTriggered)
+ // break;
+ // bEOTriggered = true;
+ //}
+ //Instead of that though we now just don't add duplicate keys
+
+ if (nUsage >= kHIDUsage_KeyboardA && nUsage <= kHIDUsage_KeyboardZ)
+ AddCookie(CFArrayGetValueAtIndex(Array, i), 'A' + (nUsage - kHIDUsage_KeyboardA) );
+ else if (nUsage >= kHIDUsage_Keyboard1 && nUsage <= kHIDUsage_Keyboard9)
+ AddCookie(CFArrayGetValueAtIndex(Array, i), '1' + (nUsage - kHIDUsage_Keyboard1) );
+ else if (nUsage >= kHIDUsage_KeyboardF1 && nUsage <= kHIDUsage_KeyboardF12)
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_F1 + (nUsage - kHIDUsage_KeyboardF1) );
+ else if (nUsage >= kHIDUsage_KeyboardF13 && nUsage <= kHIDUsage_KeyboardF24)
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_F13 + (nUsage - kHIDUsage_KeyboardF13) );
+ else if (nUsage >= kHIDUsage_Keypad1 && nUsage <= kHIDUsage_Keypad9)
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_NUMPAD1 + (nUsage - kHIDUsage_Keypad1) );
+ else switch (nUsage)
+ {
+ //0's (wx & ascii go 0-9, but HID goes 1-0)
+ case kHIDUsage_Keyboard0:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), '0');
+ break;
+ case kHIDUsage_Keypad0:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_NUMPAD0);
+ break;
+
+ //Basic
+ case kHIDUsage_KeyboardReturnOrEnter:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_RETURN);
+ break;
+ case kHIDUsage_KeyboardEscape:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_ESCAPE);
+ break;
+ case kHIDUsage_KeyboardDeleteOrBackspace:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_BACK);
+ break;
+ case kHIDUsage_KeyboardTab:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_TAB);
+ break;
+ case kHIDUsage_KeyboardSpacebar:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_SPACE);
+ break;
+ case kHIDUsage_KeyboardPageUp:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_PAGEUP);
+ break;
+ case kHIDUsage_KeyboardEnd:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_END);
+ break;
+ case kHIDUsage_KeyboardPageDown:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_PAGEDOWN);
+ break;
+ case kHIDUsage_KeyboardRightArrow:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_RIGHT);
+ break;
+ case kHIDUsage_KeyboardLeftArrow:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_LEFT);
+ break;
+ case kHIDUsage_KeyboardDownArrow:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_DOWN);
+ break;
+ case kHIDUsage_KeyboardUpArrow:
+ AddCookie(CFArrayGetValueAtIndex(Array, i), WXK_UP);
+ break;
+
+ //LEDS
+ case kHIDUsage_KeyboardCapsLock:
+ AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_CAPITAL);
+ break;
+ case kHIDUsage_KeypadNumLock:
+ AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_NUMLOCK);
+ break;
+ case kHIDUsage_KeyboardScrollLock:
+ AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_SCROLL);
+ break;
+
+ //Menu keys, Shift, other specials
+ case kHIDUsage_KeyboardLeftControl:
+ AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_CONTROL);
+ break;
+ case kHIDUsage_KeyboardLeftShift:
+ AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_SHIFT);
+ break;
+ case kHIDUsage_KeyboardLeftAlt:
+ AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_ALT);
+ break;
+ case kHIDUsage_KeyboardLeftGUI:
+ AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_MENU);
+ break;
+ case kHIDUsage_KeyboardRightControl:
+ AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_RCONTROL);
+ break;
+ case kHIDUsage_KeyboardRightShift:
+ AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_RSHIFT);
+ break;
+ case kHIDUsage_KeyboardRightAlt:
+ AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_RALT);
+ break;
+ case kHIDUsage_KeyboardRightGUI:
+ AddCookie(CFArrayGetValueAtIndex(Array, i),WXK_RMENU);
+ break;
+
+ //Default
+ default:
+ //not in wx keycodes - do nothing....
+ break;
+ } //end mightly long switch
+ } //end if the current element is not an array...
+ } //end for loop for Array
+}//end buildcookies
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//
+// wxHIDModule
+//
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+class wxHIDModule : public wxModule
+{
+ DECLARE_DYNAMIC_CLASS(wxHIDModule)
+
+ public:
+ static wxArrayPtrVoid sm_keyboards;
+ virtual bool OnInit()
+ {
+ return true;
+ }
+ virtual void OnExit()
+ {
+ for(size_t i = 0; i < sm_keyboards.GetCount(); ++i)
+ delete (wxHIDKeyboard*) sm_keyboards[i];
+ }
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxHIDModule, wxModule)
+
+wxArrayPtrVoid wxHIDModule::sm_keyboards;
+
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//
+// wxGetKeyState()
+//
+// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+bool wxGetKeyState (wxKeyCode key)
+{
+ wxASSERT_MSG(key != WXK_LBUTTON && key != WXK_RBUTTON && key !=
+ WXK_MBUTTON, wxT("can't use wxGetKeyState() for mouse buttons"));
+
+ if (wxHIDModule::sm_keyboards.GetCount() == 0)
+ {
+ int nKeyboards = wxHIDKeyboard::GetCount();
+
+ for(int i = 1; i <= nKeyboards; ++i)
+ {
+ wxHIDKeyboard* keyboard = new wxHIDKeyboard();
+ if(keyboard->Create(i))
+ {
+ wxHIDModule::sm_keyboards.Add(keyboard);
+ }
+ else
+ {
+ delete keyboard;
+ break;
+ }
+ }
+
+ wxASSERT_MSG(wxHIDModule::sm_keyboards.GetCount() != 0,
+ wxT("No keyboards found!"));
+ }
+
+ for(size_t i = 0; i < wxHIDModule::sm_keyboards.GetCount(); ++i)
+ {
+ wxHIDKeyboard* keyboard = (wxHIDKeyboard*)
+ wxHIDModule::sm_keyboards[i];
+
+ switch(key)
+ {
+ case WXK_SHIFT:
+ if( keyboard->IsActive(WXK_SHIFT) ||
+ keyboard->IsActive(WXK_RSHIFT) )
+ {
+ return true;
+ }
+ break;
+ case WXK_ALT:
+ if( keyboard->IsActive(WXK_ALT) ||
+ keyboard->IsActive(WXK_RALT) )
+ {
+ return true;
+ }
+ break;
+ case WXK_CONTROL:
+ if( keyboard->IsActive(WXK_CONTROL) ||
+ keyboard->IsActive(WXK_RCONTROL) )
+ {
+ return true;
+ }
+ break;
+ case WXK_MENU:
+ if( keyboard->IsActive(WXK_MENU) ||
+ keyboard->IsActive(WXK_RMENU) )
+ {
+ return true;
+ }
+ break;
+ default:
+ if( keyboard->IsActive(key) )
+ {
+ return true;
+ }
+ break;
+ }
+ }
+
+ return false; //not down/error
+}
+
+#endif //__DARWIN__
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: src/mac/corefoundation/joystick.cpp
+// Purpose: wxJoystick class
+// Author: Ryan Norton
+// Modified by:
+// Created: 2/13/2005
+// RCS-ID: $Id$
+// Copyright: (c) Ryan Norton
+// Licence: wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+//===========================================================================
+// DECLARATIONS
+//===========================================================================
+
+//---------------------------------------------------------------------------
+// Pre-compiled header stuff
+//---------------------------------------------------------------------------
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+//---------------------------------------------------------------------------
+// Guard
+//---------------------------------------------------------------------------
+
+//we only support HID on OSX (DARWIN), since it requires DARWIN...
+#if wxUSE_JOYSTICK && wxUSE_THREADS
+
+//---------------------------------------------------------------------------
+// Includes
+//---------------------------------------------------------------------------
+
+#ifndef WX_PRECOMP
+ #include "wx/log.h"
+ #include "wx/event.h" //joystick wxEvents
+ #include "wx/window.h" //for wxWindow to "capture" joystick
+#endif
+
+#include "wx/joystick.h" //...
+#include "wx/thread.h" //wxThread for polling thread/ wxCriticalSection
+
+//private headers
+#include "wx/mac/corefoundation/hid.h" //private mac hid stuff
+
+//mac headers
+#include <CoreServices/CoreServices.h>
+#include <mach/mach.h>
+#include <mach/mach_time.h>
+#include <unistd.h>
+
+//---------------------------------------------------------------------------
+// Definitions/Enumerations
+//---------------------------------------------------------------------------
+
+#define wxJS_MAX_AXES 10 /*max number of axes*/
+#define wxJS_MAX_BUTTONS 40 /*max number of buttons*/
+
+enum
+{
+ //These are positions within the cookie array
+ //in wxHIDJoystick that the cookies that store the axis' are
+ wxJS_AXIS_X = 40,
+ wxJS_AXIS_Y,
+ wxJS_AXIS_Z,
+ wxJS_AXIS_RUDDER,
+ wxJS_AXIS_U,
+ wxJS_AXIS_V,
+};
+
+//---------------------------------------------------------------------------
+// wxHIDJoystick
+//---------------------------------------------------------------------------
+class wxHIDJoystick : public wxHIDDevice
+{
+public:
+ wxHIDJoystick();
+ virtual ~wxHIDJoystick();
+
+ bool Create(int nWhich);
+ virtual void BuildCookies(CFArrayRef Array);
+ void MakeCookies(CFArrayRef Array);
+ IOHIDElementCookie* GetCookies();
+ IOHIDQueueInterface** GetQueue();
+
+ int m_nXMax, m_nYMax, m_nZMax, m_nRudderMax, m_nUMax, m_nVMax,
+ m_nXMin, m_nYMin, m_nZMin, m_nRudderMin, m_nUMin, m_nVMin;
+
+ friend class wxJoystick;
+};
+
+//---------------------------------------------------------------------------
+// wxJoystickThread
+//---------------------------------------------------------------------------
+class wxJoystickThread : public wxThread
+{
+public:
+ wxJoystickThread(wxHIDJoystick* hid, int joystick);
+ void* Entry();
+ static void HIDCallback(void* target, IOReturn res, void* context, void* sender);
+
+private:
+ wxHIDJoystick* m_hid;
+ int m_joystick;
+ wxPoint m_lastposition;
+ int m_axe[wxJS_MAX_AXES];
+ int m_buttons;
+ wxWindow* m_catchwin;
+ int m_polling;
+
+ friend class wxJoystick;
+};
+
+//===========================================================================
+// IMPLEMENTATION
+//===========================================================================
+
+//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+// wxGetIntFromCFDictionary
+//
+// Helper function that gets a integer from a dictionary key
+//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+void wxGetIntFromCFDictionary(CFTypeRef cfDict, CFStringRef key, int* pOut)
+{
+ CFNumberGetValue(
+ (CFNumberRef) CFDictionaryGetValue((CFDictionaryRef) cfDict,
+ key),
+ kCFNumberIntType, pOut);
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//
+// wxJoystick
+//
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject)
+
+//---------------------------------------------------------------------------
+// wxJoystick Constructor
+//
+// 1) Initializes member variables
+// 2) Attempts to create the native HID joystick implementation - if none
+// could be found (no joysticks, etc.) then it sets it to NULL
+//---------------------------------------------------------------------------
+wxJoystick::wxJoystick(int joystick)
+ : m_joystick(joystick),
+ m_thread(NULL)
+{
+ m_hid = new wxHIDJoystick();
+
+ if (m_hid->Create(m_joystick+1)) //wxHIDDevice is 1-based while this is 0
+ {
+ m_thread = new wxJoystickThread(m_hid, m_joystick);
+ m_thread->Create();
+ m_thread->Run();
+ }
+ else
+ {
+ delete m_hid;
+ m_hid = NULL;
+ }
+}
+
+//---------------------------------------------------------------------------
+// wxJoystick Destructor
+//
+// Releases the capture of the thread, deletes it, and deletes
+// the native implementation.
+//---------------------------------------------------------------------------
+wxJoystick::~wxJoystick()
+{
+ ReleaseCapture();
+ if (m_thread)
+ m_thread->Delete(); // It's detached so it will delete itself
+
+ if (m_hid)
+ delete m_hid;
+}
+
+//---------------------------------------------------------------------------
+// wxJoystick::Get[XXX]Position
+//
+// Returns the value of an axis that was polled from the thread. In the
+// case of GetPosition returns the X and Y values in a wxPoint
+//---------------------------------------------------------------------------
+wxPoint wxJoystick::GetPosition() const
+{
+ wxPoint pos(wxDefaultPosition);
+ if (m_thread) pos = m_thread->m_lastposition;
+ return pos;
+}
+int wxJoystick::GetZPosition() const
+{
+ if (m_thread)
+ return m_thread->m_axe[wxJS_AXIS_Z];
+ return 0;
+}
+int wxJoystick::GetRudderPosition() const
+{
+ if (m_thread)
+ return m_thread->m_axe[wxJS_AXIS_RUDDER];
+ return 0;
+}
+int wxJoystick::GetUPosition() const
+{
+ if (m_thread)
+ return m_thread->m_axe[wxJS_AXIS_U];
+ return 0;
+}
+int wxJoystick::GetVPosition() const
+{
+ if (m_thread)
+ return m_thread->m_axe[wxJS_AXIS_V];
+ return 0;
+}
+
+//---------------------------------------------------------------------------
+// wxJoystick::GetButtonState
+//
+// Returns the state of the buttons in a bitmask as dictated by the
+// wx manual (the real work takes place in the thread, as always)
+//---------------------------------------------------------------------------
+int wxJoystick::GetButtonState() const
+{
+ if (m_thread)
+ return m_thread->m_buttons;
+ return 0;
+}
+
+//---------------------------------------------------------------------------
+// wxJoystick::IsOk
+//
+// Returns whether the joystick initialized successfully - in this case
+// if the native implementation doesn't exist (in constructor)
+//---------------------------------------------------------------------------
+bool wxJoystick::IsOk() const
+{
+ return m_hid != NULL;
+}
+
+//---------------------------------------------------------------------------
+// wxJoystick::Get[XXX](Id/Name)
+//
+// Simple accessors to the native HID implementation
+//---------------------------------------------------------------------------
+int wxJoystick::GetManufacturerId() const
+{
+ return m_hid->m_nManufacturerId;
+}
+
+int wxJoystick::GetProductId() const
+{
+ return m_hid->m_nProductId;
+}
+
+wxString wxJoystick::GetProductName() const
+{
+ return m_hid->m_szProductName;
+}
+
+//---------------------------------------------------------------------------
+// wxJoystick::GetNumberButtons
+// wxJoystick::GetNumberAxes
+//
+// Queries the joystick for an active number of buttons/axes.
+//
+// In the native HID implementation, the cookies:
+// 0-40 are the buttons of the joystick
+// 40-50 are the axes of the joystick
+//
+// These just query the native HID implementation as above.
+//---------------------------------------------------------------------------
+int wxJoystick::GetNumberButtons() const
+{
+ int nCount = 0;
+
+ for(int nIndex = 0; nIndex < 40; ++nIndex)
+ {
+ if(m_hid->HasElement(nIndex))
+ ++nCount;
+ }
+
+ return nCount;
+}
+int wxJoystick::GetNumberAxes() const
+{
+ int nCount = 0;
+
+ for(int nIndex = 40; nIndex < 50; ++nIndex)
+ {
+ if(m_hid->HasElement(nIndex))
+ ++nCount;
+ }
+
+ return nCount;
+}
+
+//---------------------------------------------------------------------------
+// wxJoystick::GetNumberJoysticks
+//
+// Gets the number of joysticks on the system. In HID that
+// is all devices with the kHIDUsage_GD_Joystick or kHIDUsage_GD_GamePad
+// identifiers.
+//---------------------------------------------------------------------------
+int wxJoystick::GetNumberJoysticks()
+{
+ return
+ wxHIDDevice::GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_Joystick) +
+ wxHIDDevice::GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_GamePad);
+}
+
+//---------------------------------------------------------------------------
+// wxJoystick::SetCapture
+//
+// Stops sending events from the thread to the window set in
+// SetCapture and stops polling the joystick
+//---------------------------------------------------------------------------
+bool wxJoystick::SetCapture(wxWindow* win, int pollingFreq)
+{
+ if (m_thread)
+ {
+ m_thread->m_catchwin = win;
+ m_thread->m_polling = pollingFreq;
+ return true;
+ }
+ return false;
+}
+
+//---------------------------------------------------------------------------
+// wxJoystick::ReleaseCapture
+//
+// Stops sending events from the thread to the window set in
+// SetCapture and stops polling the joystick
+//---------------------------------------------------------------------------
+bool wxJoystick::ReleaseCapture()
+{
+ if (m_thread)
+ {
+ m_thread->m_catchwin = NULL;
+ m_thread->m_polling = 0;
+ return true;
+ }
+ return false;
+}
+
+//---------------------------------------------------------------------------
+// wxJoystick::Get[XXX]
+//
+// Gets the minimum and maximum values for each axis, returning 0 if the
+// axis doesn't exist.
+//---------------------------------------------------------------------------
+int wxJoystick::GetXMin() const
+{
+ return m_hid->m_nXMin;
+}
+
+int wxJoystick::GetYMin() const
+{
+ return m_hid->m_nYMin;
+}
+
+int wxJoystick::GetZMin() const
+{
+ return m_hid->m_nZMin;
+}
+
+int wxJoystick::GetRudderMin() const
+{
+ return m_hid->m_nRudderMin;
+}
+
+int wxJoystick::GetUMin() const
+{
+ return m_hid->m_nUMin;
+}
+
+int wxJoystick::GetVMin() const
+{
+ return m_hid->m_nVMin;
+}
+
+int wxJoystick::GetXMax() const
+{
+ return m_hid->m_nXMax;
+}
+
+int wxJoystick::GetYMax() const
+{
+ return m_hid->m_nYMax;
+}
+
+int wxJoystick::GetZMax() const
+{
+ return m_hid->m_nZMax;
+}
+
+int wxJoystick::GetRudderMax() const
+{
+ return m_hid->m_nRudderMax;
+}
+
+int wxJoystick::GetUMax() const
+{
+ return m_hid->m_nUMax;
+}
+
+int wxJoystick::GetVMax() const
+{
+ return m_hid->m_nVMax;
+}
+
+//---------------------------------------------------------------------------
+// wxJoystick::Get[XXX]
+//
+// Min/Max values for buttons, axes, etc.. Polling in this case is just
+// what the linux port has.
+//---------------------------------------------------------------------------
+int wxJoystick::GetMaxButtons() const
+{
+ return wxJS_MAX_BUTTONS;
+}
+
+int wxJoystick::GetMaxAxes() const
+{
+ return wxJS_MAX_AXES;
+}
+
+int wxJoystick::GetPollingMin() const
+{
+ return 10;
+}
+
+int wxJoystick::GetPollingMax() const
+{
+ return 1000;
+}
+
+//---------------------------------------------------------------------------
+// wxJoystick::Has[XXX]
+//
+// Just queries the native hid implementation if the cookie was found
+// when enumerating the cookies of the joystick device
+//---------------------------------------------------------------------------
+bool wxJoystick::HasZ() const
+{
+ return m_hid->HasElement(wxJS_AXIS_Z);
+}
+
+bool wxJoystick::HasRudder() const
+{
+ return m_hid->HasElement(wxJS_AXIS_RUDDER);
+}
+
+bool wxJoystick::HasU() const
+{
+ return m_hid->HasElement(wxJS_AXIS_U);
+}
+
+bool wxJoystick::HasV() const
+{
+ return m_hid->HasElement(wxJS_AXIS_V);
+}
+
+//---------------------------------------------------------------------------
+// UNSUPPORTED
+//---------------------------------------------------------------------------
+int wxJoystick::GetPOVPosition() const
+{
+ return -1;
+}
+
+int wxJoystick::GetPOVCTSPosition() const
+{
+ return -1;
+}
+
+int wxJoystick::GetMovementThreshold() const
+{
+ return 0;
+}
+
+void wxJoystick::SetMovementThreshold(int WXUNUSED(threshold))
+{
+}
+
+bool wxJoystick::HasPOV() const
+{
+ return false;
+}
+
+bool wxJoystick::HasPOV4Dir() const
+{
+ return false;
+}
+
+bool wxJoystick::HasPOVCTS() const
+{
+ return false;
+}
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//
+// wxHIDJoystick
+//
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//---------------------------------------------------------------------------
+// wxHIDJoystick ctor
+//
+// Initializes the min/max members
+//---------------------------------------------------------------------------
+wxHIDJoystick::wxHIDJoystick() :
+ m_nXMax(0), m_nYMax(0), m_nZMax(0), m_nRudderMax(0), m_nUMax(0), m_nVMax(0),
+ m_nXMin(0), m_nYMin(0), m_nZMin(0), m_nRudderMin(0), m_nUMin(0), m_nVMin(0)
+{
+}
+
+//---------------------------------------------------------------------------
+// wxHIDJoystick dtor
+//
+// Nothing...
+//---------------------------------------------------------------------------
+wxHIDJoystick::~wxHIDJoystick()
+{
+}
+
+//---------------------------------------------------------------------------
+// wxHIDJoystick::Create
+//
+// Creates the native HID device (joysticks are of either
+// kHIDUsage_GD_Joystick or kHIDUsage_GD_GamePad)
+//---------------------------------------------------------------------------
+bool wxHIDJoystick::Create(int nWhich)
+{
+ int nJoysticks = GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_Joystick);
+
+ if (nWhich <= nJoysticks)
+ return wxHIDDevice::Create(kHIDPage_GenericDesktop,
+ kHIDUsage_GD_Joystick,
+ nWhich);
+ else
+ nWhich -= nJoysticks;
+
+ int nGamePads = GetCount(kHIDPage_GenericDesktop, kHIDUsage_GD_GamePad);
+
+ if (nWhich <= nGamePads)
+ return wxHIDDevice::Create(kHIDPage_GenericDesktop,
+ kHIDUsage_GD_GamePad,
+ nWhich);
+ else
+ return false;
+}
+
+//---------------------------------------------------------------------------
+// wxHIDJoystick::BuildCookies
+// wxHIDJoystick::MakeCookies
+//
+// Sets up the cookies for the HID device (called from Create) - as
+// mentioned 0-40 are the buttons and 40-50 are the axes.
+//
+// MakeCookies is just a recursive function for each array within
+// BuildCookies.
+//---------------------------------------------------------------------------
+void wxHIDJoystick::BuildCookies(CFArrayRef Array)
+{
+ InitCookies(50, true);
+
+ //
+ // I wasted two hours of my life on this line :(
+ // accidently removed it during some source cleaning...
+ //
+ MakeCookies(Array);
+
+ //paranoid debugging stuff
+#if 0
+ for(int i = 0; i < 50; ++i)
+ wxPrintf(wxT("\nVAL #%i:[%i]"), i, m_pCookies[i]);
+#endif
+}//end buildcookies
+
+void wxHIDJoystick::MakeCookies(CFArrayRef Array)
+{
+ int i, nUsage, nPage;
+
+ for (i = 0; i < CFArrayGetCount(Array); ++i)
+ {
+ const void* ref = CFDictionaryGetValue(
+ (CFDictionaryRef)CFArrayGetValueAtIndex(Array, i),
+ CFSTR(kIOHIDElementKey)
+ );
+
+ if (ref != NULL)
+ {
+ MakeCookies((CFArrayRef) ref);
+ }
+ else
+ {
+ CFNumberGetValue(
+ (CFNumberRef)
+ CFDictionaryGetValue(
+ (CFDictionaryRef) CFArrayGetValueAtIndex(Array, i),
+ CFSTR(kIOHIDElementUsageKey)
+ ),
+ kCFNumberIntType,
+ &nUsage );
+
+ CFNumberGetValue(
+ (CFNumberRef)
+ CFDictionaryGetValue(
+ (CFDictionaryRef) CFArrayGetValueAtIndex(Array, i),
+ CFSTR(kIOHIDElementUsagePageKey)
+ ),
+ kCFNumberIntType,
+ &nPage );
+
+#if 0
+ wxLogSysError(wxT("[%i][%i]"), nUsage, nPage);
+#endif
+ if (nPage == kHIDPage_Button && nUsage <= 40)
+ AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), nUsage-1 );
+ else if (nPage == kHIDPage_GenericDesktop)
+ {
+ //axis...
+ switch(nUsage)
+ {
+ case kHIDUsage_GD_X:
+ AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), wxJS_AXIS_X);
+ wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
+ CFSTR(kIOHIDElementMaxKey),
+ &m_nXMax);
+ wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
+ CFSTR(kIOHIDElementMinKey),
+ &m_nXMin);
+ break;
+ case kHIDUsage_GD_Y:
+ AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), wxJS_AXIS_Y);
+ wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
+ CFSTR(kIOHIDElementMaxKey),
+ &m_nYMax);
+ wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
+ CFSTR(kIOHIDElementMinKey),
+ &m_nYMin);
+ break;
+ case kHIDUsage_GD_Z:
+ AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), wxJS_AXIS_Z);
+ wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
+ CFSTR(kIOHIDElementMaxKey),
+ &m_nZMax);
+ wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
+ CFSTR(kIOHIDElementMinKey),
+ &m_nZMin);
+ break;
+ default:
+ break;
+ }
+ }
+ else if (nPage == kHIDPage_Simulation && nUsage == kHIDUsage_Sim_Rudder)
+ {
+ //rudder...
+ AddCookieInQueue(CFArrayGetValueAtIndex(Array, i), wxJS_AXIS_RUDDER );
+ wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
+ CFSTR(kIOHIDElementMaxKey),
+ &m_nRudderMax);
+ wxGetIntFromCFDictionary(CFArrayGetValueAtIndex(Array, i),
+ CFSTR(kIOHIDElementMinKey),
+ &m_nRudderMin);
+ }
+ }
+ }
+}
+
+//---------------------------------------------------------------------------
+// wxHIDJoystick::Get[XXX]
+//
+// Simple accessors so that the HID callback and the thread procedure
+// can access members from wxHIDDevice (our parent here).
+//---------------------------------------------------------------------------
+IOHIDElementCookie* wxHIDJoystick::GetCookies()
+{ return m_pCookies; }
+IOHIDQueueInterface** wxHIDJoystick::GetQueue()
+{ return m_ppQueue; }
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//
+// wxJoystickThread
+//
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+
+//---------------------------------------------------------------------------
+// wxJoystickThread Constructor
+//
+// Just initializes members
+//---------------------------------------------------------------------------
+wxJoystickThread::wxJoystickThread(wxHIDJoystick* hid, int joystick)
+ : m_hid(hid),
+ m_joystick(joystick),
+ m_lastposition(127,127),
+ m_buttons(0),
+ m_catchwin(NULL),
+ m_polling(0)
+{
+ memset(m_axe, 0, sizeof(int) * wxJS_MAX_AXES);
+}
+
+//---------------------------------------------------------------------------
+// wxJoystickThread::Entry
+//
+// Thread procedure
+//
+// Runs a CFRunLoop for polling. Basically, it sets the HID queue to
+// call wxJoystickThread::HIDCallback in the context of this thread
+// when something changes on the device. It polls as long as the user
+// wants, or a certain amount if the user wants to "block". Note that
+// we don't actually block here since this is in a secondary thread.
+//---------------------------------------------------------------------------
+void* wxJoystickThread::Entry()
+{
+ CFRunLoopSourceRef pRLSource = NULL;
+
+ if ((*m_hid->GetQueue())->createAsyncEventSource(
+ m_hid->GetQueue(), &pRLSource) != kIOReturnSuccess )
+ {
+ wxLogSysError(wxT("Couldn't create async event source"));
+ return NULL;
+ }
+
+ wxASSERT(pRLSource != NULL);
+
+ //attach runloop source to main run loop in thread
+ CFRunLoopRef pRL = CFRunLoopGetCurrent();
+ CFRunLoopAddSource(pRL, pRLSource, kCFRunLoopDefaultMode);
+ wxASSERT( CFRunLoopContainsSource(pRL, pRLSource, kCFRunLoopDefaultMode) );
+
+
+ if( (*m_hid->GetQueue())->setEventCallout(m_hid->GetQueue(),
+ wxJoystickThread::HIDCallback, this, this) != kIOReturnSuccess )
+ {
+ wxLogSysError(wxT("Could not set event callout for queue"));
+ return NULL;
+ }
+
+ if( (*m_hid->GetQueue())->start(m_hid->GetQueue()) != kIOReturnSuccess )
+ {
+ wxLogSysError(wxT("Could not start queue"));
+ return NULL;
+ }
+
+ double dTime;
+
+ while(true)
+ {
+ if (TestDestroy())
+ break;
+
+ if (m_polling)
+ dTime = 0.0001 * m_polling;
+ else
+ dTime = 0.0001 * 10; // check at least every 10 msec in "blocking" case
+
+ //true just "handles and returns" - false forces it to stay the time
+ //amount
+#if 1
+ CFRunLoopRunInMode(kCFRunLoopDefaultMode, dTime, true);
+#else
+ IOReturn ret = NULL;
+ HIDCallback(this, ret, this, this);
+ Sleep(3000);
+#endif
+ }
+
+ wxASSERT( CFRunLoopContainsSource(pRL, pRLSource, kCFRunLoopDefaultMode) );
+
+ CFRunLoopRemoveSource(pRL, pRLSource, kCFRunLoopDefaultMode);
+ CFRelease(pRLSource);
+
+ return NULL;
+}
+
+//---------------------------------------------------------------------------
+// wxJoystickThread::HIDCallback (static)
+//
+// Callback for the native HID device when it recieves input.
+//
+// This is where the REAL dirty work gets done.
+//
+// 1) Loops through each event the queue has recieved
+// 2) First, checks if the thread that is running the loop for
+// the polling has ended - if so it breaks out
+// 3) Next, it checks if there was an error getting this event from
+// the HID queue, if there was, it logs an error and returns
+// 4) Now it does the real dirty work by getting the button states
+// from cookies 0-40 and axes positions/states from cookies 40-50
+// in the native HID device by quering cookie values.
+// 5) Sends the event to the polling window (if any)
+// 6) Gets the next event and goes back to (1)
+//---------------------------------------------------------------------------
+/*static*/ void wxJoystickThread::HIDCallback(void* WXUNUSED(target),
+ IOReturn WXUNUSED(res),
+ void* context,
+ void* WXUNUSED(sender))
+{
+ IOHIDEventStruct hidevent;
+ AbsoluteTime bogustime = {0,0};
+ IOReturn ret;
+ wxJoystickThread* pThis = (wxJoystickThread*) context;
+ wxHIDJoystick* m_hid = pThis->m_hid;
+
+ //Get the "first" event from the queue
+ //bogustime tells it we don't care at what time to start
+ //where it gets the next from
+ ret = (*m_hid->GetQueue())->getNextEvent(m_hid->GetQueue(),
+ &hidevent, bogustime, 0);
+
+ while (ret != kIOReturnUnderrun)
+ {
+ if (pThis->TestDestroy())
+ break;
+
+ if(ret != kIOReturnSuccess)
+ {
+ wxLogSysError(wxString::Format(wxT("wxJoystick Error:[%i]"), ret));
+ return;
+ }
+
+ wxJoystickEvent wxevent;
+
+ //Find the cookie that changed
+ int nIndex = 0;
+ IOHIDElementCookie* pCookies = m_hid->GetCookies();
+ while(nIndex < 50)
+ {
+ if(hidevent.elementCookie == pCookies[nIndex])
+ break;
+
+ ++nIndex;
+ }
+
+ //debugging stuff
+#if 0
+ if(nIndex == 50)
+ {
+ wxLogSysError(wxString::Format(wxT("wxJoystick Out Of Bounds Error")));
+ break;
+ }
+#endif
+
+ //is the cookie a button?
+ if (nIndex < 40)
+ {
+ if (hidevent.value)
+ {
+ pThis->m_buttons |= (1 << nIndex);
+ wxevent.SetEventType(wxEVT_JOY_BUTTON_DOWN);
+ }
+ else
+ {
+ pThis->m_buttons &= ~(1 << nIndex);
+ wxevent.SetEventType(wxEVT_JOY_BUTTON_UP);
+ }
+
+ wxevent.SetButtonChange(nIndex+1);
+ }
+ else if (nIndex == wxJS_AXIS_X)
+ {
+ pThis->m_lastposition.x = hidevent.value;
+ wxevent.SetEventType(wxEVT_JOY_MOVE);
+ pThis->m_axe[0] = hidevent.value;
+ }
+ else if (nIndex == wxJS_AXIS_Y)
+ {
+ pThis->m_lastposition.y = hidevent.value;
+ wxevent.SetEventType(wxEVT_JOY_MOVE);
+ pThis->m_axe[1] = hidevent.value;
+ }
+ else if (nIndex == wxJS_AXIS_Z)
+ {
+ wxevent.SetEventType(wxEVT_JOY_ZMOVE);
+ pThis->m_axe[2] = hidevent.value;
+ }
+ else
+ wxevent.SetEventType(wxEVT_JOY_MOVE);
+
+ Nanoseconds timestamp = AbsoluteToNanoseconds(hidevent.timestamp);
+
+ wxULongLong llTime(timestamp.hi, timestamp.lo);
+
+ llTime /= 1000000;
+
+ wxevent.SetTimestamp(llTime.GetValue());
+ wxevent.SetJoystick(pThis->m_joystick);
+ wxevent.SetButtonState(pThis->m_buttons);
+ wxevent.SetPosition(pThis->m_lastposition);
+ wxevent.SetZPosition(pThis->m_axe[2]);
+ wxevent.SetEventObject(pThis->m_catchwin);
+
+ if (pThis->m_catchwin)
+ pThis->m_catchwin->AddPendingEvent(wxevent);
+
+ ret = (*m_hid->GetQueue())->getNextEvent(m_hid->GetQueue(),
+ &hidevent, bogustime, 0);
+ }
+}
+
+#endif // wxUSE_JOYSTICK
--- /dev/null
+///////////////////////////////////////////////////////////////////////////////
+// Name: mac/corefoundation/stdpaths.cpp
+// Purpose: wxStandardPaths implementation for CoreFoundation systems
+// Author: David Elliott
+// Modified by:
+// Created: 2004-10-27
+// RCS-ID: $Id$
+// Copyright: (c) 2004 David Elliott <dfe@cox.net>
+// Licence: wxWindows licence
+///////////////////////////////////////////////////////////////////////////////
+
+// ============================================================================
+// declarations
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// headers
+// ----------------------------------------------------------------------------
+
+#include "wx/wxprec.h"
+
+#if wxUSE_STDPATHS
+
+#ifndef WX_PRECOMP
+ #include "wx/intl.h"
+#endif //ndef WX_PRECOMP
+
+#include "wx/stdpaths.h"
+#include "wx/filename.h"
+#ifdef __WXMAC__
+#include "wx/mac/private.h"
+#endif
+#include "wx/mac/corefoundation/cfstring.h"
+
+#include <CoreFoundation/CFBundle.h>
+#include <CoreFoundation/CFURL.h>
+
+#define kDefaultPathStyle kCFURLPOSIXPathStyle
+
+// ============================================================================
+// implementation
+// ============================================================================
+
+// ----------------------------------------------------------------------------
+// wxStandardPathsCF ctors/dtor
+// ----------------------------------------------------------------------------
+
+wxStandardPathsCF::wxStandardPathsCF()
+ : m_bundle(CFBundleGetMainBundle())
+{
+ CFRetain(m_bundle);
+ UseAppInfo(AppInfo_AppName | AppInfo_VendorName);
+}
+
+wxStandardPathsCF::wxStandardPathsCF(wxCFBundleRef bundle)
+ : m_bundle(bundle)
+{
+ CFRetain(m_bundle);
+ UseAppInfo(AppInfo_AppName | AppInfo_VendorName);
+}
+
+wxStandardPathsCF::~wxStandardPathsCF()
+{
+ CFRelease(m_bundle);
+}
+
+// ----------------------------------------------------------------------------
+// wxStandardPathsCF Mac-specific methods
+// ----------------------------------------------------------------------------
+
+void wxStandardPathsCF::SetBundle(wxCFBundleRef bundle)
+{
+ CFRetain(bundle);
+ CFRelease(m_bundle);
+ m_bundle = bundle;
+}
+
+// ----------------------------------------------------------------------------
+// generic functions in terms of which the other ones are implemented
+// ----------------------------------------------------------------------------
+
+static wxString BundleRelativeURLToPath(CFURLRef relativeURL)
+{
+ CFURLRef absoluteURL = CFURLCopyAbsoluteURL(relativeURL);
+ wxCHECK_MSG(absoluteURL, wxEmptyString, wxT("Failed to resolve relative URL to absolute URL"));
+ CFStringRef cfStrPath = CFURLCopyFileSystemPath(absoluteURL,kDefaultPathStyle);
+ CFRelease(absoluteURL);
+ return wxCFStringRef(cfStrPath).AsString(wxLocale::GetSystemEncoding());
+}
+
+wxString wxStandardPathsCF::GetFromFunc(wxCFURLRef (*func)(wxCFBundleRef)) const
+{
+ wxCHECK_MSG(m_bundle, wxEmptyString,
+ wxT("wxStandardPaths for CoreFoundation only works with bundled apps"));
+ CFURLRef relativeURL = (*func)(m_bundle);
+ wxCHECK_MSG(relativeURL, wxEmptyString, wxT("Couldn't get URL"));
+ wxString ret(BundleRelativeURLToPath(relativeURL));
+ CFRelease(relativeURL);
+ return ret;
+}
+
+wxString wxStandardPathsCF::GetDocumentsDir() const
+{
+#if defined( __WXMAC__ ) && !defined(__WXOSX_IPHONE__)
+ return wxMacFindFolderNoSeparator
+ (
+ kUserDomain,
+ kDocumentsFolderType,
+ kCreateFolder
+ );
+#else
+ return wxFileName::GetHomeDir() + wxT("/Documents");
+#endif
+}
+
+// ----------------------------------------------------------------------------
+// wxStandardPathsCF public API
+// ----------------------------------------------------------------------------
+
+wxString wxStandardPathsCF::GetConfigDir() const
+{
+#if defined( __WXMAC__ ) && !defined(__WXOSX_IPHONE__)
+ return wxMacFindFolder((short)kLocalDomain, kPreferencesFolderType, kCreateFolder);
+#else
+ return wxT("/Library/Preferences");
+#endif
+}
+
+wxString wxStandardPathsCF::GetUserConfigDir() const
+{
+#if defined( __WXMAC__ ) && !defined(__WXOSX_IPHONE__)
+ return wxMacFindFolder((short)kUserDomain, kPreferencesFolderType, kCreateFolder);
+#else
+ return wxFileName::GetHomeDir() + wxT("/Library/Preferences");
+#endif
+}
+
+wxString wxStandardPathsCF::GetDataDir() const
+{
+ return GetFromFunc(CFBundleCopySharedSupportURL);
+}
+
+wxString wxStandardPathsCF::GetExecutablePath() const
+{
+#ifdef __WXMAC__
+#if 1
+ return GetFromFunc(CFBundleCopyBundleURL);
+#else
+ // TODO remove if cf implementation ok
+ ProcessInfoRec processinfo;
+ ProcessSerialNumber procno ;
+#ifdef __LP64__
+ FSRef fsRef;
+#else
+ FSSpec fsSpec;
+#endif
+
+ procno.highLongOfPSN = 0 ;
+ procno.lowLongOfPSN = kCurrentProcess ;
+ processinfo.processInfoLength = sizeof(ProcessInfoRec);
+ processinfo.processName = NULL;
+#ifdef __LP64__
+ processinfo.processAppRef = &fsRef;
+#else
+ processinfo.processAppSpec = &fsSpec;
+#endif
+
+ GetProcessInformation( &procno , &processinfo ) ;
+#ifdef __LP64__
+ return wxMacFSRefToPath(&fsRef);
+#else
+ return wxMacFSSpec2MacFilename(&fsSpec);
+#endif
+#endif
+
+#else
+ return wxStandardPathsBase::GetExecutablePath();
+#endif
+}
+
+wxString wxStandardPathsCF::GetLocalDataDir() const
+{
+#if defined( __WXMAC__ ) && !defined(__WXOSX_IPHONE__)
+ return AppendAppInfo(wxMacFindFolder((short)kLocalDomain, kApplicationSupportFolderType, kCreateFolder));
+#else
+ return AppendAppInfo(wxT("/Library/Application Support"));
+#endif
+}
+
+wxString wxStandardPathsCF::GetUserDataDir() const
+{
+#if defined( __WXMAC__ ) && !defined(__WXOSX_IPHONE__)
+ return AppendAppInfo(wxMacFindFolder((short)kUserDomain, kApplicationSupportFolderType, kCreateFolder));
+#else
+ return AppendAppInfo(wxFileName::GetHomeDir() + _T("/Library/Application Support"));
+#endif
+}
+
+wxString wxStandardPathsCF::GetPluginsDir() const
+{
+ return GetFromFunc(CFBundleCopyBuiltInPlugInsURL);
+}
+
+wxString wxStandardPathsCF::GetResourcesDir() const
+{
+ return GetFromFunc(CFBundleCopyResourcesDirectoryURL);
+}
+
+wxString
+wxStandardPathsCF::GetLocalizedResourcesDir(const wxString& lang,
+ ResourceCat category) const
+{
+ return wxStandardPathsBase::
+ GetLocalizedResourcesDir(lang, category) + _T(".lproj");
+}
+
+#endif // wxUSE_STDPATHS
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: src/mac/corefoundation/strconv.cpp
+// Purpose: Unicode conversion classes
+// Author: David Elliott
+// Modified by:
+// Created: 2007-07-06
+// RCS-ID: $Id$
+// Copyright: (c) 2007 David Elliott
+// Licence: wxWindows licence
+/////////////////////////////////////////////////////////////////////////////
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+#ifndef WX_PRECOMP
+ #include "wx/string.h"
+#endif
+
+#include "wx/strconv.h"
+#include "wx/fontmap.h"
+
+#ifdef __DARWIN__
+
+#include "wx/mac/corefoundation/private/strconv_cf.h"
+#include "wx/mac/corefoundation/cfref.h"
+
+
+// ============================================================================
+// CoreFoundation conversion classes
+// ============================================================================
+
+/* Provide factory functions for unit tests. Not in any header. Do not
+ * assume ABI compatibility even within a given wxWidgets release.
+ */
+
+WXDLLIMPEXP_BASE wxMBConv* new_wxMBConv_cf( const char* name)
+{
+ wxMBConv_cf *result = new wxMBConv_cf(name);
+ if(!result->IsOk())
+ {
+ delete result;
+ return NULL;
+ }
+ else
+ return result;
+}
+
+WXDLLIMPEXP_BASE wxMBConv* new_wxMBConv_cf(wxFontEncoding encoding)
+{
+ wxMBConv_cf *result = new wxMBConv_cf(encoding);
+ if(!result->IsOk())
+ {
+ delete result;
+ return NULL;
+ }
+ else
+ return result;
+}
+
+// Provide a constant for the wchat_t encoding used by the host platform.
+#ifdef WORDS_BIGENDIAN
+ static const CFStringEncoding wxCFStringEncodingWcharT = kCFStringEncodingUTF32BE;
+#else
+ static const CFStringEncoding wxCFStringEncodingWcharT = kCFStringEncodingUTF32LE;
+#endif
+
+ size_t wxMBConv_cf::ToWChar(wchar_t * dst, size_t dstSize, const char * src, size_t srcSize) const
+ {
+ wxCHECK(src, wxCONV_FAILED);
+
+ /* NOTE: This is wrong if the source encoding has an element size
+ * other than char (e.g. it's kCFStringEncodingUnicode)
+ * If the user specifies it, it's presumably right though.
+ * Right now we don't support UTF-16 in anyway since wx can do a better job.
+ */
+ if(srcSize == wxNO_LEN)
+ srcSize = strlen(src) + 1;
+
+ // First create the temporary CFString
+ wxCFRef<CFStringRef> theString( CFStringCreateWithBytes (
+ NULL, //the allocator
+ (const UInt8*)src,
+ srcSize,
+ m_encoding,
+ false //no BOM/external representation
+ ));
+
+ wxCHECK(theString != NULL, wxCONV_FAILED);
+
+ /* NOTE: The string content includes the NULL element if the source string did
+ * That means we have to do nothing special because the destination will have
+ * the NULL element iff the source did and the NULL element will be included
+ * in the count iff it was included in the source count.
+ */
+
+
+/* If we're compiling against Tiger headers we can support direct conversion
+ * to UTF32. If we are then run against a pre-Tiger system, the encoding
+ * won't be available so we'll defer to the string->UTF-16->UTF-32 conversion.
+ */
+ if(CFStringIsEncodingAvailable(wxCFStringEncodingWcharT))
+ {
+ CFRange fullStringRange = CFRangeMake(0, CFStringGetLength(theString));
+ CFIndex usedBufLen;
+
+ CFIndex charsConverted = CFStringGetBytes(
+ theString,
+ fullStringRange,
+ wxCFStringEncodingWcharT,
+ 0,
+ false,
+ // if dstSize is 0 then pass NULL to get required length in usedBufLen
+ dstSize != 0?(UInt8*)dst:NULL,
+ dstSize * sizeof(wchar_t),
+ &usedBufLen);
+
+ // charsConverted is > 0 iff conversion succeeded
+ if(charsConverted <= 0)
+ return wxCONV_FAILED;
+
+ /* usedBufLen is the number of bytes written, so we divide by
+ * sizeof(wchar_t) to get the number of elements written.
+ */
+ wxASSERT( (usedBufLen % sizeof(wchar_t)) == 0 );
+
+ // CFStringGetBytes does exactly the right thing when buffer
+ // pointer is NULL and returns the number of bytes required
+ return usedBufLen / sizeof(wchar_t);
+ }
+ else
+ {
+ // NOTE: Includes NULL iff source did
+ /* NOTE: This is an approximation. The eventual UTF-32 will
+ * possibly have less elements but certainly not more.
+ */
+ size_t returnSize = CFStringGetLength(theString);
+
+ if (dstSize == 0 || dst == NULL)
+ {
+ return returnSize;
+ }
+
+ // Convert the entire string.. too hard to figure out how many UTF-16 we'd need
+ // for an undersized UTF-32 destination buffer.
+ CFRange fullStringRange = CFRangeMake(0, CFStringGetLength(theString));
+ UniChar *szUniCharBuffer = new UniChar[fullStringRange.length];
+
+ CFStringGetCharacters(theString, fullStringRange, szUniCharBuffer);
+
+ wxMBConvUTF16 converter;
+ returnSize = converter.ToWChar( dst, dstSize, (const char*)szUniCharBuffer, fullStringRange.length );
+ delete [] szUniCharBuffer;
+
+ return returnSize;
+ }
+ // NOTREACHED
+ }
+
+ size_t wxMBConv_cf::FromWChar(char *dst, size_t dstSize, const wchar_t *src, size_t srcSize) const
+ {
+ wxCHECK(src, wxCONV_FAILED);
+
+ if(srcSize == wxNO_LEN)
+ srcSize = wxStrlen(src) + 1;
+
+ // Temporary CFString
+ wxCFRef<CFStringRef> theString;
+
+/* If we're compiling against Tiger headers we can support direct conversion
+ * from UTF32. If we are then run against a pre-Tiger system, the encoding
+ * won't be available so we'll defer to the UTF-32->UTF-16->string conversion.
+ */
+ if(CFStringIsEncodingAvailable(wxCFStringEncodingWcharT))
+ {
+ theString = wxCFRef<CFStringRef>(CFStringCreateWithBytes(
+ kCFAllocatorDefault,
+ (UInt8*)src,
+ srcSize * sizeof(wchar_t),
+ wxCFStringEncodingWcharT,
+ false));
+ }
+ else
+ {
+ wxMBConvUTF16 converter;
+ size_t cbUniBuffer = converter.FromWChar( NULL, 0, src, srcSize );
+ wxASSERT(cbUniBuffer % sizeof(UniChar));
+
+ // Will be free'd by kCFAllocatorMalloc when CFString is released
+ UniChar *tmpUniBuffer = (UniChar*)malloc(cbUniBuffer);
+
+ cbUniBuffer = converter.FromWChar( (char*) tmpUniBuffer, cbUniBuffer, src, srcSize );
+ wxASSERT(cbUniBuffer % sizeof(UniChar));
+
+ theString = wxCFRef<CFStringRef>(CFStringCreateWithCharactersNoCopy(
+ kCFAllocatorDefault,
+ tmpUniBuffer,
+ cbUniBuffer / sizeof(UniChar),
+ kCFAllocatorMalloc
+ ));
+
+ }
+
+ wxCHECK(theString != NULL, wxCONV_FAILED);
+
+ CFIndex usedBufLen;
+
+ CFIndex charsConverted = CFStringGetBytes(
+ theString,
+ CFRangeMake(0, CFStringGetLength(theString)),
+ m_encoding,
+ 0, // FAIL on unconvertible characters
+ false, // not an external representation
+ // if dstSize is 0 then pass NULL to get required length in usedBufLen
+ (dstSize != 0)?(UInt8*)dst:NULL,
+ dstSize,
+ &usedBufLen
+ );
+
+ // charsConverted is > 0 iff conversion succeeded
+ if(charsConverted <= 0)
+ return wxCONV_FAILED;
+
+ return usedBufLen;
+ }
+
+#endif // __DARWIN__
+
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: mac/corefoundation/utilsexc_base.cpp
+// Purpose: wxMacLaunch
+// Author: Ryan Norton
+// Modified by:
+// Created: 2005-06-21
+// RCS-ID: $Id$
+// Copyright: (c) Ryan Norton
+// Licence: wxWindows licence
+// Notes: Source was originally in utilsexc_cf.cpp,1.6 then moved
+// to totally unrelated hid.cpp,1.8.
+/////////////////////////////////////////////////////////////////////////////
+
+//===========================================================================
+// DECLARATIONS
+//===========================================================================
+
+//---------------------------------------------------------------------------
+// Pre-compiled header stuff
+//---------------------------------------------------------------------------
+
+// For compilers that support precompilation, includes "wx.h".
+#include "wx/wxprec.h"
+
+// WX includes
+#ifndef WX_PRECOMP
+ #include "wx/string.h"
+ #include "wx/log.h"
+ #include "wx/intl.h"
+ #include "wx/utils.h"
+ #include "wx/wxcrt.h"
+#endif // WX_PRECOMP
+
+// Mac Includes
+#include <CoreFoundation/CoreFoundation.h>
+#ifndef __WXOSX_IPHONE__
+#include <ApplicationServices/ApplicationServices.h>
+#endif
+
+// More WX Includes
+#include "wx/filename.h"
+#include "wx/mac/corefoundation/cfstring.h"
+
+// Default path style
+#define kDefaultPathStyle kCFURLPOSIXPathStyle
+
+//===========================================================================
+// IMPLEMENTATION
+//===========================================================================
+
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+//
+// wxMacLaunch
+//
+// argv is the command line split up, with the application path first
+// flags are the flags from wxExecute
+// process is the process passed from wxExecute for pipe streams etc.
+// returns -1 on error for wxEXEC_SYNC and 0 on error for wxEXEC_ASYNC
+//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+bool wxMacLaunch(char **argv)
+{
+ // Obtains the number of arguments for determining the size of
+ // the CFArray used to hold them
+ CFIndex cfiCount = 0;
+ for(char** argvcopy = argv; *argvcopy != NULL ; ++argvcopy)
+ {
+ ++cfiCount;
+ }
+
+ // If there is not a single argument then there is no application
+ // to launch
+ if(cfiCount == 0)
+ {
+ wxLogDebug(wxT("wxMacLaunch No file to launch!"));
+ return false ;
+ }
+
+ // Path to bundle
+ wxString path = *argv++;
+
+ // Create a CFURL for the application path
+ // Created this way because we are opening a bundle which is a directory
+ CFURLRef cfurlApp =
+ CFURLCreateWithFileSystemPath(
+ kCFAllocatorDefault,
+ wxCFStringRef(path),
+ kDefaultPathStyle,
+ true); //false == not a directory
+
+ // Check for error from the CFURL
+ if(!cfurlApp)
+ {
+ wxLogDebug(wxT("wxMacLaunch Can't open path: %s"), path.c_str());
+ return false ;
+ }
+
+ // Create a CFBundle from the CFURL created earlier
+ CFBundleRef cfbApp = CFBundleCreate(kCFAllocatorDefault, cfurlApp);
+
+ // Check to see if CFBundleCreate returned an error,
+ // and if it did this was an invalid bundle or not a bundle
+ // at all (maybe a simple directory etc.)
+ if(!cfbApp)
+ {
+ wxLogDebug(wxT("wxMacLaunch Bad bundle: %s"), path.c_str());
+ CFRelease(cfurlApp);
+ return false ;
+ }
+
+ // Get the bundle type and make sure its an 'APPL' bundle
+ // Otherwise we're dealing with something else here...
+ UInt32 dwBundleType, dwBundleCreator;
+ CFBundleGetPackageInfo(cfbApp, &dwBundleType, &dwBundleCreator);
+ if(dwBundleType != 'APPL')
+ {
+ wxLogDebug(wxT("wxMacLaunch Not an APPL bundle: %s"), path.c_str());
+ CFRelease(cfbApp);
+ CFRelease(cfurlApp);
+ return false ;
+ }
+
+ // Create a CFArray for dealing with the command line
+ // arguments to the bundle
+ CFMutableArrayRef cfaFiles = CFArrayCreateMutable(kCFAllocatorDefault,
+ cfiCount-1, &kCFTypeArrayCallBacks);
+ if(!cfaFiles) //This should never happen
+ {
+ wxLogDebug(wxT("wxMacLaunch Could not create CFMutableArray"));
+ CFRelease(cfbApp);
+ CFRelease(cfurlApp);
+ return false ;
+ }
+
+ // Loop through command line arguments to the bundle,
+ // turn them into CFURLs and then put them in cfaFiles
+ // For use to launch services call
+ for( ; *argv != NULL ; ++argv)
+ {
+ // Check for '<' as this will ring true for
+ // CFURLCreateWithString but is generally not considered
+ // typical on mac but is usually passed here from wxExecute
+ if (wxStrcmp(*argv, wxT("<")) == 0)
+ continue;
+
+
+ CFURLRef cfurlCurrentFile; // CFURL to hold file path
+ wxFileName argfn(*argv); // Filename for path
+
+ if(argfn.DirExists())
+ {
+ // First, try creating as a directory
+ cfurlCurrentFile = CFURLCreateWithFileSystemPath(
+ kCFAllocatorDefault,
+ wxCFStringRef(*argv),
+ kDefaultPathStyle,
+ true); //true == directory
+ }
+ else if(argfn.FileExists())
+ {
+ // And if it isn't a directory try creating it
+ // as a regular file
+ cfurlCurrentFile = CFURLCreateWithFileSystemPath(
+ kCFAllocatorDefault,
+ wxCFStringRef(*argv),
+ kDefaultPathStyle,
+ false); //false == regular file
+ }
+ else
+ {
+ // Argument did not refer to
+ // an entry in the local filesystem,
+ // so try creating it through CFURLCreateWithString
+ cfurlCurrentFile = CFURLCreateWithString(
+ kCFAllocatorDefault,
+ wxCFStringRef(*argv),
+ NULL);
+ }
+
+ // Continue in the loop if the CFURL could not be created
+ if(!cfurlCurrentFile)
+ {
+ wxLogDebug(
+ wxT("wxMacLaunch Could not create CFURL for argument:%s"),
+ *argv);
+ continue;
+ }
+
+ // Add the valid CFURL to the argument array and then
+ // release it as the CFArray adds a ref count to it
+ CFArrayAppendValue(
+ cfaFiles,
+ cfurlCurrentFile
+ );
+ CFRelease(cfurlCurrentFile); // array has retained it
+ }
+
+ // Create a LSLaunchURLSpec for use with LSOpenFromURLSpec
+ // Note that there are several flag options (launchFlags) such
+ // as kLSLaunchDontSwitch etc. and maybe we could be more
+ // picky about the flags we choose
+ LSLaunchURLSpec launchspec;
+ launchspec.appURL = cfurlApp;
+ launchspec.itemURLs = cfaFiles;
+ launchspec.passThruParams = NULL; //AEDesc*
+ launchspec.launchFlags = kLSLaunchDefaults;
+ launchspec.asyncRefCon = NULL;
+
+ // Finally, call LSOpenFromURL spec with our arguments
+ // 2nd parameter is a pointer to a CFURL that gets
+ // the actual path launched by the function
+ OSStatus status = LSOpenFromURLSpec(&launchspec, NULL);
+
+ // Cleanup corefoundation references
+ CFRelease(cfbApp);
+ CFRelease(cfurlApp);
+ CFRelease(cfaFiles);
+
+ // Check for error from LSOpenFromURLSpec
+ if(status != noErr)
+ {
+ wxLogDebug(wxT("wxMacLaunch LSOpenFromURLSpec Error: %d"),
+ (int)status);
+ return false ;
+ }
+
+ // No error from LSOpenFromURLSpec, so app was launched
+ return true ;
+}
+
--- /dev/null
+/////////////////////////////////////////////////////////////////////////////
+// Name: src/mac/corefoundation/utilsexec_cf.cpp
+// Purpose: Execution-related utilities for Darwin
+// Author: David Elliott, Ryan Norton (wxMacExecute)
+// Modified by: Stefan Csomor (added necessary wxT for unicode builds)
+// Created: 2004-11-04
+// RCS-ID: $Id$
+// Copyright: (c) David Elliott, Ryan Norton
+// Licence: wxWindows licence
+// Notes: This code comes from src/mac/carbon/utilsexc.cpp,1.11
+/////////////////////////////////////////////////////////////////////////////
+
+#include "wx/wxprec.h"
+#ifndef WX_PRECOMP
+ #include "wx/log.h"
+ #include "wx/utils.h"
+#endif //ndef WX_PRECOMP
+#include "wx/unix/execute.h"
+#include "wx/stdpaths.h"
+#include "wx/app.h"
+#include "wx/apptrait.h"
+#include "wx/thread.h"
+#include "wx/process.h"
+
+#include <sys/wait.h>
+
+#include <CoreFoundation/CFSocket.h>
+
+/*!
+ Called due to source signal detected by the CFRunLoop.
+ This is nearly identical to the wxGTK equivalent.
+ */
+extern "C" void WXCF_EndProcessDetector(CFSocketRef s,
+ CFSocketCallBackType WXUNUSED(callbackType),
+ CFDataRef WXUNUSED(address),
+ void const *WXUNUSED(data),
+ void *info)
+{
+ /*
+ Either our pipe was closed or the process ended successfully. Either way,
+ we're done. It's not if waitpid is going to magically succeed when
+ we get fired again. CFSocketInvalidate closes the fd for us and also
+ invalidates the run loop source for us which should cause it to
+ release the CFSocket (thus causing it to be deallocated) and remove
+ itself from the runloop which should release it and cause it to also
+ be deallocated. Of course, it's possible the RunLoop hangs onto
+ one or both of them by retaining/releasing them within its stack
+ frame. However, that shouldn't be depended on. Assume that s is
+ deallocated due to the following call.
+ */
+ CFSocketInvalidate(s);
+
+ // Now tell wx that the process has ended.
+ wxHandleProcessTermination(static_cast<wxEndProcessData *>(info));
+}
+
+/*!
+ Implements the GUI-specific AddProcessCallback() for both wxMac and
+ wxCocoa using the CFSocket/CFRunLoop API which is available to both.
+ Takes advantage of the fact that sockets on UNIX are just regular
+ file descriptors and thus even a non-socket file descriptor can
+ apparently be used with CFSocket so long as you only tell CFSocket
+ to do things with it that would be valid for a non-socket fd.
+ */
+int wxGUIAppTraits::AddProcessCallback(wxEndProcessData *proc_data, int fd)
+{
+ static int s_last_tag = 0;
+ CFSocketContext context =
+ { 0
+ , static_cast<void*>(proc_data)
+ , NULL
+ , NULL
+ , NULL
+ };
+ CFSocketRef cfSocket = CFSocketCreateWithNative(kCFAllocatorDefault,fd,kCFSocketReadCallBack,&WXCF_EndProcessDetector,&context);
+ if(cfSocket == NULL)
+ {
+ wxLogError(wxT("Failed to create socket for end process detection"));
+ return 0;
+ }
+ CFRunLoopSourceRef runLoopSource = CFSocketCreateRunLoopSource(kCFAllocatorDefault, cfSocket, /*highest priority:*/0);
+ if(runLoopSource == NULL)
+ {
+ wxLogError(wxT("Failed to create CFRunLoopSource from CFSocket for end process detection"));
+ // closes the fd.. we can't really stop it, nor do we necessarily want to.
+ CFSocketInvalidate(cfSocket);
+ CFRelease(cfSocket);
+ return 0;
+ }
+ // Now that the run loop source has the socket retained and we no longer
+ // need to refer to it within this method, we can release it.
+ CFRelease(cfSocket);
+
+ CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
+ // Now that the run loop has the source retained we can release it.
+ CFRelease(runLoopSource);
+
+ /*
+ Feed wx some bullshit.. we don't use it since CFSocket helpfully passes
+ itself into our callback and that's enough to be able to
+ CFSocketInvalidate it which is all we need to do to get everything we
+ just created to be deallocated.
+ */
+ return ++s_last_tag;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+
+// NOTE: This doesn't really belong here but this was a handy file to
+// put it in because it's already compiled for wxCocoa and wxMac GUI lib.
+#if wxUSE_STDPATHS
+static wxStandardPathsCF gs_stdPaths;
+wxStandardPathsBase& wxGUIAppTraits::GetStandardPaths()
+{
+ return gs_stdPaths;
+}
+#endif
+
projects / wxWidgets.git / commitdiff
