From 514fddd5916ffdb5f758463f6415748dbd787c23 Mon Sep 17 00:00:00 2001 From: Stefan Csomor Date: Wed, 11 Jun 2008 16:08:31 +0000 Subject: [PATCH] rename round git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@54107 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775 --- include/wx/mac/core/cfdataref.h | 97 ++++++ include/wx/mac/core/cfref.h | 389 +++++++++++++++++++++++ include/wx/mac/core/cfstring.h | 80 +++++ include/wx/mac/core/hid.h | 116 +++++++ include/wx/mac/core/joystick.h | 93 ++++++ include/wx/mac/core/private.h | 82 +++++ include/wx/mac/core/private/strconv_cf.h | 338 ++++++++++++++++++++ include/wx/mac/core/stdpaths.h | 67 ++++ 8 files changed, 1262 insertions(+) create mode 100644 include/wx/mac/core/cfdataref.h create mode 100644 include/wx/mac/core/cfref.h create mode 100644 include/wx/mac/core/cfstring.h create mode 100644 include/wx/mac/core/hid.h create mode 100644 include/wx/mac/core/joystick.h create mode 100644 include/wx/mac/core/private.h create mode 100644 include/wx/mac/core/private/strconv_cf.h create mode 100644 include/wx/mac/core/stdpaths.h diff --git a/include/wx/mac/core/cfdataref.h b/include/wx/mac/core/cfdataref.h new file mode 100644 index 0000000000..19a44d71a8 --- /dev/null +++ b/include/wx/mac/core/cfdataref.h @@ -0,0 +1,97 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: wx/mac/corefoundation/cfdata.h +// Purpose: wxCFDataRef class +// Author: Stefan Csomor +// Modified by: +// Created: 2007/05/10 +// RCS-ID: $Id: cfdataref.h 46095 2007-05-18 07:29:49Z SC $ +// Copyright: (c) 2007 Stefan Csomor +// Licence: wxWindows licence +// Notes: See http://developer.apple.com/documentation/CoreFoundation/Conceptual/CFBinaryData/index.html +///////////////////////////////////////////////////////////////////////////// +/*! @header wx/mac/corefoundation/cfref.h + @abstract wxCFDataRef template class +*/ + +#ifndef _WX_MAC_COREFOUNDATION_CFDATAREF_H__ +#define _WX_MAC_COREFOUNDATION_CFDATAREF_H__ + +#include "wx/mac/corefoundation/cfref.h" + +#include + +/*! @class wxCFDataRef + @discussion Properly retains/releases reference to CoreFoundation data objects +*/ +class wxCFDataRef : public wxCFRef< CFDataRef > +{ +public: + /*! @method wxCFDataRef + @abstract Creates a NULL data ref + */ + wxCFDataRef() + {} + + typedef wxCFRef super_type; + + /*! @method wxCFDataRef + @abstract Assumes ownership of p and creates a reference to it. + @templatefield otherType Any type. + @param p The raw pointer to assume ownership of. May be NULL. + @discussion Like shared_ptr, it is assumed that the caller has a strong reference to p and intends + to transfer ownership of that reference to this ref holder. If the object comes from + a Create or Copy method then this is the correct behavior. If the object comes from + a Get method then you must CFRetain it yourself before passing it to this constructor. + A handy way to do this is to use the non-member wxCFRefFromGet factory funcion. + This method is templated and takes an otherType *p. This prevents implicit conversion + using an operator refType() in a different ref-holding class type. + */ + explicit wxCFDataRef(CFDataRef r) + : super_type(r) + {} + + /*! @method wxCFDataRef + @abstract Copies a ref holder of the same type + @param otherRef The other ref holder to copy. + @discussion Ownership will be shared by the original ref and the newly created ref. That is, + the object will be explicitly retained by this new ref. + */ + wxCFDataRef(const wxCFDataRef& otherRef) + : super_type( otherRef ) + {} + + /*! @method wxCFDataRef + @abstract Copies raw data into a data ref + @param data The raw data. + @param length The data length. + */ + wxCFDataRef(const UInt8* data, CFIndex length) + : super_type(CFDataCreate(kCFAllocatorDefault, data, length)) + { + } + + /*! @method GetLength + @abstract returns the length in bytes of the data stored + */ + CFIndex GetLength() const + { + if ( m_ptr ) + return CFDataGetLength( *this ); + else + return 0; + } + + /*! @method GetBytes + @abstract Copies the data into an external buffer + @param range The desired range. + @param buffer The target buffer. + */ + void GetBytes( CFRange range, UInt8 *buffer ) const + { + if ( m_ptr ) + CFDataGetBytes(m_ptr, range, buffer); + } +}; + +#endif //ifndef _WX_MAC_COREFOUNDATION_CFDATAREF_H__ + diff --git a/include/wx/mac/core/cfref.h b/include/wx/mac/core/cfref.h new file mode 100644 index 0000000000..f5251ab1c0 --- /dev/null +++ b/include/wx/mac/core/cfref.h @@ -0,0 +1,389 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: wx/mac/corefoundation/cfref.h +// Purpose: wxCFRef template class +// Author: David Elliott +// Modified by: Stefan Csomor +// Created: 2007/05/10 +// RCS-ID: $Id$ +// Copyright: (c) 2007 David Elliott , Stefan Csomor +// Licence: wxWindows licence +// Notes: See http://developer.apple.com/documentation/CoreFoundation/Conceptual/CFMemoryMgmt/index.html +///////////////////////////////////////////////////////////////////////////// +/*! @header wx/mac/corefoundation/cfref.h + @abstract wxCFRef template class + @discussion FIXME: Convert doc tags to something less buggy with C++ +*/ + +#ifndef _WX_MAC_COREFOUNDATION_CFREF_H__ +#define _WX_MAC_COREFOUNDATION_CFREF_H__ + +// Include unistd to ensure that NULL is defined +#include +// Include AvailabilityMacros for DEPRECATED_ATTRIBUTE +#include + +// #include +/* Don't include CFBase.h such that this header can be included from public + * headers with minimal namespace pollution. + * Note that Darwin CF uses extern for CF_EXPORT. If we need this on Win32 + * or non-Darwin Mac OS we'll need to define the appropriate __declspec. + */ +typedef const void *CFTypeRef; +extern "C" { +extern /* CF_EXPORT */ +CFTypeRef CFRetain(CFTypeRef cf); +extern /* CF_EXPORT */ +void CFRelease(CFTypeRef cf); +} // extern "C" + + +/*! @function wxCFRelease + @abstract A CFRelease variant that checks for NULL before releasing. + @discussion The parameter is template not for type safety but to ensure the argument + is a raw pointer and not a ref holder of any type. +*/ +template +inline void wxCFRelease(Type *r) +{ + if ( r != NULL ) + ::CFRelease((CFTypeRef)r); +} + +/*! @function wxCFRetain + @abstract A typesafe CFRetain variant that checks for NULL. +*/ +template +inline Type* wxCFRetain(Type *r) +{ + // NOTE(DE): Setting r to the result of CFRetain improves efficiency on both x86 and PPC + // Casting r to CFTypeRef ensures we are calling the real C version defined in CFBase.h + // and not any possibly templated/overloaded CFRetain. + if ( r != NULL ) + r = (Type*)::CFRetain((CFTypeRef)r); + return r; +} + +template +class wxCFRef; + +/*! @class wxCFWeakRef + @templatefield refType The CF reference type (e.g. CFStringRef, CFRunLoopRef, etc.) + It should already be a pointer. This is different from + shared_ptr where the template parameter is the pointee type. + @discussion Wraps a raw pointer without any retain or release. + Provides a way to get what amounts to a raw pointer from a wxCFRef without + using a raw pointer. Unlike a raw pointer, constructing a wxCFRef from this + class will cause it to be retained because it is assumed that a wxCFWeakRef + does not own its pointer. +*/ +template +class wxCFWeakRef +{ + template + friend wxCFWeakRef static_cfref_cast(const wxCFRef &otherRef); +public: + /*! @method wxCFWeakRef + @abstract Creates a NULL reference + */ + wxCFWeakRef() + : m_ptr(NULL) + {} + + // Default copy constructor is fine. + // Default destructor is fine but we'll set NULL to avoid bugs + ~wxCFWeakRef() + { m_ptr = NULL; } + + // Do not implement a raw-pointer constructor. + + /*! @method wxCFWeakRef + @abstract Copies another ref holder where its type can be converted to ours + @templatefield otherRefType Any type held by another wxCFWeakRef. + @param otherRef The other weak ref holder to copy. + @discussion This is merely a copy or implicit cast. + */ + template + wxCFWeakRef(const wxCFWeakRef& otherRef) + : m_ptr(otherRef.get()) // Implicit conversion from otherRefType to refType should occur + {} + + /*! @method wxCFWeakRef + @abstract Copies a strong ref holder where its type can be converted to ours + @templatefield otherRefType Any type held by a wxCFRef. + @param otherRef The strong ref holder to copy. + @discussion This ref is merely a pointer copy, the strong ref still holds the pointer. + */ + template + wxCFWeakRef(const wxCFRef& otherRef) + : m_ptr(otherRef.get()) // Implicit conversion from otherRefType to refType should occur + {} + + /*! @method get + @abstract Explicit conversion to the underlying pointer type + @discussion Allows the caller to explicitly get the underlying pointer. + */ + refType get() const + { return m_ptr; } + + /*! @method operator refType + @abstract Implicit conversion to the underlying pointer type + @discussion Allows the ref to be used in CF function calls. + */ + operator refType() const + { return m_ptr; } + +protected: + /*! @method wxCFWeakRef + @abstract Constructs a weak reference to the raw pointer + @templatefield otherType Any type. + @param p The raw pointer to assume ownership of. May be NULL. + @discussion This method is private so that the friend static_cfref_cast can use it + */ + template + explicit wxCFWeakRef(otherType *p) + : m_ptr(p) // Implicit conversion from otherType* to refType should occur. + {} + + /*! @var m_ptr The raw pointer. + */ + refType m_ptr; +}; + +/*! @class wxCFRef + @templatefield refType The CF reference type (e.g. CFStringRef, CFRunLoopRef, etc.) + It should already be a pointer. This is different from + shared_ptr where the template parameter is the pointee type. + @discussion Properly retains/releases reference to CoreFoundation objects +*/ +template +class wxCFRef +{ +public: + /*! @method wxCFRef + @abstract Creates a NULL reference + */ + wxCFRef() + : m_ptr(NULL) + {} + + /*! @method wxCFRef + @abstract Assumes ownership of p and creates a reference to it. + @templatefield otherType Any type. + @param p The raw pointer to assume ownership of. May be NULL. + @discussion Like shared_ptr, it is assumed that the caller has a strong reference to p and intends + to transfer ownership of that reference to this ref holder. If the object comes from + a Create or Copy method then this is the correct behavior. If the object comes from + a Get method then you must CFRetain it yourself before passing it to this constructor. + A handy way to do this is to use the non-member wxCFRefFromGet factory funcion. + This method is templated and takes an otherType *p. This prevents implicit conversion + using an operator refType() in a different ref-holding class type. + */ + template + explicit wxCFRef(otherType *p) + : m_ptr(p) // Implicit conversion from otherType* to refType should occur. + {} + + /*! @method wxCFRef + @abstract Copies a ref holder of the same type + @param otherRef The other ref holder to copy. + @discussion Ownership will be shared by the original ref and the newly created ref. That is, + the object will be explicitly retained by this new ref. + */ + wxCFRef(const wxCFRef& otherRef) + : m_ptr(wxCFRetain(otherRef.m_ptr)) + {} + + /*! @method wxCFRef + @abstract Copies a ref holder where its type can be converted to ours + @templatefield otherRefType Any type held by another wxCFRef. + @param otherRef The other ref holder to copy. + @discussion Ownership will be shared by the original ref and the newly created ref. That is, + the object will be explicitly retained by this new ref. + */ + template + wxCFRef(const wxCFRef& otherRef) + : m_ptr(wxCFRetain(otherRef.get())) // Implicit conversion from otherRefType to refType should occur + {} + + /*! @method wxCFRef + @abstract Copies a weak ref holder where its type can be converted to ours + @templatefield otherRefType Any type held by a wxCFWeakRef. + @param otherRef The weak ref holder to copy. + @discussion Ownership will be taken by this newly created ref. That is, + the object will be explicitly retained by this new ref. + Ownership is most likely shared with some other ref as well. + */ + template + wxCFRef(const wxCFWeakRef& otherRef) + : m_ptr(wxCFRetain(otherRef.get())) // Implicit conversion from otherRefType to refType should occur + {} + + /*! @method ~wxCFRef + @abstract Releases (potentially shared) ownership of the ref. + @discussion A ref holder instance is always assumed to have ownership so ownership is always + released (CFRelease called) upon destruction. + */ + ~wxCFRef() + { reset(); } + + /*! @method operator= + @abstract Assigns the other ref's pointer to us when the otherRef is the same type. + @param otherRef The other ref holder to copy. + @discussion The incoming pointer is retained, the original pointer is released, and this object + is made to point to the new pointer. + */ + wxCFRef& operator=(const wxCFRef& otherRef) + { + wxCFRetain(otherRef.m_ptr); + wxCFRelease(m_ptr); + m_ptr = otherRef.m_ptr; + return *this; + } + + /*! @method operator= + @abstract Assigns the other ref's pointer to us when the other ref can be converted to our type. + @templatefield otherRefType Any type held by another wxCFRef + @param otherRef The other ref holder to copy. + @discussion The incoming pointer is retained, the original pointer is released, and this object + is made to point to the new pointer. + */ + template + wxCFRef& operator=(const wxCFRef& otherRef) + { + wxCFRetain(otherRef.get()); + wxCFRelease(m_ptr); + m_ptr = otherRef.get(); // Implicit conversion from otherRefType to refType should occur + return *this; + } + + /*! @method get + @abstract Explicit conversion to the underlying pointer type + @discussion Allows the caller to explicitly get the underlying pointer. + */ + refType get() const + { return m_ptr; } + + /*! @method operator refType + @abstract Implicit conversion to the underlying pointer type + @discussion Allows the ref to be used in CF function calls. + */ + operator refType() const + { return m_ptr; } + +#if 0 + < // HeaderDoc is retarded and thinks the GT from operator-> is part of a template param. + // So give it that < outside of a comment to fake it out. (if 0 is not a comment to HeaderDoc) +#endif + + /*! @method operator-> + @abstract Implicit conversion to the underlying pointer type + @discussion This is nearly useless for CF types which are nearly always opaque + */ + refType operator-> () const + { return m_ptr; } + + /*! @method reset + @abstract Nullifies the reference + @discussion Releases ownership (calls CFRelease) before nullifying the pointer. + */ + void reset() + { + wxCFRelease(m_ptr); + m_ptr = NULL; + } + + /*! @method reset + @abstract Sets this to a new reference + @templatefield otherType Any type. + @param p The raw pointer to assume ownership of + @discussion The existing reference is released (like destruction). It is assumed that the caller + has a strong reference to the new p and intends to transfer ownership of that reference + to this ref holder. Take care to call CFRetain if you received the object from a Get method. + This method is templated and takes an otherType *p. This prevents implicit conversion + using an operator refType() in a different ref-holding class type. + */ + template + void reset(otherType* p) + { + wxCFRelease(m_ptr); + m_ptr = p; // Automatic conversion should occur + } +protected: + /*! @var m_ptr The raw pointer. + */ + refType m_ptr; +}; + +/*! @function wxCFRefFromGet + @abstract Factory function to create wxCFRef from a raw pointer obtained from a Get-rule function + @param p The pointer to retain and create a wxCFRef from. May be NULL. + @discussion Unlike the wxCFRef raw pointer constructor, this function explicitly retains its + argument. This can be used for functions such as CFDictionaryGetValue() or + CFAttributedStringGetString() which return a temporary reference (Get-rule functions). + FIXME: Anybody got a better name? +*/ +template +inline wxCFRef wxCFRefFromGet(Type *p) +{ + return wxCFRef(wxCFRetain(p)); +} + +/*! @function static_cfref_cast + @abstract Works like static_cast but with a wxCFRef as the argument. + @param refType Template parameter. The destination raw pointer type + @param otherRef Normal parameter. The source wxCFRef<> object. + @discussion This is intended to be a clever way to make static_cast work while allowing + the return value to be converted to either a strong ref or a raw pointer + while ensuring that the retain count is updated appropriately. + + This is modeled after shared_ptr's static_pointer_cast. Just as wxCFRef is + parameterized on a pointer to an opaque type so is this class. Note that + this differs from shared_ptr which is parameterized on the pointee type. + + FIXME: Anybody got a better name? +*/ +template +inline wxCFWeakRef static_cfref_cast(const wxCFRef &otherRef); + +template +inline wxCFWeakRef static_cfref_cast(const wxCFRef &otherRef) +{ + return wxCFWeakRef(static_cast(otherRef.get())); +} + +/*! @function CFRelease + @abstract Overloads CFRelease so that the user is warned of bad behavior. + @discussion It is rarely appropriate to retain or release a wxCFRef. If one absolutely + must do it he can explicitly get() the raw pointer + Normally, this function is unimplemented resulting in a linker error if used. +*/ +template +inline void CFRelease(const wxCFRef & cfref) DEPRECATED_ATTRIBUTE; + +/*! @function CFRetain + @abstract Overloads CFRetain so that the user is warned of bad behavior. + @discussion It is rarely appropriate to retain or release a wxCFRef. If one absolutely + must do it he can explicitly get() the raw pointer + Normally, this function is unimplemented resulting in a linker error if used. +*/ +template +inline void CFRetain(const wxCFRef& cfref) DEPRECATED_ATTRIBUTE; + +// Change the 0 to a 1 if you want the functions to work (no link errors) +// Neither function will cause retain/release side-effects if implemented. +#if 0 +template +void CFRelease(const wxCFRef & cfref) +{ + CFRelease(cfref.get()); +} + +template +void CFRetain(const wxCFRef & cfref) +{ + CFRetain(cfref.get()); +} +#endif + +#endif //ndef _WX_MAC_COREFOUNDATION_CFREF_H__ + diff --git a/include/wx/mac/core/cfstring.h b/include/wx/mac/core/cfstring.h new file mode 100644 index 0000000000..c4b1719c4d --- /dev/null +++ b/include/wx/mac/core/cfstring.h @@ -0,0 +1,80 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: wx/mac/corefoundation/cfstring.h +// Purpose: wxCFStringRef and other string functions +// Author: Stefan Csomor +// Modified by: +// Created: 2004-10-29 (from code in wx/mac/carbon/private.h) +// RCS-ID: $Id$ +// Copyright: (c) Stefan Csomor +// Licence: wxWindows licence +// Usage: Darwin (base library) +///////////////////////////////////////////////////////////////////////////// + +#ifndef __WX_CFSTRINGHOLDER_H__ +#define __WX_CFSTRINGHOLDER_H__ + +#include + +#include "wx/dlimpexp.h" +#include "wx/fontenc.h" +#include "wx/mac/corefoundation/cfref.h" + +class WXDLLIMPEXP_FWD_BASE wxString; + +WXDLLIMPEXP_BASE void wxMacConvertNewlines13To10( wxString *data ) ; +WXDLLIMPEXP_BASE void wxMacConvertNewlines10To13( wxString *data ) ; + +WXDLLIMPEXP_BASE void wxMacConvertNewlines13To10( char * data ) ; +WXDLLIMPEXP_BASE void wxMacConvertNewlines10To13( char * data ) ; + +WXDLLIMPEXP_BASE wxUint32 wxMacGetSystemEncFromFontEnc(wxFontEncoding encoding) ; +WXDLLIMPEXP_BASE wxFontEncoding wxMacGetFontEncFromSystemEnc(wxUint32 encoding) ; +WXDLLIMPEXP_BASE void wxMacWakeUp() ; + +class WXDLLIMPEXP_BASE wxCFStringRef : public wxCFRef< CFStringRef > +{ +public: + wxCFStringRef() + { + } + + wxCFStringRef(const wxString &str, + wxFontEncoding encoding = wxFONTENCODING_DEFAULT) ; + + wxCFStringRef(CFStringRef ref) + : wxCFRef< CFStringRef >(ref) + { + } + + wxCFStringRef(const wxCFStringRef& otherRef ) + : wxCFRef< CFStringRef >(otherRef) + { + } + + ~wxCFStringRef() + { + } + + wxString AsString( wxFontEncoding encoding = wxFONTENCODING_DEFAULT ) ; + +private: +} ; + +// corresponding class for holding UniChars (native unicode characters) + +class WXDLLIMPEXP_BASE wxMacUniCharBuffer +{ +public : + wxMacUniCharBuffer( const wxString &str ) ; + + ~wxMacUniCharBuffer() ; + + UniCharPtr GetBuffer() ; + + UniCharCount GetChars() ; + +private : + UniCharPtr m_ubuf ; + UniCharCount m_chars ; +}; +#endif //__WXCFSTRINGHOLDER_H__ diff --git a/include/wx/mac/core/hid.h b/include/wx/mac/core/hid.h new file mode 100644 index 0000000000..e6df5cb45f --- /dev/null +++ b/include/wx/mac/core/hid.h @@ -0,0 +1,116 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: wx/mac/corefoundation/hid.h +// Purpose: DARWIN HID layer for WX +// Author: Ryan Norton +// Modified by: +// Created: 11/11/2003 +// RCS-ID: $Id$ +// Copyright: (c) Ryan Norton +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +// =========================================================================== +// declarations +// =========================================================================== + +// --------------------------------------------------------------------------- +// headers +// --------------------------------------------------------------------------- + +#ifndef _WX_MACCARBONHID_H_ +#define _WX_MACCARBONHID_H_ + +#include "wx/defs.h" +#include "wx/string.h" + +//Mac OSX only +#ifdef __DARWIN__ + +#include +#include +#include +#include +#include + +//Darn apple - doesn't properly wrap their headers in extern "C"! +//http://www.macosx.com/forums/archive/index.php/t-68069.html +//Needed for codewarrior link error with mach_port_deallocate() +extern "C" { +#include +} + +#include //this actually includes mach_port.h (see above) + +// =========================================================================== +// definitions +// =========================================================================== + + +// --------------------------------------------------------------------------- +// wxHIDDevice +// +// A wrapper around OS X HID Manager procedures. +// The tutorial "Working With HID Class Device Interfaces" Is +// Quite good, as is the sample program associated with it +// (Depite the author's protests!). +// --------------------------------------------------------------------------- +class WXDLLIMPEXP_CORE wxHIDDevice +{ +public: + wxHIDDevice() : m_ppDevice(NULL), m_ppQueue(NULL), m_pCookies(NULL) {} + + bool Create (int nClass = -1, int nType = -1, int nDev = 1); + + static size_t GetCount(int nClass = -1, int nType = -1); + + void AddCookie(CFTypeRef Data, int i); + void AddCookieInQueue(CFTypeRef Data, int i); + void InitCookies(size_t dwSize, bool bQueue = false); + + //Must be implemented by derived classes + //builds the cookie array - + //first call InitCookies to initialize the cookie + //array, then AddCookie to add a cookie at a certain point in an array + virtual void BuildCookies(CFArrayRef Array) = 0; + + //checks to see whether the cookie at nIndex is active (element value != 0) + bool IsActive(int nIndex); + + //checks to see whether an element in the internal cookie array + //exists + bool HasElement(int nIndex); + + //closes the device and cleans the queue and cookies + virtual ~wxHIDDevice(); + +protected: + IOHIDDeviceInterface** m_ppDevice; //this, essentially + IOHIDQueueInterface** m_ppQueue; //queue (if we want one) + IOHIDElementCookie* m_pCookies; //cookies + + wxString m_szProductName; //product name + int m_nProductId; //product id + int m_nManufacturerId; //manufacturer id + mach_port_t m_pPort; //mach port to use +}; + +// --------------------------------------------------------------------------- +// wxHIDKeyboard +// +// Semi-simple implementation that opens a connection to the first +// keyboard of the machine. Used in wxGetKeyState. +// --------------------------------------------------------------------------- +class WXDLLIMPEXP_CORE wxHIDKeyboard : public wxHIDDevice +{ +public: + static int GetCount(); + bool Create(int nDev = 1); + void AddCookie(CFTypeRef Data, int i); + virtual void BuildCookies(CFArrayRef Array); + void DoBuildCookies(CFArrayRef Array); +}; + +#endif //__DARWIN__ + +#endif + // _WX_MACCARBONHID_H_ diff --git a/include/wx/mac/core/joystick.h b/include/wx/mac/core/joystick.h new file mode 100644 index 0000000000..a909070072 --- /dev/null +++ b/include/wx/mac/core/joystick.h @@ -0,0 +1,93 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: joystick.h +// Purpose: wxJoystick class +// Author: Ryan Norton +// Modified by: +// Created: 2/13/2005 +// RCS-ID: $Id$ +// Copyright: (c) Ryan Norton +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_JOYSTICK_H_ +#define _WX_JOYSTICK_H_ + +#include "wx/event.h" + +class WXDLLIMPEXP_FWD_CORE wxJoystickThread; + +class WXDLLIMPEXP_ADV wxJoystick: public wxObject +{ + DECLARE_DYNAMIC_CLASS(wxJoystick) + public: + + wxJoystick(int joystick = wxJOYSTICK1); + virtual ~wxJoystick(); + + // Attributes + //////////////////////////////////////////////////////////////////////////// + + wxPoint GetPosition() const; + int GetPosition(unsigned axis) const; + bool GetButtonState(unsigned button) const; + int GetZPosition() const; + int GetButtonState() const; + int GetPOVPosition() const; + int GetPOVCTSPosition() const; + int GetRudderPosition() const; + int GetUPosition() const; + int GetVPosition() const; + int GetMovementThreshold() const; + void SetMovementThreshold(int threshold) ; + + // Capabilities + //////////////////////////////////////////////////////////////////////////// + + bool IsOk() const; // Checks that the joystick is functioning + static int GetNumberJoysticks() ; + int GetManufacturerId() const ; + int GetProductId() const ; + wxString GetProductName() const ; + int GetXMin() const; + int GetYMin() const; + int GetZMin() const; + int GetXMax() const; + int GetYMax() const; + int GetZMax() const; + int GetNumberButtons() const; + int GetNumberAxes() const; + int GetMaxButtons() const; + int GetMaxAxes() const; + int GetPollingMin() const; + int GetPollingMax() const; + int GetRudderMin() const; + int GetRudderMax() const; + int GetUMin() const; + int GetUMax() const; + int GetVMin() const; + int GetVMax() const; + + bool HasRudder() const; + bool HasZ() const; + bool HasU() const; + bool HasV() const; + bool HasPOV() const; + bool HasPOV4Dir() const; + bool HasPOVCTS() const; + + // Operations + //////////////////////////////////////////////////////////////////////////// + + // pollingFreq = 0 means that movement events are sent when above the threshold. + // If pollingFreq > 0, events are received every this many milliseconds. + bool SetCapture(wxWindow* win, int pollingFreq = 0); + bool ReleaseCapture(); + +protected: + int m_joystick; + wxJoystickThread* m_thread; + class wxHIDJoystick* m_hid; +}; + +#endif + // _WX_JOYSTICK_H_ diff --git a/include/wx/mac/core/private.h b/include/wx/mac/core/private.h new file mode 100644 index 0000000000..9d70b22c7a --- /dev/null +++ b/include/wx/mac/core/private.h @@ -0,0 +1,82 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: wx/mac/corefoundation/private.h +// Purpose: Private declarations: as this header is only included by +// wxWidgets itself, it may contain identifiers which don't start +// with "wx". +// Author: Stefan Csomor +// Modified by: +// Created: 1998-01-01 +// RCS-ID: $Id: private.h 53819 2008-05-29 14:11:45Z SC $ +// Copyright: (c) Stefan Csomor +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_PRIVATE_H_ +#define _WX_PRIVATE_H_ + +#include "wx/defs.h" + +#include + +#include "wx/mac/corefoundation/cfstring.h" +#include "wx/mac/corefoundation/cfdataref.h" + +#if wxUSE_GUI + +#include + +class WXDLLIMPEXP_CORE wxMacCGContextStateSaver +{ + DECLARE_NO_COPY_CLASS(wxMacCGContextStateSaver) + +public: + wxMacCGContextStateSaver( CGContextRef cg ) + { + m_cg = cg; + CGContextSaveGState( cg ); + } + ~wxMacCGContextStateSaver() + { + CGContextRestoreGState( m_cg ); + } +private: + CGContextRef m_cg; +}; + + +// Quartz + +WXDLLIMPEXP_CORE CGImageRef wxMacCreateCGImageFromBitmap( const wxBitmap& bitmap ); + +WXDLLIMPEXP_CORE CGDataProviderRef wxMacCGDataProviderCreateWithCFData( CFDataRef data ); +WXDLLIMPEXP_CORE CGDataConsumerRef wxMacCGDataConsumerCreateWithCFData( CFMutableDataRef data ); +WXDLLIMPEXP_CORE CGDataProviderRef wxMacCGDataProviderCreateWithMemoryBuffer( const wxMemoryBuffer& buf ); + +CGColorSpaceRef WXDLLIMPEXP_CORE wxMacGetGenericRGBColorSpace(void); + +#endif // wxUSE_GUI + +//--------------------------------------------------------------------------- +// cocoa bridging utilities +//--------------------------------------------------------------------------- + +bool wxMacInitCocoa(); + +class WXDLLIMPEXP_CORE wxMacAutoreleasePool +{ +public : + wxMacAutoreleasePool(); + ~wxMacAutoreleasePool(); +private : + void* m_pool; +}; + +// NSObject + +void wxMacCocoaRelease( void* obj ); +void wxMacCocoaAutorelease( void* obj ); +void wxMacCocoaRetain( void* obj ); + + +#endif + // _WX_PRIVATE_H_ diff --git a/include/wx/mac/core/private/strconv_cf.h b/include/wx/mac/core/private/strconv_cf.h new file mode 100644 index 0000000000..07a98a1de0 --- /dev/null +++ b/include/wx/mac/core/private/strconv_cf.h @@ -0,0 +1,338 @@ +///////////////////////////////////////////////////////////////////////////// +// Name: include/wx/mac/corefoundation/strconv_cf.h +// Purpose: Unicode conversion classes +// Author: David Elliott, Ryan Norton +// Modified by: +// Created: 2007-07-06 +// RCS-ID: $Id$ +// Copyright: (c) 2004 Ryan Norton +// (c) 2007 David Elliott +// Licence: wxWindows licence +///////////////////////////////////////////////////////////////////////////// + +#include "wx/strconv.h" + +#include +#include + +// ============================================================================ +// CoreFoundation conversion classes +// ============================================================================ + +inline CFStringEncoding wxCFStringEncFromFontEnc(wxFontEncoding encoding) +{ + CFStringEncoding enc = kCFStringEncodingInvalidId ; + + switch (encoding) + { + case wxFONTENCODING_DEFAULT : + enc = CFStringGetSystemEncoding(); + break ; + + 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_11 : + enc = kCFStringEncodingISOLatinThai; + 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 ; +// This only really encodes to UTF7 (if that) evidently +// case wxFONTENCODING_UTF7 : +// enc = kCFStringEncodingNonLossyASCII ; +// break ; + case wxFONTENCODING_UTF8 : + enc = kCFStringEncodingUTF8 ; + break ; + case wxFONTENCODING_EUC_JP : + enc = kCFStringEncodingEUC_JP; + break ; +/* Don't support conversion to/from UTF16 as wxWidgets can do this better. + * In particular, ToWChar would fail miserably using strlen on an input UTF16. + case wxFONTENCODING_UTF16 : + enc = kCFStringEncodingUnicode ; + 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 ; + /* CFString is known to support this back to the original CarbonLib */ + /* http://developer.apple.com/samplecode/CarbonMDEF/listing2.html */ + case wxFONTENCODING_MACKEYBOARD : + /* We don't wish to pollute the namespace too much, even though we're a private header. */ + /* The constant is well-defined as 41 and is not expected to change. */ + enc = 41 /*kTextEncodingMacKeyboardGlyphs*/ ; + break ; + + default : + // because gcc is picky + break ; + } + + return enc ; +} + + +class wxMBConv_cf : public wxMBConv +{ +public: + wxMBConv_cf() + { + Init(CFStringGetSystemEncoding()) ; + } + + wxMBConv_cf(const wxMBConv_cf& conv) + { + m_encoding = conv.m_encoding; + } + +#if wxUSE_FONTMAP + wxMBConv_cf(const char* name) + { + Init( wxCFStringEncFromFontEnc(wxFontMapperBase::Get()->CharsetToEncoding(name, false) ) ) ; + } +#endif + + wxMBConv_cf(wxFontEncoding encoding) + { + Init( wxCFStringEncFromFontEnc(encoding) ); + } + + virtual ~wxMBConv_cf() + { + } + + void Init( CFStringEncoding encoding) + { + m_encoding = encoding ; + } + + virtual size_t ToWChar(wchar_t * dst, size_t dstSize, const char * src, size_t srcSize = wxNO_LEN) const; + virtual size_t FromWChar(char *dst, size_t dstSize, const wchar_t *src, size_t srcSize = wxNO_LEN) const; + + virtual wxMBConv *Clone() const { return new wxMBConv_cf(*this); } + + bool IsOk() const + { + return m_encoding != kCFStringEncodingInvalidId && + CFStringIsEncodingAvailable(m_encoding); + } + +private: + CFStringEncoding m_encoding ; +}; + diff --git a/include/wx/mac/core/stdpaths.h b/include/wx/mac/core/stdpaths.h new file mode 100644 index 0000000000..3fcb8d5676 --- /dev/null +++ b/include/wx/mac/core/stdpaths.h @@ -0,0 +1,67 @@ +/////////////////////////////////////////////////////////////////////////////// +// Name: wx/mac/corefoundation/stdpaths.h +// Purpose: wxStandardPaths for CoreFoundation systems +// Author: David Elliott +// Modified by: +// Created: 2004-10-27 +// RCS-ID: $Id$ +// Copyright: (c) 2004 David Elliott +// Licence: wxWindows licence +/////////////////////////////////////////////////////////////////////////////// + +#ifndef _WX_MAC_STDPATHS_H_ +#define _WX_MAC_STDPATHS_H_ + +struct __CFBundle; +struct __CFURL; + +typedef const __CFURL * wxCFURLRef; +typedef __CFBundle * wxCFBundleRef; + +// ---------------------------------------------------------------------------- +// wxStandardPaths +// ---------------------------------------------------------------------------- + +class WXDLLIMPEXP_BASE wxStandardPathsCF : public wxStandardPathsBase +{ +public: + wxStandardPathsCF(); + virtual ~wxStandardPathsCF(); + + // wxMac specific: allow user to specify a different bundle + wxStandardPathsCF(wxCFBundleRef bundle); + void SetBundle(wxCFBundleRef bundle); + + // implement base class pure virtuals + virtual wxString GetExecutablePath() const; + virtual wxString GetConfigDir() const; + virtual wxString GetUserConfigDir() const; + virtual wxString GetDataDir() const; + virtual wxString GetLocalDataDir() const; + virtual wxString GetUserDataDir() const; + virtual wxString GetPluginsDir() const; + virtual wxString GetResourcesDir() const; + virtual wxString + GetLocalizedResourcesDir(const wxString& lang, + ResourceCat category = ResourceCat_None) const; + virtual wxString GetDocumentsDir() const; + +protected: + // this function can be called with any of CFBundleCopyXXXURL function + // pointer as parameter + wxString GetFromFunc(wxCFURLRef (*func)(wxCFBundleRef)) const; + + wxCFBundleRef m_bundle; +}; + +// If using UNIX (i.e. darwin) then use UNIX standard paths +#if defined(__UNIX__) +#include "wx/unix/stdpaths.h" +#else +// If compiling wxMac for CarbonLib then we are wxStandardPaths +class WXDLLIMPEXP_BASE wxStandardPaths: public wxStandardPathsCF +{ +}; +#endif + +#endif // _WX_MAC_STDPATHS_H_ -- 2.45.2