rename round

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@54107 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775

diff --git a/include/wx/mac/core/cfdataref.h b/include/wx/mac/core/cfdataref.h
new file mode 100644 (file)
index 0000000..19a44d7
--- /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 <CoreFoundation/CFData.h>
+
+/*! @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<CFDataRef> 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 (file)
index 0000000..f5251ab
--- /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 <dfe@cox.net>
+// Modified by: Stefan Csomor
+// Created:     2007/05/10
+// RCS-ID:      $Id$
+// Copyright:   (c) 2007 David Elliott <dfe@cox.net>, 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 <unistd.h>
+// Include AvailabilityMacros for DEPRECATED_ATTRIBUTE
+#include <AvailabilityMacros.h>
+
+// #include <CoreFoundation/CFBase.h>
+/* 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 <class Type>
+inline void wxCFRelease(Type *r)
+{
+    if ( r != NULL )
+        ::CFRelease((CFTypeRef)r);
+}
+
+/*! @function   wxCFRetain
+    @abstract   A typesafe CFRetain variant that checks for NULL.
+*/
+template <class Type>
+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 refType>
+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 refType>
+class wxCFWeakRef
+{
+    template <class refTypeA, class otherRefType>
+    friend wxCFWeakRef<refTypeA> static_cfref_cast(const wxCFRef<otherRefType> &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 <class otherRefType>
+    wxCFWeakRef(const wxCFWeakRef<otherRefType>& 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 <class otherRefType>
+    wxCFWeakRef(const wxCFRef<otherRefType>& 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 <class otherType>
+    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 refType>
+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 <class otherType>
+    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 <class otherRefType>
+    wxCFRef(const wxCFRef<otherRefType>& 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 <class otherRefType>
+    wxCFRef(const wxCFWeakRef<otherRefType>& 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 <class otherRefType>
+    wxCFRef& operator=(const wxCFRef<otherRefType>& 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-&gt;
+        @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 <class otherType>
+    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 <typename Type>
+inline wxCFRef<Type*> wxCFRefFromGet(Type *p)
+{
+    return wxCFRef<Type*>(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 <class refType, class otherRefType>
+inline wxCFWeakRef<refType> static_cfref_cast(const wxCFRef<otherRefType> &otherRef);
+
+template <class refType, class otherRefType>
+inline wxCFWeakRef<refType> static_cfref_cast(const wxCFRef<otherRefType> &otherRef)
+{
+    return wxCFWeakRef<refType>(static_cast<refType>(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 <class T>
+inline void CFRelease(const wxCFRef<T*> & 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 <class T>
+inline void CFRetain(const wxCFRef<T*>& 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 <class T>
+void CFRelease(const wxCFRef<T*> & cfref)
+{
+    CFRelease(cfref.get());
+}
+
+template <class T>
+void CFRetain(const wxCFRef<T*> & 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 (file)
index 0000000..c4b1719
--- /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 <CoreFoundation/CFString.h>
+
+#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 (file)
index 0000000..e6df5cb
--- /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 <IOKit/IOKitLib.h>
+#include <IOKit/IOCFPlugIn.h>
+#include <IOKit/hid/IOHIDLib.h>
+#include <IOKit/hid/IOHIDKeys.h>
+#include <Kernel/IOKit/hidsystem/IOHIDUsageTables.h>
+
+//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 <mach/mach_port.h>
+}
+
+#include <mach/mach.h> //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 (file)
index 0000000..a909070
--- /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 (file)
index 0000000..9d70b22
--- /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 <CoreFoundation/CoreFoundation.h>
+
+#include "wx/mac/corefoundation/cfstring.h"
+#include "wx/mac/corefoundation/cfdataref.h"
+
+#if wxUSE_GUI
+
+#include <CoreGraphics/CoreGraphics.h>
+
+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 (file)
index 0000000..07a98a1
--- /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 <CoreFoundation/CFString.h>
+#include <CoreFoundation/CFStringEncodingExt.h>
+
+// ============================================================================
+// 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 (file)
index 0000000..3fcb8d5
--- /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_