This commit was manufactured by cvs2svn to create tag 'WX_2_7_1'.

git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/tags/WX_2_7_1@41974 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
2006-10-12 08:58:05 +00:00
299 changed files with 7433 additions and 21272 deletions
--- a/1339
+++ b/1339
--- a/configure.in
+++ b/configure.in
@@ -35,7 +35,7 @@ dnl wx_release_number += 1
 wx_major_version_number=2
 wx_minor_version_number=7
 wx_release_number=1
-wx_subrelease_number=1
+wx_subrelease_number=0

 WX_RELEASE=$wx_major_version_number.$wx_minor_version_number
 WX_VERSION=$WX_RELEASE.$wx_release_number
@@ -3085,9 +3085,6 @@ libraries returned by 'pkg-config gtk+-2.0 --libs' or 'gtk-config
                AC_MSG_WARN([Unicode configuration not supported with GTK+ 1.x])
                wxUSE_UNICODE=no
            fi
-
-            dnl test for XIM support in libgdk
-            AC_CHECK_LIB(gdk, gdk_im_open, AC_DEFINE(HAVE_XIM))
        fi

        AC_LANG_POP
@@ -3105,6 +3102,10 @@ libraries returned by 'pkg-config gtk+-2.0 --libs' or 'gtk-config
        TOOLKIT=GTK
        GUIDIST=GTK_DIST

+        dnl test for XIM support in libgdk
+        AC_CHECK_LIB(gdk, gdk_im_open, AC_DEFINE(HAVE_XIM))
+
+
        dnl test for external libxpm if we're configured to use it
        if test "$wxUSE_GPE" = "yes"; then
            AC_MSG_CHECKING(for gpewidget library)
@@ -6925,6 +6926,10 @@ if test "$wxUSE_RICHTEXT" = "yes"; then
    SAMPLES_SUBDIRS="$SAMPLES_SUBDIRS richtext"
 fi

+if test "$wxUSE_GRAPHICS_CONTEXT" = "yes"; then
+  AC_DEFINE(wxUSE_GRAPHICS_CONTEXT)
+fi
+
 dnl ---------------------------------------------------------------------------
 dnl wxImage options
 dnl ---------------------------------------------------------------------------
@@ -7031,29 +7036,6 @@ if test "$wxUSE_WIZARDDLG" = "yes"; then
    SAMPLES_SUBDIRS="$SAMPLES_SUBDIRS wizard"
 fi

-dnl ---------------------------------------------------------------------------
-dnl wxGraphicsContext
-dnl ---------------------------------------------------------------------------
-
-if test "$wxUSE_GRAPHICS_CONTEXT" = "yes"; then
-   if test "$wxUSE_MAC" = 1 -o "$wxUSE_COCOA" = "1"; then
-      AC_DEFINE(wxUSE_GRAPHICS_CONTEXT)
-   elif test "$wxUSE_GTK" != 1; then
-      dnl for other builds we'll just wing it for now...
-      AC_DEFINE(wxUSE_GRAPHICS_CONTEXT)
-   else  
-      dnl ...but let's check for cairo availability for wxGTK builds
-      PKG_CHECK_MODULES(CAIRO, cairo,
-	    [
-	    	AC_DEFINE(wxUSE_GRAPHICS_CONTEXT)
-	    ],
-	    [
-	        AC_MSG_WARN([Cairo library not found, unable to set wxUSE_GRAPHICS_CONTEXT])
-	    ]
-      )
-   fi
-fi
-
 dnl ---------------------------------------------------------------------------
 dnl wxMediaCtrl
 dnl ---------------------------------------------------------------------------
--- a/contrib/src/Makefile.in
+++ b/contrib/src/Makefile.in
@@ -1,6 +1,6 @@
 # $Id$

-CONTRIB_SUBDIRS=fl gizmos mmedia ogl plot stc svg deprecated #animate #applet
+CONTRIB_SUBDIRS=fl gizmos mmedia ogl plot stc svg deprecated animate #applet

 all:
 	@for d in $(CONTRIB_SUBDIRS); do (cd $$d && $(MAKE)); done
--- a/contrib/src/gizmos/multicell.cpp
+++ b/contrib/src/gizmos/multicell.cpp
@@ -4,7 +4,7 @@
 // Author:      Jonathan Bayer
 // Modified by:
 // Created:
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) Jonathan Bayer
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
@@ -651,3 +651,4 @@ void wxMultiCellCanvas :: CalculateConstraints()
 }

 /*** End of File ***/
+
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,11 +1,3 @@
-wxwidgets2.7 (2.7.1.1-0) unstable; urgency=low
-
-  * First 2.7.x release from wxPython team.
-  * Many enhancements, changes, fixes and updates.  See 
-    http://wxpython.org/CHANGES.txt for details.
-
- -- Robin Dunn <robin@alldunn.com>  Wed, 18 Oct 2006 17:09:53 -0700
-
 wxwidgets2.7 (2.7.0.0-2) unstable; urgency=low

  * Fixes to ansi packages builds
--- a/distrib/scripts/Bakefiles.release.bkgen
+++ b/distrib/scripts/Bakefiles.release.bkgen
@@ -2,6 +2,6 @@
 <bakefile-gen>
  <include file="../../build/bakefiles/Bakefiles.bkgen"/>
  <!-- add extra formats to release -->
-  <enable-formats>gnu,dmars,dmars_smake,msevc4prj</enable-formats>
+  <enable-formats>dmars,dmars_smake,msevc4prj</enable-formats>
 </bakefile-gen>

--- a/distrib/scripts/build-environ.cfg
+++ b/distrib/scripts/build-environ.cfg
@@ -17,7 +17,7 @@ DOCDIR=${WX_TEMP_DIR}/wxWidgets/docs/
 CURDATE=`date -I`

 # build info
-BUILD_VERSION=2.7.2-rc1
+BUILD_VERSION=2.7.1-rc
 BUILD_TAG=HEAD


--- a/distrib/scripts/create_archives.sh
+++ b/distrib/scripts/create_archives.sh
@@ -114,20 +114,11 @@ doinit()
 dospinport(){
    port=$1
    
-    case "$port" in
-        all)
-            portname="Widgets";;
-        base)
-            portname="Base";;
-        motif)
-            portname="Motif";;
-        mac)
-            portname="Mac";;
-        *)
-            # for all the others (DFB, GTK, MGL, MSW, X11) just use the
-            # upper-case version as they are abbreviations
-            portname=`echo $port | tr '[a-z]' '[A-Z]'`;;
-    esac
+    if [ $port != "all" ]; then
+        portname="`echo $port|tr '[a-z]' '[A-Z]'`"    
+    else
+        portname="Widgets"
+    fi
    
    echo "Creating wx$portname distribution..."

--- a/docs/changes.txt
+++ b/docs/changes.txt
@@ -38,6 +38,7 @@ INCOMPATIBLE CHANGES SINCE 2.6.x
 - wxDialog::CreateButtonSizer() may return NULL now, please see the manual


+
 Deprecated methods since 2.6.x and their replacements
 -----------------------------------------------------

@@ -51,18 +52,6 @@ Major changes in 2.7 release
 - New AUI library supporting docking windows and much more


-2.7.2
-----
-
-All (GUI): 
-
- wxMemoryDC constructor now optionally accepts a wxBitmap parameter,
-  calling SelectObject itself if a valid bitmap is passed.
- Reverted wxBuffered[Paint]DC to pre 2.7.1 state, added
-  wxAutoBufferedPaintDC and wxAutoBufferedPaintDCFactory.
-
-
-
 2.7.1
 -----

--- a/docs/latex/wx/bufferdc.tex
+++ b/docs/latex/wx/bufferdc.tex
@@ -22,12 +22,11 @@ your \texttt{OnPaint()} handler, you should look at
 \helpref{wxBufferedPaintDC}{wxbufferedpaintdc} or \helpref{wxAutoBufferedPaintDC}{wxautobufferedpaintdc}.

 Please note that GTK+ 2.0 as well as OS X provide double buffering themselves
-+natively. Use \helpref{wxWindow::IsDoubleBuffered}{wxwindowisdoublebuffered} to
-+determine whether you need to use buffering or not.
+natively. wxBufferedDC is aware of this however, and will bypass the buffering
+unless explicit buffer bitmap is given.

 \wxheading{Derived from}

-\helpref{wxMemoryDC}{wxmemorydc}\\
 \helpref{wxDC}{wxdc}\\
 \helpref{wxObject}{wxobject}

@@ -49,10 +48,10 @@ Please note that GTK+ 2.0 as well as OS X provide double buffering themselves

 \func{}{wxBufferedDC}{\void}

-\func{}{wxBufferedDC}{\param{wxDC *}{dc}, \param{const wxSize\& }{area}, \param{int }{style = wxBUFFER\_CLIENT\_AREA}}
-
 \func{}{wxBufferedDC}{\param{wxDC *}{dc}, \param{const wxBitmap\& }{buffer}, \param{int }{style = wxBUFFER\_CLIENT\_AREA}}

+\func{}{wxBufferedDC}{\param{wxWindow*}{window}, \param{wxDC *}{dc}, \param{const wxSize\& }{area}, \param{int }{style = wxBUFFER\_CLIENT\_AREA}}
+
 If you use the first, default, constructor, you must call one of the 
 \helpref{Init}{wxbuffereddcinit} methods later in order to use the object.

@@ -65,6 +64,10 @@ must not be called after using them.
 flushed to this DC when this object is destroyed.  You may pass NULL
 in order to just initialize the buffer, and not flush it.}

+\docparam{window}{The window on which the dc paints. May be NULL, but
+you should normally specify this so that the DC can be aware whether the
+surface is natively double-buffered or not.}
+
 \docparam{area}{The size of the bitmap to be used for buffering (this bitmap is
 created internally when it is not given explicitly).}

@@ -80,10 +83,10 @@ device context).}

 \membersection{wxBufferedDC::Init}\label{wxbuffereddcinit}

-\func{void}{Init}{\param{wxDC *}{dc}, \param{const wxSize\& }{area}, \param{int }{style = wxBUFFER\_CLIENT\_AREA}}
-
 \func{void}{Init}{\param{wxDC *}{dc}, \param{const wxBitmap\& }{buffer}, \param{int }{style = wxBUFFER\_CLIENT\_AREA}}

+\func{void}{Init}{\param{wxWindow*}{window}, \param{wxDC *}{dc}, \param{const wxSize\& }{area}, \param{int }{style = wxBUFFER\_CLIENT\_AREA}}
+
 These functions initialize the object created using the default constructor.
 Please see \helpref{constructors documentation}{wxbuffereddcctor} for details.

@@ -113,7 +116,6 @@ already does this internally for the real underlying wxPaintDC.
 \wxheading{Derived from}

 \helpref{wxBufferedDC}{wxbuffereddc}\\
-\helpref{wxMemoryDC}{wxmemorydc}\\
 \helpref{wxDC}{wxdc}\\
 \helpref{wxObject}{wxobject}

--- a/docs/latex/wx/memorydc.tex
+++ b/docs/latex/wx/memorydc.tex
@@ -41,14 +41,13 @@ can be reselected into another memory DC.

 \membersection{wxMemoryDC::wxMemoryDC}\label{wxmemorydcctor}

-\func{}{wxMemoryDC}{\param{const wxBitmap\& }{bitmap = wxNullBitmap}}
+\func{}{wxMemoryDC}{\void}

 Constructs a new memory device context.

 Use the {\it Ok} member to test whether the constructor was successful
-in creating a usable device context. If you don't pass a valid bitmap
-to the constructor, don't forget to select a bitmap into the DC before
-drawing on it.
+in creating a usable device context. Don't forget to select a bitmap
+into the DC before drawing on it.

 \membersection{wxMemoryDC::SelectObject}\label{wxmemorydcselectobject}

--- a/docs/latex/wx/window.tex
+++ b/docs/latex/wx/window.tex
@@ -3603,10 +3603,9 @@ This function is currently only implemented under MSW.

 Calling this method immediately repaints the invalidated area of the window and
 all of its children recursively while this would usually only happen when the
-flow of control returns to the event loop. 
-Notice that this function doesn't invalidate any area of the window so
-nothing happens if nothing has been invalidated (i.e. marked as requiring
-a redraw). Use \helpref{Refresh}{wxwindowrefresh} first if you want to
+flow of control returns to the event loop. Notice that this function doesn't
+refresh the window and does nothing if the window hadn't been already
+repainted. Use \helpref{Refresh}{wxwindowrefresh} first if you want to
 immediately redraw the window unconditionally.


--- a/include/wx/aui/floatpane.h
+++ b/include/wx/aui/floatpane.h
@@ -35,24 +35,18 @@ public:
    wxFloatingPane(wxWindow* parent,
                   wxFrameManager* owner_mgr,
                   const wxPaneInfo& pane,
-                   wxWindowID id = wxID_ANY,
-                   long style = wxRESIZE_BORDER | wxSYSTEM_MENU | wxCAPTION |
-                                wxFRAME_NO_TASKBAR | wxFRAME_FLOAT_ON_PARENT | 
-                                wxCLIP_CHILDREN
+                   wxWindowID id = wxID_ANY
                   );
    virtual ~wxFloatingPane();
    void SetPaneWindow(const wxPaneInfo& pane);
-    
-protected:
-    virtual void OnMoveStart();
-    virtual void OnMoving(const wxRect& window_rect, wxDirection dir);
-    virtual void OnMoveFinished();
-    
 private:
    void OnSize(wxSizeEvent& event);
    void OnClose(wxCloseEvent& event);
    void OnMoveEvent(wxMoveEvent& event);
    void OnIdle(wxIdleEvent& event);
+    void OnMoveStart();
+    void OnMoving(const wxRect& window_rect, wxDirection dir);
+    void OnMoveFinished();
    void OnActivate(wxActivateEvent& event);
    static bool isMouseDown();
 private:
--- a/include/wx/aui/framemanager.h
+++ b/include/wx/aui/framemanager.h
@@ -218,7 +218,6 @@ public:
    bool IsRightDockable() const { return HasFlag(optionRightDockable); }
    bool IsFloatable() const { return HasFlag(optionFloatable); }
    bool IsMovable() const { return HasFlag(optionMovable); }
-    bool IsDestroyOnClose() const { return HasFlag(optionDestroyOnClose); }
    bool HasCaption() const { return HasFlag(optionCaption); }
    bool HasGripper() const { return HasFlag(optionGripper); }
    bool HasBorder() const { return HasFlag(optionPaneBorder); }
@@ -383,7 +382,7 @@ public:



-class WXDLLIMPEXP_AUI wxFloatingPane;
+

 class WXDLLIMPEXP_AUI wxFrameManager : public wxEvtHandler
 {
@@ -428,8 +427,6 @@ public:
                 int insert_level = wxAUI_INSERT_PANE);

    bool DetachPane(wxWindow* window);
-    
-    void ClosePane(wxPaneInfo& pane_info);

    wxString SavePaneInfo(wxPaneInfo& pane);
    void LoadPaneInfo(wxString pane_part, wxPaneInfo &pane);
@@ -443,7 +440,6 @@ public:


 public:
-    virtual wxFloatingPane * CreateFloatingFrame(wxWindow* parent, const wxPaneInfo& p);

    void DrawHintRect(wxWindow* pane_window,
                       const wxPoint& pt,
--- a/include/wx/bmpcbox.h
+++ b/include/wx/bmpcbox.h
@@ -5,7 +5,7 @@
 // Modified by:
 // Created:     Aug-31-2006
 // Copyright:   (c) Jaakko Salli
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

--- a/include/wx/cocoa/NSPanel.h
+++ b/include/wx/cocoa/NSPanel.h
@@ -4,7 +4,7 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/03/16
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) 2003 David Elliott
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
--- a/include/wx/cocoa/NSView.h
+++ b/include/wx/cocoa/NSView.h
@@ -4,7 +4,7 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/02/15
-// RCS-ID:      $Id$
+// RCS-ID:      $Id: 
 // Copyright:   (c) 2003 David Elliott
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
@@ -30,7 +30,7 @@ protected:
    static void *sm_cocoaObserver;
 public:
    virtual wxWindow* GetWxWindow() const
-    {   return NULL; }
+    {	return NULL;	}
    virtual void Cocoa_FrameChanged(void) = 0;
    virtual bool Cocoa_acceptsFirstMouse(bool &acceptsFirstMouse, WX_NSEvent theEvent)
    {   return false; }
@@ -61,9 +61,8 @@ public:
    virtual bool Cocoa_otherMouseUp(WX_NSEvent theEvent)
    {   return false; }
    virtual bool Cocoa_resetCursorRects()
-    {   return false; }
+    {	return false; }
    virtual ~wxCocoaNSView() { }
 };

-#endif
-    // __WX_COCOA_NSVIEW_H__
+#endif // _WX_COCOA_NSVIEW_H_
--- a/include/wx/cocoa/NSWindow.h
+++ b/include/wx/cocoa/NSWindow.h
@@ -4,7 +4,7 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/03/16
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) 2003 David Elliott
 // Licence:     wxWindows licence
 ///////////////////////////////////////////////////////////////////////////////
--- a/include/wx/cocoa/ObjcAssociate.h
+++ b/include/wx/cocoa/ObjcAssociate.h
@@ -2,9 +2,9 @@
 // Name:        wx/cocoa/ObjcAssociate.h
 // Purpose:     Associates an Objective-C class with a C++ class
 // Author:      David Elliott
-// Modified by:
+// Modified by: 
 // Created:     2002/12/03
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) 2002 David Elliott <dfe@cox.net>
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
@@ -76,3 +76,4 @@ void wxClass::Set##ObjcClass(WX_##ObjcClass cocoaObjcClass) \
 }

 #endif // __WX_COCOA_OBJC_ASSOCIATE_H__
+
--- a/include/wx/cocoa/ObjcPose.h
+++ b/include/wx/cocoa/ObjcPose.h
@@ -2,9 +2,9 @@
 // Name:        wx/cocoa/ObjcPose.h
 // Purpose:     Macros for initializing poseAs, among other things
 // Author:      David Elliott
-// Modified by:
+// Modified by: 
 // Created:     2002/12/03
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) 2002 David Elliott <dfe@cox.net>
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
@@ -22,31 +22,31 @@ Objective-C Poser class initialization
 class wxPoseAsInitializer
 {
 public:
-    wxPoseAsInitializer()
-    : m_next(sm_first)
-    {
-        sm_first = this;
-    }
-    virtual ~wxPoseAsInitializer()
-    {
-        sm_first = m_next;
-    }
-    static void InitializePosers()
-    {
-        while(sm_first)
-        {
-            delete sm_first;
-        }
-    };
+	wxPoseAsInitializer()
+	: m_next(sm_first)
+	{
+		sm_first = this;
+	}
+	virtual ~wxPoseAsInitializer()
+	{
+		sm_first = m_next;
+	}
+	static void InitializePosers()
+	{
+		while(sm_first)
+		{
+			delete sm_first;
+		}
+	};
 protected:
-    wxPoseAsInitializer *m_next;
-    static wxPoseAsInitializer *sm_first;
+	wxPoseAsInitializer *m_next;
+	static wxPoseAsInitializer *sm_first;
 };

 class wxDummyForPoseAsInitializer
 {
 public:
-    wxDummyForPoseAsInitializer(void*) {}
+	wxDummyForPoseAsInitializer(void*) {}
 };

 #define WX_IMPLEMENT_POSER(poser) \
@@ -65,3 +65,4 @@ wxDummyForPoseAsInitializer wxDummyPoseAsInitializerFor##poser(new wxPoseAsIniti
 #endif // __OBJC__

 #endif // __WX_COCOA_PRIVATE_POSER_H__
+
--- a/include/wx/cocoa/bitmap.h
+++ b/include/wx/cocoa/bitmap.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/cocoa/bitmap.h
+// Name:        include/wx/cocoa/bitmap.h
 // Purpose:     wxBitmap class
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/07/19
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_BITMAP_H__
@@ -86,7 +86,7 @@ public:

    // destructor
    virtual ~wxBitmap();
-
+  
 // ------------------------------------------------------------------------
 // Implementation
 // ------------------------------------------------------------------------
@@ -131,7 +131,7 @@ public:
    void SetMask(wxMask *mask) ;

    int GetBitmapType() const;
-
+  
    inline bool operator == (const wxBitmap& bitmap) const
    {   return m_refData == bitmap.m_refData; }
    inline bool operator != (const wxBitmap& bitmap) const
@@ -155,5 +155,4 @@ class WXDLLIMPEXP_CORE wxBitmapHandler: public wxBitmapHandlerBase
    DECLARE_ABSTRACT_CLASS(wxBitmapHandler)
 };

-#endif
-    // __WX_COCOA_BITMAP_H__
+#endif // __WX_COCOA_BITMAP_H__
--- a/include/wx/cocoa/bmpbuttn.h
+++ b/include/wx/cocoa/bmpbuttn.h
@@ -4,9 +4,9 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/03/16
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_BMPBUTTN_H__
--- a/include/wx/cocoa/button.h
+++ b/include/wx/cocoa/button.h
@@ -4,9 +4,9 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2002/12/29
-// RCS-ID:      $Id$
+// RCS-ID:      $Id: 
 // Copyright:   (c) 2002 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_BUTTON_H__
@@ -36,7 +36,7 @@ public:
    {
        Create(parent, winid, label, pos, size, style, validator, name);
    }
-
+    

    bool Create(wxWindow *parent, wxWindowID winid,
            const wxString& label = wxEmptyString,
@@ -44,7 +44,7 @@ public:
            const wxSize& size = wxDefaultSize, long style = 0,
            const wxValidator& validator = wxDefaultValidator,
            const wxString& name = wxButtonNameStr);
-
+    
    virtual ~wxButton();

 // ------------------------------------------------------------------------
@@ -61,5 +61,4 @@ public:
    wxSize DoGetBestSize() const;
 };

-#endif
-    // __WX_COCOA_BUTTON_H__
+#endif // __WX_COCOA_BUTTON_H__
--- a/include/wx/cocoa/control.h
+++ b/include/wx/cocoa/control.h
@@ -4,9 +4,9 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/02/15
-// RCS-ID:      $Id$
+// RCS-ID:      $Id: 
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_CONTROL_H__
@@ -53,7 +53,7 @@ public:
    // --------------------------

    void OnEraseBackground(wxEraseEvent& event);
-
+   
    virtual void Command(wxCommandEvent& event) { ProcessCommand(event); }

    // Calls the callback and appropriate event handlers
@@ -65,5 +65,4 @@ protected:
    virtual wxSize DoGetBestSize() const;
 };

-#endif
-    // __WX_COCOA_CONTROL_H__
+#endif // __WX_COCOA_CONTROL_H__
--- a/include/wx/cocoa/cursor.h
+++ b/include/wx/cocoa/cursor.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/cocoa/cursor.h
+// Name:        cursor.h
 // Purpose:     wxCursor class
 // Author:      David Elliott <dfe@cox.net>
 // Modified by:
 // Created:     2002/11/27
-// RCS-ID:      $Id$
+// RCS-ID:      
 // Copyright:   (c) David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_COCOA_CURSOR_H_
@@ -17,7 +17,7 @@
 class WXDLLEXPORT wxCursorRefData: public wxObjectRefData
 {
    DECLARE_NO_COPY_CLASS(wxCursorRefData)
-
+        
    friend class WXDLLEXPORT wxBitmap;
    friend class WXDLLEXPORT wxCursor;
 public:
@@ -54,9 +54,9 @@ public:

  inline bool operator == (const wxCursor& cursor) const { return m_refData == cursor.m_refData; }
  inline bool operator != (const wxCursor& cursor) const { return m_refData != cursor.m_refData; }
-
+  
  inline WX_NSCursor GetNSCursor() const
-  {
+  {	
    return (M_CURSORDATA ? M_CURSORDATA->m_hCursor : 0);
  }

@@ -64,5 +64,4 @@ public:

 extern WXDLLEXPORT void wxSetCursor(const wxCursor& cursor);

-#endif
-    // _WX_COCOA_CURSOR_H_
+#endif // _WX_COCOA_CURSOR_H_
--- a/include/wx/cocoa/dcclient.h
+++ b/include/wx/cocoa/dcclient.h
@@ -6,7 +6,7 @@
 // Created:     2003/04/01
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_DCCLIENT_H__
@@ -66,5 +66,4 @@ protected:
    virtual bool CocoaUnlockFocus();
 };

-#endif
-    // __WX_COCOA_DCCLIENT_H__
+#endif // __WX_COCOA_DCCLIENT_H__
--- a/include/wx/cocoa/dcmemory.h
+++ b/include/wx/cocoa/dcmemory.h
@@ -6,7 +6,7 @@
 // Created:     2003/03/16
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_DCMEMORY_H__
@@ -18,7 +18,7 @@ class WXDLLEXPORT wxMemoryDC: public wxDC
 {
    DECLARE_DYNAMIC_CLASS(wxMemoryDC)
 public:
-    wxMemoryDC( const wxBitmap& bitmap = wxNullBitmap );
+    wxMemoryDC(void);
    wxMemoryDC( wxDC *dc ); // Create compatible DC
    virtual ~wxMemoryDC(void);
    virtual void SelectObject(const wxBitmap& bitmap);
@@ -36,5 +36,4 @@ protected:
        int logicalFunc, bool useMask, wxCoord xsrcMask, wxCoord ysrcMask);
 };

-#endif
-    // __WX_COCOA_DCMEMORY_H__
+#endif // __WX_COCOA_DCMEMORY_H__
--- a/include/wx/cocoa/dcscreen.h
+++ b/include/wx/cocoa/dcscreen.h
@@ -4,9 +4,9 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/03/16
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_DCSCREEN_H__
--- a/include/wx/cocoa/frame.h
+++ b/include/wx/cocoa/frame.h
@@ -4,7 +4,7 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/03/16
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) 2003 David Elliott
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
@@ -15,7 +15,7 @@
 class WXDLLEXPORT wxMenuBar;
 class WXDLLEXPORT wxStatusBar;

-class WXDLLEXPORT wxFrame: public wxFrameBase
+class WXDLLEXPORT wxFrame: public wxFrameBase 
 {
    DECLARE_EVENT_TABLE()
    DECLARE_DYNAMIC_CLASS(wxFrame)
@@ -95,7 +95,7 @@ public:
 #if wxUSE_TOOLBAR
    // create main toolbar bycalling OnCreateToolBar()
    virtual wxToolBar* CreateToolBar(long style = -1,
-                                     wxWindowID winid = wxID_ANY,
+                                     wxWindowID winid = -1,
                                     const wxString& name = wxToolBarNameStr);
    // sets the main tool bar
    virtual void SetToolBar(wxToolBar *toolbar);
--- a/include/wx/cocoa/gauge.h
+++ b/include/wx/cocoa/gauge.h
@@ -6,7 +6,7 @@
 // Created:     2003/07/15
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_GAUGE_H__
@@ -70,5 +70,4 @@ protected:
    virtual wxSize DoGetBestSize() const;
 };

-#endif
-    // __WX_COCOA_GAUGE_H__
+#endif // __WX_COCOA_GAUGE_H__
--- a/include/wx/cocoa/icon.h
+++ b/include/wx/cocoa/icon.h
@@ -6,7 +6,7 @@
 // Created:     2003/08/11
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_COCOA_ICON_H__
@@ -58,5 +58,4 @@ public:
    bool CreateFromXpm(const char **bits);
 };

-#endif
-    // _WX_COCOA_ICON_H__
+#endif // _WX_COCOA_ICON_H__
--- a/include/wx/cocoa/radiobut.h
+++ b/include/wx/cocoa/radiobut.h
@@ -4,9 +4,9 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/03/18
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_RADIOBUT_H__
--- a/include/wx/cocoa/region.h
+++ b/include/wx/cocoa/region.h
@@ -2,11 +2,11 @@
 // Name:        wx/cocoa/region.h
 // Purpose:     wxRegion class
 // Author:      David Elliott
-// Modified by:
+// Modified by: 
 // Created:     2004/04/12
 // RCS-ID:      $Id$
 // Copyright:   (c) 2004 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_COCOA_REGION_H__
@@ -68,5 +68,4 @@ public:
    {   return *(wxRegionIterator*)&(this->wxRegionIteratorGeneric::operator=(iter)); }
 };

-#endif
-    //ndef _WX_COCOA_REGION_H__
+#endif //ndef _WX_COCOA_REGION_H__
--- a/include/wx/cocoa/scrolbar.h
+++ b/include/wx/cocoa/scrolbar.h
@@ -6,7 +6,7 @@
 // Created:     2004/04/25
 // RCS-ID:      $Id$
 // Copyright:   (c) 2004 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_COCOA_SCROLBAR_H__
@@ -71,5 +71,4 @@ protected:
    int m_pageSize;
 };

-#endif
-    // _WX_COCOA_SCROLBAR_H__
+#endif // _WX_COCOA_SCROLBAR_H__
--- a/include/wx/cocoa/slider.h
+++ b/include/wx/cocoa/slider.h
@@ -6,7 +6,7 @@
 // Created:     2003/06/19
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_SLIDER_H__
@@ -79,5 +79,4 @@ public:

 };

-#endif
-    // __WX_COCOA_SLIDER_H__
+#endif // __WX_COCOA_SLIDER_H__
--- a/include/wx/cocoa/spinbutt.h
+++ b/include/wx/cocoa/spinbutt.h
@@ -6,7 +6,7 @@
 // Created:     2003/07/14
 // RCS-ID:      $Id$
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_SPINBUTT_H__
@@ -27,7 +27,7 @@ class WXDLLEXPORT wxSpinButton: public wxSpinButtonBase// , protected wxCocoaNSS
 // ------------------------------------------------------------------------
 public:
    wxSpinButton() { }
-    wxSpinButton(wxWindow *parent, wxWindowID winid = wxID_ANY,
+    wxSpinButton(wxWindow *parent, wxWindowID winid = -1,
            const wxPoint& pos = wxDefaultPosition,
            const wxSize& size = wxDefaultSize,
            long style = wxSP_VERTICAL | wxSP_ARROW_KEYS,
@@ -36,7 +36,7 @@ public:
        Create(parent, winid, pos, size, style, name);
    }

-    bool Create(wxWindow *parent, wxWindowID winid = wxID_ANY,
+    bool Create(wxWindow *parent, wxWindowID winid = -1,
            const wxPoint& pos = wxDefaultPosition,
            const wxSize& size = wxDefaultSize,
            long style = wxSP_HORIZONTAL,
@@ -60,5 +60,4 @@ public:
    virtual void SetRange(int minValue, int maxValue);
 };

-#endif
-    // __WX_COCOA_SPINBUTT_H__
+#endif // __WX_COCOA_SPINBUTT_H__
--- a/include/wx/cocoa/statbmp.h
+++ b/include/wx/cocoa/statbmp.h
@@ -4,9 +4,9 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/03/16
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_STATBMP_H__
--- a/include/wx/cocoa/statbox.h
+++ b/include/wx/cocoa/statbox.h
@@ -4,9 +4,9 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/03/18
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_STATBOX_H__
--- a/include/wx/cocoa/statline.h
+++ b/include/wx/cocoa/statline.h
@@ -4,9 +4,9 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/03/18
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_STATLINE_H__
--- a/include/wx/cocoa/stattext.h
+++ b/include/wx/cocoa/stattext.h
@@ -4,9 +4,9 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/02/15
-// RCS-ID:      $Id$
+// RCS-ID:      $Id: 
 // Copyright:   (c) 2003 David Elliott
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __WX_COCOA_STATTEXT_H__
@@ -55,5 +55,4 @@ public:
    void SetLabel(const wxString& label);
 };

-#endif
-    // __WX_COCOA_STATTEXT_H__
+#endif // __WX_COCOA_STATTEXT_H__
--- a/include/wx/cocoa/textctrl.h
+++ b/include/wx/cocoa/textctrl.h
@@ -4,7 +4,7 @@
 // Author:      David Elliott
 // Modified by:
 // Created:     2003/03/16
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) 2003 David Elliott
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
--- a/include/wx/dcbuffer.h
+++ b/include/wx/dcbuffer.h
@@ -16,15 +16,29 @@
 #include "wx/dcclient.h"
 #include "wx/window.h"

+
+// I think this patch should be test on wxMac with
+// wxTEST_PAINTDCDELEGATION as 1, and then with
+// with wxTEST_MEMORYDCDELEGATION as 1.
+#define wxTEST_PAINTDCDELEGATION        0
+#define wxTEST_MEMORYDCDELEGATION       0
+
+
 // Split platforms into two groups - those which have well-working
 // double-buffering by default, and those which do not.
-#if defined(__WXMAC__) || defined(__WXGTK20__) || defined(__WXDFB__)
+#if defined(__WXMAC__) || defined(__WXGTK20__)
    #define wxALWAYS_NATIVE_DOUBLE_BUFFER       1
 #else
    #define wxALWAYS_NATIVE_DOUBLE_BUFFER       0
 #endif


+#if wxTEST_PAINTDCDELEGATION || wxTEST_MEMORYDCDELEGATION
+    #undef wxALWAYS_NATIVE_DOUBLE_BUFFER
+    #define wxALWAYS_NATIVE_DOUBLE_BUFFER 0
+#endif
+
+
 // ----------------------------------------------------------------------------
 // Double buffering helper.
 // ----------------------------------------------------------------------------
@@ -37,11 +51,12 @@
 // does not prepare the window DC
 #define wxBUFFER_CLIENT_AREA        0x02

-class WXDLLEXPORT wxBufferedDC : public wxMemoryDC
+class WXDLLEXPORT wxBufferedDC : public wxDC
 {
 public:
    // Default ctor, must subsequently call Init for two stage construction.
-    wxBufferedDC() : m_dc( 0 ), m_buffer(NULL), m_style(0)
+    wxBufferedDC() : wxDC(), m_targetDc(NULL), m_mainDc(NULL),
+                     m_buffer(NULL), m_style(0)
    {
    }

@@ -49,23 +64,38 @@ public:
    wxBufferedDC(wxDC *dc,
                 const wxBitmap &buffer = wxNullBitmap,
                 int style = wxBUFFER_CLIENT_AREA)
-        : m_dc( dc ),
-          m_buffer( &buffer ),
-          m_style(style)
+        : wxDC(),
+          m_targetDc(NULL),
+          m_mainDc(NULL)
    {
-        UseBuffer();
+        // All other members except dcs are initialized in Init
+        Init(dc, buffer, style);
    }

    // Construct a wxBufferedDC with an internal buffer of 'area'
    // (where area is usually something like the size of the window
    // being buffered)
    wxBufferedDC(wxDC *dc, const wxSize &area, int style = wxBUFFER_CLIENT_AREA)
-        : m_dc( dc ),
-          m_buffer(NULL),
-          m_style(style)
-
+        : wxDC(),
+          m_targetDc(NULL),
+          m_mainDc(NULL)
    {
-        UseBuffer(area.x, area.y);
+        // All other members except dcs are initialized in Init
+        Init(NULL, dc, area, style);
+    }
+
+    // Same, but also receives window to detect whether it is
+    // natively double-buffered.
+    wxBufferedDC(wxWindow* win,
+                 wxDC *dc,
+                 const wxSize &area,
+                 int style = wxBUFFER_CLIENT_AREA)
+        : wxDC(),
+          m_targetDc(NULL),
+          m_mainDc(NULL)
+    {
+        // All other members except dcs are initialized in Init
+        Init(win, dc, area, style);
    }

    // default copy ctor ok.
@@ -73,31 +103,55 @@ public:
    // The usually desired  action in the dtor is to blit the buffer.
    virtual ~wxBufferedDC()
    {
-        if ( m_dc ) UnMask();
+        UnMask();
    }

-    // These reimplement the actions of the ctors for two stage creation, but
-    // are not used by the ctors themselves to save a few cpu cycles.
    void Init(wxDC *dc,
-              const wxBitmap &buffer=wxNullBitmap,
+              const wxBitmap &buffer,
              int style = wxBUFFER_CLIENT_AREA)
    {
-        wxASSERT_MSG( m_dc == 0 && m_buffer == NULL,
-                      _T("wxBufferedDC already initialised") );
-        m_dc = dc;
+        wxASSERT_MSG( m_mainDc == NULL,
+                      wxT("wxBufferedDC already initialised") );
+        wxASSERT_MSG( buffer.Ok(),
+                      wxT("invalid bitmap") );
+        m_mainDc = dc;
        m_buffer = &buffer;
        m_style = style;
        UseBuffer();
    }

-    void Init(wxDC *dc, const wxSize &area, int style = wxBUFFER_CLIENT_AREA)
+    void Init(wxWindow* win,
+              wxDC *dc,
+              const wxSize &area = wxDefaultSize,
+              int style = wxBUFFER_CLIENT_AREA)
    {
-        wxASSERT_MSG( m_dc == 0 && m_buffer == NULL,
-                      _T("wxBufferedDC already initialised") );
-        m_dc = dc;
-        m_buffer = NULL;
+        wxASSERT_MSG( m_mainDc == NULL,
+                      wxT("wxBufferedDC already initialised") );
+
+        m_mainDc = dc;
        m_style = style;
-        UseBuffer(area.x, area.y);
+
+#if wxTEST_MEMORYDCDELEGATION
+        if ( 0 )
+#elif wxTEST_PAINTDCDELEGATION
+        if ( 1 )
+#else
+        if ( win && win->IsDoubleBuffered() )
+#endif
+        {
+            AttachDC(dc);
+            m_buffer = NULL;
+        }
+        else
+        {
+            PrepareBuffer(win, area);
+            UseBuffer();
+        }
+    }
+
+    void Init(wxDC *dc, const wxSize &area = wxDefaultSize, int style = wxBUFFER_CLIENT_AREA)
+    {
+        Init(NULL, dc, area, style);
    }

    // Blits the buffer to the dc, and detaches the dc from the buffer (so it
@@ -106,45 +160,443 @@ public:
    // Usually called in the dtor or by the dtor of derived classes if the
    // BufferedDC must blit before the derived class (which may own the dc it's
    // blitting to) is destroyed.
-    void UnMask()
-    {
-        wxASSERT_MSG( m_dc != 0,
-                      _T("No underlying DC associated with wxBufferedDC (anymore)") );
-
-        wxCoord x=0, y=0;
-
-        if (m_style & wxBUFFER_CLIENT_AREA)
-            GetDeviceOrigin(&x, &y);
-
-        m_dc->Blit( 0, 0,
-                    m_buffer->GetWidth(), m_buffer->GetHeight(), this,
-                    -x, -y );
-        m_dc = NULL;
-    }
+    void UnMask();

    // Set and get the style
    void SetStyle(int style) { m_style = style; }
    int GetStyle() const { return m_style; }

 private:
-    // check that the bitmap is valid and use it
-    void UseBuffer(wxCoord w = -1, wxCoord h = -1);
+    // Prepares wxMemoryDC.
+    void UseBuffer();

-    // the underlying DC to which we copy everything drawn on this one in
-    // UnMask()
+    // Allocate m_buffer, if necessary.
+    void PrepareBuffer(wxWindow* win, const wxSize& area);
+
+    // DC to which calls are delegated.
+    wxDC*           m_targetDc;
+
+    // This the underlying DC to which we copy everything drawn on
+    // this one in UnMask().
    //
    // NB: Without the existence of a wxNullDC, this must be a pointer, else it
    //     could probably be a reference.
-    wxDC *m_dc;
+    wxDC*           m_mainDc;

    // the buffer (selected in this DC)
-    const wxBitmap *m_buffer;
+    const wxBitmap* m_buffer;

    // the buffering style
-    int m_style;
+    int             m_style;

-    DECLARE_DYNAMIC_CLASS(wxBufferedDC)
    DECLARE_NO_COPY_CLASS(wxBufferedDC)
+public:
+    //
+    // BEGIN DC-DELEGATION IMPLEMENTATION
+    //
+
+    wxDC& GetAttachedDC()
+    {
+        return *m_targetDc;
+    }
+
+    // Use this to set the DC which receives delegated calls.
+    void AttachDC(wxDC* dc)
+    {
+        m_targetDc = dc;
+    #ifdef __WXMSW__
+        SetHDC( dc ? dc->GetHDC() : NULL );
+    #endif
+    }
+
+    // Sets DC to NULL
+    wxDC* DetachDC()
+    {
+        wxDC* retDc = m_targetDc;
+        AttachDC(NULL);
+        return retDc;
+    }
+
+#ifdef __WXGTK__
+    virtual GdkWindow* GetGDKWindow() const
+    {
+        return m_targetDc->GetGDKWindow();
+    }
+    virtual wxBitmap GetSelectedBitmap() const
+    {
+        return m_targetDc->GetSelectedBitmap();
+    }
+#endif
+
+    bool Blit(wxCoord xdest, wxCoord ydest, wxCoord width, wxCoord height,
+              wxDC *source, wxCoord xsrc, wxCoord ysrc,
+              int rop = wxCOPY, bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord)
+        { return m_targetDc->Blit(xdest, ydest, width, height,
+                                  source, xsrc, ysrc, rop,
+                                  useMask, xsrcMask, ysrcMask); }
+    bool Blit(const wxPoint& destPt, const wxSize& sz,
+              wxDC *source, const wxPoint& srcPt,
+              int rop = wxCOPY, bool useMask = false, const wxPoint& srcPtMask = wxDefaultPosition)
+        { return m_targetDc->Blit(destPt, sz, source, srcPt,
+                                  rop, useMask, srcPtMask); }
+    virtual void CalcBoundingBox(wxCoord x, wxCoord y) { m_targetDc->CalcBoundingBox(x, y); }
+#if defined(__WXWINCE__)
+    void CalculateEllipticPoints( wxList* points,
+                                  wxCoord xStart, wxCoord yStart,
+                                  wxCoord w, wxCoord h,
+                                  double sa, double ea )
+        { m_targetDc->CalculateEllipticPoints(points, xStart, yStart, w,
+                                              h, sa, ea); }
+#endif // defined(__WXWINCE__)
+    virtual bool CanDrawBitmap() const { return m_targetDc->CanDrawBitmap(); }
+    virtual bool CanGetTextExtent() const { return m_targetDc->CanGetTextExtent(); }
+    virtual void Clear() { m_targetDc->Clear(); }
+    virtual void ComputeScaleAndOrigin() { m_targetDc->ComputeScaleAndOrigin(); }
+    void CrossHair(wxCoord x, wxCoord y) { m_targetDc->CrossHair(x, y); }
+    void CrossHair(const wxPoint& pt) { m_targetDc->CrossHair(pt); }
+    virtual void DestroyClippingRegion() { m_targetDc->DestroyClippingRegion(); }
+    wxCoord DeviceToLogicalX(wxCoord x) const { return m_targetDc->DeviceToLogicalX(x); }
+    wxCoord DeviceToLogicalXRel(wxCoord x) const { return m_targetDc->DeviceToLogicalXRel(x); }
+    wxCoord DeviceToLogicalY(wxCoord y) const { return m_targetDc->DeviceToLogicalY(y); }
+    wxCoord DeviceToLogicalYRel(wxCoord y) const { return m_targetDc->DeviceToLogicalYRel(y); }
+#if defined(__WXWINCE__)
+    virtual void DoDrawEllipticArcRot( wxCoord x, wxCoord y,
+                                       wxCoord w, wxCoord h,
+                                       double sa = 0, double ea = 0, double angle = 0 )
+        { m_targetDc->DoDrawEllipticArcRot(x, y, w, h,
+                                           sa, ea, angle); }
+#endif // defined(__WXWINCE__)
+    void DrawArc(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2,
+                 wxCoord xc, wxCoord yc)
+        { m_targetDc->DrawArc(x1, y1, x2, y2,
+                              xc, yc); }
+    void DrawArc(const wxPoint& pt1, const wxPoint& pt2, const wxPoint& centre)
+        { m_targetDc->DrawArc(pt1, pt2, centre); }
+    void DrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
+                    bool useMask = false)
+        { m_targetDc->DrawBitmap(bmp, x, y, useMask); }
+    void DrawBitmap(const wxBitmap &bmp, const wxPoint& pt,
+                    bool useMask = false)
+        { m_targetDc->DrawBitmap(bmp, pt, useMask); }
+    void DrawCheckMark(wxCoord x, wxCoord y,
+                       wxCoord width, wxCoord height)
+        { m_targetDc->DrawCheckMark(x, y, width, height); }
+    void DrawCheckMark(const wxRect& rect) { m_targetDc->DrawCheckMark(rect); }
+    void DrawCircle(wxCoord x, wxCoord y, wxCoord radius) { m_targetDc->DrawCircle(x, y, radius); }
+    void DrawCircle(const wxPoint& pt, wxCoord radius) { m_targetDc->DrawCircle(pt, radius); }
+    void DrawEllipse(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+        { m_targetDc->DrawEllipse(x, y, width, height); }
+    void DrawEllipse(const wxPoint& pt, const wxSize& sz) { m_targetDc->DrawEllipse(pt, sz); }
+    void DrawEllipse(const wxRect& rect) { m_targetDc->DrawEllipse(rect); }
+    void DrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
+                         double sa, double ea)
+        { m_targetDc->DrawEllipticArc(x, y, w, h,
+                                      sa, ea); }
+    void DrawEllipticArc(const wxPoint& pt, const wxSize& sz,
+                         double sa, double ea)
+        { m_targetDc->DrawEllipticArc(pt, sz, sa, ea); }
+#if defined(__WXWINCE__)
+    void DrawEllipticArcRot( wxCoord x, wxCoord y,
+                             wxCoord width, wxCoord height,
+                             double sa = 0, double ea = 0, double angle = 0 )
+        { m_targetDc->DrawEllipticArcRot(x, y, width, height,
+                                         sa, ea, angle); }
+    void DrawEllipticArcRot( const wxPoint& pt,
+                             const wxSize& sz,
+                             double sa = 0, double ea = 0, double angle = 0 )
+        { m_targetDc->DrawEllipticArcRot(pt, sz, sa, ea,
+                                         angle); }
+    void DrawEllipticArcRot( const wxRect& rect,
+                             double sa = 0, double ea = 0, double angle = 0 )
+        { m_targetDc->DrawEllipticArcRot(rect, sa, ea, angle); }
+#endif // defined(__WXWINCE__)
+    void DrawIcon(const wxIcon& icon, wxCoord x, wxCoord y) { m_targetDc->DrawIcon(icon, x, y); }
+    void DrawIcon(const wxIcon& icon, const wxPoint& pt) { m_targetDc->DrawIcon(icon, pt); }
+    virtual void DrawLabel(const wxString& text,
+                           const wxBitmap& image,
+                           const wxRect& rect,
+                           int alignment = wxALIGN_LEFT | wxALIGN_TOP,
+                           int indexAccel = -1,
+                           wxRect *rectBounding = NULL)
+        { m_targetDc->DrawLabel(text, image, rect, alignment,
+                                indexAccel, rectBounding); }
+    void DrawLabel(const wxString& text, const wxRect& rect,
+                   int alignment = wxALIGN_LEFT | wxALIGN_TOP,
+                   int indexAccel = -1)
+        { m_targetDc->DrawLabel(text, rect, alignment, indexAccel); }
+    void DrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
+        { m_targetDc->DrawLine(x1, y1, x2, y2); }
+    void DrawLine(const wxPoint& pt1, const wxPoint& pt2) { m_targetDc->DrawLine(pt1, pt2); }
+    void DrawLines(int n, wxPoint points[],
+                   wxCoord xoffset = 0, wxCoord yoffset = 0)
+        { m_targetDc->DrawLines(n, points, xoffset, yoffset); }
+    void DrawLines(const wxList *list,
+                   wxCoord xoffset = 0, wxCoord yoffset = 0)
+        { m_targetDc->DrawLines(list, xoffset, yoffset); }
+    virtual void DrawObject(wxDrawObject* drawobject) { m_targetDc->DrawObject(drawobject); }
+    void DrawPoint(wxCoord x, wxCoord y) { m_targetDc->DrawPoint(x, y); }
+    void DrawPoint(const wxPoint& pt) { m_targetDc->DrawPoint(pt); }
+    void DrawPolyPolygon(int n, int count[], wxPoint points[],
+                         wxCoord xoffset = 0, wxCoord yoffset = 0,
+                         int fillStyle = wxODDEVEN_RULE)
+        { m_targetDc->DrawPolyPolygon(n, count, points, xoffset,
+                                      yoffset, fillStyle); }
+    void DrawPolygon(int n, wxPoint points[],
+                     wxCoord xoffset = 0, wxCoord yoffset = 0,
+                     int fillStyle = wxODDEVEN_RULE)
+        { m_targetDc->DrawPolygon(n, points, xoffset, yoffset,
+                                  fillStyle); }
+    void DrawPolygon(const wxList *list,
+                     wxCoord xoffset = 0, wxCoord yoffset = 0,
+                     int fillStyle = wxODDEVEN_RULE)
+        { m_targetDc->DrawPolygon(list, xoffset, yoffset, fillStyle); }
+    void DrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+        { m_targetDc->DrawRectangle(x, y, width, height); }
+    void DrawRectangle(const wxPoint& pt, const wxSize& sz) { m_targetDc->DrawRectangle(pt, sz); }
+    void DrawRectangle(const wxRect& rect) { m_targetDc->DrawRectangle(rect); }
+    void DrawRotatedText(const wxString& text, wxCoord x, wxCoord y, double angle)
+        { m_targetDc->DrawRotatedText(text, x, y, angle); }
+    void DrawRotatedText(const wxString& text, const wxPoint& pt, double angle)
+        { m_targetDc->DrawRotatedText(text, pt, angle); }
+    void DrawRoundedRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height,
+                              double radius)
+        { m_targetDc->DrawRoundedRectangle(x, y, width, height,
+                                           radius); }
+    void DrawRoundedRectangle(const wxPoint& pt, const wxSize& sz,
+                             double radius)
+        { m_targetDc->DrawRoundedRectangle(pt, sz, radius); }
+    void DrawRoundedRectangle(const wxRect& r, double radius)
+        { m_targetDc->DrawRoundedRectangle(r, radius); }
+#if wxUSE_SPLINES
+    void DrawSpline(wxCoord x1, wxCoord y1,
+                    wxCoord x2, wxCoord y2,
+                    wxCoord x3, wxCoord y3)
+        { m_targetDc->DrawSpline(x1, y1, x2, y2,
+                                 x3, y3); }
+    void DrawSpline(int n, wxPoint points[]) { m_targetDc->DrawSpline(n, points); }
+    void DrawSpline(wxList *points) { m_targetDc->DrawSpline(points); }
+#endif // wxUSE_SPLINES
+    void DrawText(const wxString& text, wxCoord x, wxCoord y)
+        { m_targetDc->DrawText(text, x, y); }
+    void DrawText(const wxString& text, const wxPoint& pt) { m_targetDc->DrawText(text, pt); }
+    virtual void EndDoc() { m_targetDc->EndDoc(); }
+    virtual void EndPage() { m_targetDc->EndPage(); }
+    bool FloodFill(wxCoord x, wxCoord y, const wxColour& col,
+                   int style = wxFLOOD_SURFACE)
+        { return m_targetDc->FloodFill(x, y, col, style); }
+    bool FloodFill(const wxPoint& pt, const wxColour& col,
+                   int style = wxFLOOD_SURFACE)
+        { return m_targetDc->FloodFill(pt, col, style); }
+    virtual const wxBrush&  GetBackground() const { return m_targetDc->GetBackground(); }
+    virtual int GetBackgroundMode() const { return m_targetDc->GetBackgroundMode(); }
+    virtual const wxBrush&  GetBrush() const { return m_targetDc->GetBrush(); }
+    virtual wxCoord GetCharHeight() const { return m_targetDc->GetCharHeight(); }
+    virtual wxCoord GetCharWidth() const { return m_targetDc->GetCharWidth(); }
+    void GetClippingBox(wxCoord *x, wxCoord *y, wxCoord *w, wxCoord *h) const
+        { m_targetDc->GetClippingBox(x, y, w, h); }
+    void GetClippingBox(wxRect& rect) const { m_targetDc->GetClippingBox(rect); }
+    void GetClippingBox(long *x, long *y, long *w, long *h) const
+        { m_targetDc->GetClippingBox(x, y, w, h); }
+    virtual int GetDepth() const { return m_targetDc->GetDepth(); }
+    void GetDeviceOrigin(wxCoord *x, wxCoord *y) const { m_targetDc->GetDeviceOrigin(x, y); }
+    wxPoint GetDeviceOrigin() const { return m_targetDc->GetDeviceOrigin(); }
+    void GetDeviceOrigin(long *x, long *y) const { m_targetDc->GetDeviceOrigin(x, y); }
+    virtual const wxFont&   GetFont() const { return m_targetDc->GetFont(); }
+    virtual int GetLogicalFunction() const { return m_targetDc->GetLogicalFunction(); }
+    void GetLogicalOrigin(wxCoord *x, wxCoord *y) const { m_targetDc->GetLogicalOrigin(x, y); }
+    wxPoint GetLogicalOrigin() const { return m_targetDc->GetLogicalOrigin(); }
+    void GetLogicalOrigin(long *x, long *y) const { m_targetDc->GetLogicalOrigin(x, y); }
+    virtual void GetLogicalScale(double *x, double *y) { m_targetDc->GetLogicalScale(x, y); }
+    virtual int GetMapMode() const { return m_targetDc->GetMapMode(); }
+    virtual void GetMultiLineTextExtent(const wxString& text,
+                                        wxCoord *width,
+                                        wxCoord *height,
+                                        wxCoord *heightLine = NULL,
+                                        wxFont *font = NULL)
+        { m_targetDc->GetMultiLineTextExtent(text, width, height, heightLine,
+                                             font); }
+#if WXWIN_COMPATIBILITY_2_4
+    virtual bool GetOptimization() { return m_targetDc->GetOptimization(); }
+#endif // WXWIN_COMPATIBILITY_2_4
+    virtual wxSize GetPPI() const { return m_targetDc->GetPPI(); }
+    bool GetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
+        { return m_targetDc->GetPartialTextExtents(text, widths); }
+    virtual const wxPen&    GetPen() const { return m_targetDc->GetPen(); }
+    bool GetPixel(wxCoord x, wxCoord y, wxColour *col) const
+        { return m_targetDc->GetPixel(x, y, col); }
+    bool GetPixel(const wxPoint& pt, wxColour *col) const { return m_targetDc->GetPixel(pt, col); }
+    void GetSize(int *width, int *height) const { m_targetDc->GetSize(width, height); }
+    wxSize GetSize() const { return m_targetDc->GetSize(); }
+    void GetSizeMM(int* width, int* height) const { m_targetDc->GetSizeMM(width, height); }
+    wxSize GetSizeMM() const { return m_targetDc->GetSizeMM(); }
+    virtual const wxColour& GetTextBackground() const { return m_targetDc->GetTextBackground(); }
+    void GetTextExtent(const wxString& string,
+                       wxCoord *x, wxCoord *y,
+                       wxCoord *descent = NULL,
+                       wxCoord *externalLeading = NULL,
+                       wxFont *theFont = NULL) const
+        { m_targetDc->GetTextExtent(string, x, y, descent,
+                                    externalLeading, theFont); }
+    void GetTextExtent(const wxString& string,
+                       long *x, long *y,
+                       long *descent = NULL,
+                       long *externalLeading = NULL,
+                       wxFont *theFont = NULL) const
+        { m_targetDc->GetTextExtent(string, x, y, descent,
+                                    externalLeading, theFont); }
+    virtual const wxColour& GetTextForeground() const { return m_targetDc->GetTextForeground(); }
+    virtual void GetUserScale(double *x, double *y) const { m_targetDc->GetUserScale(x, y); }
+    void GradientFillConcentric(const wxRect& rect,
+                                const wxColour& initialColour,
+                                const wxColour& destColour)
+        { m_targetDc->GradientFillConcentric(rect, initialColour, destColour); }
+    void GradientFillConcentric(const wxRect& rect,
+                                const wxColour& initialColour,
+                                const wxColour& destColour,
+                                const wxPoint& circleCenter)
+        { m_targetDc->GradientFillConcentric(rect, initialColour, destColour, circleCenter); }
+    void GradientFillLinear(const wxRect& rect,
+                            const wxColour& initialColour,
+                            const wxColour& destColour,
+                            wxDirection nDirection = wxEAST)
+        { m_targetDc->GradientFillLinear(rect, initialColour, destColour, nDirection); }
+    wxCoord LogicalToDeviceX(wxCoord x) const { return m_targetDc->LogicalToDeviceX(x); }
+    wxCoord LogicalToDeviceXRel(wxCoord x) const { return m_targetDc->LogicalToDeviceXRel(x); }
+    wxCoord LogicalToDeviceY(wxCoord y) const { return m_targetDc->LogicalToDeviceY(y); }
+    wxCoord LogicalToDeviceYRel(wxCoord y) const { return m_targetDc->LogicalToDeviceYRel(y); }
+    wxCoord MaxX() const { return m_targetDc->MaxX(); }
+    wxCoord MaxY() const { return m_targetDc->MaxY(); }
+    wxCoord MinX() const { return m_targetDc->MinX(); }
+    wxCoord MinY() const { return m_targetDc->MinY(); }
+    virtual bool Ok() const { return m_targetDc->Ok(); }
+    void ResetBoundingBox()
+        { m_targetDc->ResetBoundingBox(); }
+#if defined(__WXWINCE__)
+    void Rotate( wxList* points, double angle, wxPoint center = wxPoint(0,0) )
+        { m_targetDc->Rotate(points, angle, center); }
+#endif // defined(__WXWINCE__)
+    virtual void SetAxisOrientation(bool xLeftRight, bool yBottomUp)
+        { m_targetDc->SetAxisOrientation(xLeftRight, yBottomUp); }
+    virtual void SetBackground(const wxBrush& brush) { m_targetDc->SetBackground(brush); }
+    virtual void SetBackgroundMode(int mode) { m_targetDc->SetBackgroundMode(mode); }
+    virtual void SetBrush(const wxBrush& brush) { m_targetDc->SetBrush(brush); }
+    void SetClippingRegion(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+        { m_targetDc->SetClippingRegion(x, y, width, height); }
+    void SetClippingRegion(const wxPoint& pt, const wxSize& sz)
+        { m_targetDc->SetClippingRegion(pt, sz); }
+    void SetClippingRegion(const wxRect& rect) { m_targetDc->SetClippingRegion(rect); }
+    void SetClippingRegion(const wxRegion& region) { m_targetDc->SetClippingRegion(region); }
+    virtual void SetDeviceOrigin(wxCoord x, wxCoord y) { m_targetDc->SetDeviceOrigin(x, y); }
+    virtual void SetFont(const wxFont& font) { m_targetDc->SetFont(font); }
+    virtual void SetLogicalFunction(int function) { m_targetDc->SetLogicalFunction(function); }
+    virtual void SetLogicalOrigin(wxCoord x, wxCoord y) { m_targetDc->SetLogicalOrigin(x, y); }
+    virtual void SetLogicalScale(double x, double y) { m_targetDc->SetLogicalScale(x, y); }
+    virtual void SetMapMode(int mode) { m_targetDc->SetMapMode(mode); }
+#if WXWIN_COMPATIBILITY_2_4
+    virtual void SetOptimization(bool opt) { m_targetDc->SetOptimization(opt); }
+#endif // WXWIN_COMPATIBILITY_2_4
+#if wxUSE_PALETTE
+    virtual void SetPalette(const wxPalette& palette) { m_targetDc->SetPalette(palette); }
+#endif // wxUSE_PALETTE
+    virtual void SetPen(const wxPen& pen) { m_targetDc->SetPen(pen); }
+    virtual void SetTextBackground(const wxColour& colour) { m_targetDc->SetTextBackground(colour); }
+    virtual void SetTextForeground(const wxColour& colour) { m_targetDc->SetTextForeground(colour); }
+    virtual void SetUserScale(double x, double y) { m_targetDc->SetUserScale(x, y); }
+    virtual bool StartDoc(const wxString& message) { return m_targetDc->StartDoc(message); }
+    virtual void StartPage() { m_targetDc->StartPage(); }
+protected:
+    virtual bool DoBlit(wxCoord xdest, wxCoord ydest,
+                        wxCoord width, wxCoord height,
+                        wxDC *source, wxCoord xsrc, wxCoord ysrc,
+                        int rop = wxCOPY, bool useMask = false, wxCoord xsrcMask = wxDefaultCoord, wxCoord ysrcMask = wxDefaultCoord)
+        { return m_targetDc->Blit(xdest, ydest, width, height,
+                                  source, xsrc, ysrc, rop,
+                                  useMask, xsrcMask, ysrcMask); }
+    virtual void DoCrossHair(wxCoord x, wxCoord y) { m_targetDc->CrossHair(x, y); }
+    virtual void DoDrawArc(wxCoord x1, wxCoord y1,
+                           wxCoord x2, wxCoord y2,
+                           wxCoord xc, wxCoord yc)
+        { m_targetDc->DrawArc(x1, y1, x2, y2,
+                              xc, yc); }
+    virtual void DoDrawBitmap(const wxBitmap &bmp, wxCoord x, wxCoord y,
+                              bool useMask = false)
+        { m_targetDc->DrawBitmap(bmp, x, y, useMask); }
+    virtual void DoDrawCheckMark(wxCoord x, wxCoord y,
+                                 wxCoord width, wxCoord height)
+        { m_targetDc->DrawCheckMark(x, y, width, height); }
+    virtual void DoDrawEllipse(wxCoord x, wxCoord y,
+                               wxCoord width, wxCoord height)
+        { m_targetDc->DrawEllipse(x, y, width, height); }
+    virtual void DoDrawEllipticArc(wxCoord x, wxCoord y, wxCoord w, wxCoord h,
+                                   double sa, double ea)
+        { m_targetDc->DrawEllipticArc(x, y, w, h,
+                                      sa, ea); }
+    virtual void DoDrawIcon(const wxIcon& icon, wxCoord x, wxCoord y)
+        { m_targetDc->DrawIcon(icon, x, y); }
+    virtual void DoDrawLine(wxCoord x1, wxCoord y1, wxCoord x2, wxCoord y2)
+        { m_targetDc->DrawLine(x1, y1, x2, y2); }
+    virtual void DoDrawLines(int n, wxPoint points[],
+                             wxCoord xoffset, wxCoord yoffset)
+        { m_targetDc->DrawLines(n, points, xoffset, yoffset); }
+    virtual void DoDrawPoint(wxCoord x, wxCoord y) { m_targetDc->DrawPoint(x, y); }
+    virtual void DoDrawPolyPolygon(int n, int count[], wxPoint points[],
+                               wxCoord xoffset, wxCoord yoffset,
+                               int fillStyle)
+        { m_targetDc->DrawPolyPolygon(n, count, points, xoffset,
+                                      yoffset, fillStyle); }
+    virtual void DoDrawPolygon(int n, wxPoint points[],
+                               wxCoord xoffset, wxCoord yoffset,
+                               int fillStyle = wxODDEVEN_RULE)
+        { m_targetDc->DrawPolygon(n, points, xoffset, yoffset,
+                                  fillStyle); }
+    virtual void DoDrawRectangle(wxCoord x, wxCoord y, wxCoord width, wxCoord height)
+        { m_targetDc->DrawRectangle(x, y, width, height); }
+    virtual void DoDrawRotatedText(const wxString& text,
+                                   wxCoord x, wxCoord y, double angle)
+        { m_targetDc->DrawRotatedText(text, x, y, angle); }
+    virtual void DoDrawRoundedRectangle(wxCoord x, wxCoord y,
+                                        wxCoord width, wxCoord height,
+                                        double radius)
+        { m_targetDc->DrawRoundedRectangle(x, y, width, height,
+                                           radius); }
+#if wxUSE_SPLINES
+    virtual void DoDrawSpline(wxList *points) { m_targetDc->DrawSpline(points); }
+#endif // wxUSE_SPLINES
+    virtual void DoDrawText(const wxString& text, wxCoord x, wxCoord y)
+        { m_targetDc->DrawText(text, x, y); }
+    virtual bool DoFloodFill(wxCoord x, wxCoord y, const wxColour& col,
+                             int style = wxFLOOD_SURFACE)
+        { return m_targetDc->FloodFill(x, y, col, style); }
+    virtual void DoGetClippingBox(wxCoord *x, wxCoord *y,
+                                  wxCoord *w, wxCoord *h) const
+        { m_targetDc->GetClippingBox(x, y, w, h); }
+    virtual void DoGetDeviceOrigin(wxCoord *x, wxCoord *y) const
+        { m_targetDc->GetDeviceOrigin(x, y); }
+    virtual void DoGetLogicalOrigin(wxCoord *x, wxCoord *y) const
+        { m_targetDc->GetLogicalOrigin(x, y); }
+    virtual bool DoGetPartialTextExtents(const wxString& text, wxArrayInt& widths) const
+        { return m_targetDc->GetPartialTextExtents(text, widths); }
+    virtual bool DoGetPixel(wxCoord x, wxCoord y, wxColour *col) const
+        { return m_targetDc->GetPixel(x, y, col); }
+    virtual void DoGetSize(int *width, int *height) const { m_targetDc->GetSize(width, height); }
+    virtual void DoGetSizeMM(int* width, int* height) const { m_targetDc->GetSizeMM(width, height); }
+    virtual void DoGetTextExtent(const wxString& string,
+                                 wxCoord *x, wxCoord *y,
+                                 wxCoord *descent = NULL,
+                                 wxCoord *externalLeading = NULL,
+                                 wxFont *theFont = NULL) const
+        { m_targetDc->GetTextExtent(string, x, y, descent,
+                                    externalLeading, theFont); }
+    virtual void DoGradientFillLinear(const wxRect& rect,
+                                      const wxColour& initialColour,
+                                      const wxColour& destColour,
+                                      wxDirection nDirection = wxEAST)
+        { m_targetDc->GradientFillLinear(rect, initialColour, destColour, nDirection); }
+    virtual void DoSetClippingRegion(wxCoord x, wxCoord y,
+                                     wxCoord width, wxCoord height)
+        { m_targetDc->SetClippingRegion(x, y, width, height); }
+    virtual void DoSetClippingRegionAsRegion(const wxRegion& region)
+        { m_targetDc->SetClippingRegion(region); }
 };


@@ -154,7 +606,7 @@ private:

 // Creates a double buffered wxPaintDC, optionally allowing the
 // user to specify their own buffer to use.
-class WXDLLEXPORT wxBufferedPaintDC : public wxBufferedDC
+class wxBufferedPaintDC : public wxBufferedDC
 {
 public:
    // If no bitmap is supplied by the user, a temporary one will be created.
@@ -168,7 +620,7 @@ public:
        if( buffer != wxNullBitmap )
            Init(&m_paintdc, buffer, style);
        else
-            Init(&m_paintdc, window->GetClientSize(), style);
+            Init(window, &m_paintdc, window->GetClientSize(), style);
    }

    // If no bitmap is supplied by the user, a temporary one will be created.
@@ -179,7 +631,7 @@ public:
        if (style & wxBUFFER_VIRTUAL_AREA)
            window->PrepareDC( m_paintdc );

-        Init(&m_paintdc, window->GetClientSize(), style);
+        Init(window, &m_paintdc, window->GetClientSize(), style);
    }

    // default copy ctor ok.
@@ -194,7 +646,6 @@ public:
 private:
    wxPaintDC m_paintdc;

-    DECLARE_ABSTRACT_CLASS(wxBufferedPaintDC)
    DECLARE_NO_COPY_CLASS(wxBufferedPaintDC)
 };

@@ -233,7 +684,7 @@ private:
    {
        // Help the user to get the double-buffering working properly.
        wxASSERT_MSG( win->GetBackgroundStyle() == wxBG_STYLE_CUSTOM,
-                      wxT("In constructor, you need to call SetBackgroundStyle(wxBG_STYLE_CUSTOM), ")
+                      wxT("In constructor, you need to call GetBackgroundStyle(wxBG_STYLE_CUSTOM), ")
                      wxT("and also, if needed, paint the background manually in the paint event handler."));
    }

@@ -248,16 +699,4 @@ typedef wxAutoBufferedPaintDCBase wxAutoBufferedPaintDC;
 #endif


-// Check if the window is natively double buffered and will return a wxPaintDC
-// if it is, a wxBufferedPaintDC otherwise.  It is the caller's responsibility
-// to delete the wxDC pointer when finished with it.
-inline wxDC* wxAutoBufferedPaintDCFactory(wxWindow* window)
-{
-    if ( window->IsDoubleBuffered() )
-        return new wxPaintDC(window);
-    else
-        return new wxBufferedPaintDC(window);
-}
-            
-
 #endif  // _WX_DCBUFFER_H_
--- a/include/wx/dfb/dcmemory.h
+++ b/include/wx/dfb/dcmemory.h
@@ -17,7 +17,7 @@
 class WXDLLIMPEXP_CORE wxMemoryDC : public wxDC
 {
 public:
-    wxMemoryDC( const wxBitmap& bitmap = wxNullBitmap );
+    wxMemoryDC();
    wxMemoryDC(wxDC *dc); // create compatible DC

    virtual void SelectObject(const wxBitmap& bitmap);
--- a/include/wx/generic/bmpcbox.h
+++ b/include/wx/generic/bmpcbox.h
@@ -4,7 +4,7 @@
 // Author:      Jaakko Salli
 // Modified by:
 // Created:     Aug-30-2006
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) Jaakko Salli
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
--- a/include/wx/generic/grid.h
+++ b/include/wx/generic/grid.h
@@ -28,7 +28,7 @@ extern WXDLLIMPEXP_DATA_ADV(const wxChar) wxGridNameStr[];
 //
 #define WXGRID_DEFAULT_NUMBER_ROWS            10
 #define WXGRID_DEFAULT_NUMBER_COLS            10
-#if defined(__WXMSW__) || defined(__WXGTK20__)
+#ifdef __WXMSW__
 #define WXGRID_DEFAULT_ROW_HEIGHT             25
 #else
 #define WXGRID_DEFAULT_ROW_HEIGHT             30
--- a/include/wx/gtk/bitmap.h
+++ b/include/wx/gtk/bitmap.h
@@ -122,9 +122,6 @@ private:
    bool CreateFromImageAsPixmap(const wxImage& image, int depth);
    bool CreateFromImageAsPixbuf(const wxImage& image);

-    virtual wxObjectRefData* CreateRefData() const;
-    virtual wxObjectRefData* CloneRefData(const wxObjectRefData* data) const;
-
    enum Representation
    {
        Pixmap,
--- a/include/wx/gtk/dcclient.h
+++ b/include/wx/gtk/dcclient.h
@@ -99,6 +99,8 @@ public:
    virtual void SetDeviceOrigin( wxCoord x, wxCoord y );
    virtual void SetAxisOrientation( bool xLeftRight, bool yBottomUp );

+    virtual GdkWindow* GetGDKWindow() const { return m_window; }
+
 // protected:
    // implementation
    // --------------
@@ -126,7 +128,7 @@ public:
 protected:
    virtual void ComputeScaleAndOrigin();

-    virtual GdkWindow *GetGDKWindow() const { return m_window; }
+    GdkWindow *GetWindow() { return m_window; }

 private:
    DECLARE_DYNAMIC_CLASS(wxWindowDC)
--- a/include/wx/gtk/dcmemory.h
+++ b/include/wx/gtk/dcmemory.h
@@ -26,7 +26,7 @@ class WXDLLIMPEXP_CORE wxMemoryDC;
 class WXDLLIMPEXP_CORE wxMemoryDC : public wxWindowDC
 {
 public:
-    wxMemoryDC( const wxBitmap& bitmap = wxNullBitmap );
+    wxMemoryDC();
    wxMemoryDC( wxDC *dc ); // Create compatible DC
    virtual ~wxMemoryDC();
    virtual void SelectObject( const wxBitmap& bitmap );
--- a/include/wx/gtk/font.h
+++ b/include/wx/gtk/font.h
@@ -84,9 +84,6 @@ protected:
    // common part of all ctors
    void Init();

-    virtual wxObjectRefData* CreateRefData() const;
-    virtual wxObjectRefData* CloneRefData(const wxObjectRefData* data) const;
-
 private:
    DECLARE_DYNAMIC_CLASS(wxFont)
 };
--- a/include/wx/gtk/gauge.h
+++ b/include/wx/gtk/gauge.h
@@ -1,10 +1,10 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/gtk/gauge.h
+// Name:        gauge.h
 // Purpose:
 // Author:      Robert Roebling
 // Id:          $Id$
 // Copyright:   (c) 1998 Robert Roebling
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_GTK_GAUGE_H_
@@ -57,12 +57,12 @@ public:
    virtual void Pulse();

    bool IsVertical() const { return HasFlag(wxGA_VERTICAL); }
-
+    
    static wxVisualAttributes
    GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);

    virtual wxVisualAttributes GetDefaultAttributes() const;
-
+    
    // implementation
    // -------------

@@ -83,5 +83,4 @@ private:
    DECLARE_DYNAMIC_CLASS(wxGauge)
 };

-#endif
-    // _WX_GTK_GAUGE_H_
+#endif // _WX_GTK_GAUGE_H_
--- a/include/wx/gtk/menu.h
+++ b/include/wx/gtk/menu.h
@@ -75,7 +75,7 @@ public:
    virtual ~wxMenu();

    void Attach(wxMenuBarBase *menubar);
-
+    
    void SetLayoutDirection(const wxLayoutDirection dir);
    wxLayoutDirection GetLayoutDirection() const;

@@ -101,10 +101,9 @@ private:
    // common part of Append (if pos == -1)  and Insert
    bool GtkAppend(wxMenuItem *item, int pos=-1);

-    GtkWidget *m_prevRadio;
+	GtkWidget *m_prevRadio;

    DECLARE_DYNAMIC_CLASS(wxMenu)
 };

-#endif
-    // __GTKMENUH__
+#endif // __GTKMENUH__
--- a/include/wx/gtk/stattext.h
+++ b/include/wx/gtk/stattext.h
@@ -1,10 +1,10 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/gtk/stattext.h
+// Name:        stattext.h
 // Purpose:
 // Author:      Robert Roebling
 // Id:          $Id$
 // Copyright:   (c) 1998 Robert Roebling
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_GTK_STATTEXT_H_
@@ -22,7 +22,7 @@ public:
                 wxWindowID id,
                 const wxString &label,
                 const wxPoint &pos = wxDefaultPosition,
-                 const wxSize &size = wxDefaultSize,
+                 const wxSize &size = wxDefaultSize, 
                 long style = 0,
                 const wxString &name = wxStaticTextNameStr );

@@ -30,7 +30,7 @@ public:
                wxWindowID id,
                const wxString &label,
                const wxPoint &pos = wxDefaultPosition,
-                const wxSize &size = wxDefaultSize,
+                const wxSize &size = wxDefaultSize, 
                long style = 0,
                const wxString &name = wxStaticTextNameStr );

@@ -42,7 +42,7 @@ public:

    static wxVisualAttributes
    GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);
-
+    
    // see wx/stattext.h
    void Wrap(int width);

@@ -56,11 +56,10 @@ protected:
    virtual void DoSetSize(int x, int y,
                           int width, int height,
                           int sizeFlags = wxSIZE_AUTO);
-
+                           
    virtual wxSize DoGetBestSize() const;

    DECLARE_DYNAMIC_CLASS(wxStaticText)
 };

-#endif
-    // _WX_GTK_STATTEXT_H_
+#endif // _WX_GTK_STATTEXT_H_
--- a/include/wx/gtk/textctrl.h
+++ b/include/wx/gtk/textctrl.h
@@ -174,9 +174,6 @@ public:
    static wxVisualAttributes
    GetClassDefaultAttributes(wxWindowVariant variant = wxWINDOW_VARIANT_NORMAL);

-    // has the control been frozen by Freeze()?
-    bool IsFrozen() const { return m_frozenness > 0; }
-
 protected:
    virtual wxSize DoGetBestSize() const;
    virtual void DoApplyWidgetStyle(GtkRcStyle *style);
@@ -189,6 +186,9 @@ protected:
    // override this and return true.
    virtual bool UseGTKStyleBase() const { return true; }

+    // has the control been frozen by Freeze()?
+    bool IsFrozen() const { return m_frozenness > 0; }
+
    virtual void DoSetValue(const wxString &value, int flags = 0);

 private:
--- a/include/wx/gtk/win_gtk.h
+++ b/include/wx/gtk/win_gtk.h
@@ -22,6 +22,15 @@ extern "C" {
 #define GTK_PIZZA(obj)          GTK_CHECK_CAST (obj, gtk_pizza_get_type (), GtkPizza)
 #define GTK_IS_PIZZA(obj)       GTK_CHECK_TYPE (obj, gtk_pizza_get_type ())

+/* Shadow types */
+typedef enum
+{
+    GTK_MYSHADOW_NONE,
+    GTK_MYSHADOW_THIN,
+    GTK_MYSHADOW_IN,
+    GTK_MYSHADOW_OUT
+} GtkMyShadowType;
+
 typedef struct _GtkPizzaChild    GtkPizzaChild;
 typedef struct _GtkPizza        GtkPizza;
 typedef struct _GtkPizzaClass   GtkPizzaClass;
@@ -39,10 +48,13 @@ struct _GtkPizza
 {
    GtkContainer container;
    GList *children;
+    GtkMyShadowType shadow_type;

    guint m_xoffset;
    guint m_yoffset;
    
+    gint  m_width;
+
    GdkWindow *bin_window;
 };

@@ -75,6 +87,9 @@ void       gtk_pizza_set_yoffset     (GtkPizza          *pizza, gint yoffset);
 WXDLLIMPEXP_CORE
 gint       gtk_pizza_get_rtl_offset  (GtkPizza          *pizza); 

+WXDLLIMPEXP_CORE
+void       gtk_pizza_set_shadow_type (GtkPizza          *pizza,
+                                      GtkMyShadowType    type);

 WXDLLIMPEXP_CORE
 void       gtk_pizza_scroll          (GtkPizza          *pizza,
--- a/include/wx/gtk1/dcmemory.h
+++ b/include/wx/gtk1/dcmemory.h
@@ -26,7 +26,7 @@ class WXDLLIMPEXP_CORE wxMemoryDC;
 class WXDLLIMPEXP_CORE wxMemoryDC : public wxWindowDC
 {
 public:
-    wxMemoryDC( const wxBitmap& bitmap = wxNullBitmap );
+    wxMemoryDC();
    wxMemoryDC( wxDC *dc ); // Create compatible DC
    virtual ~wxMemoryDC();
    virtual void SelectObject( const wxBitmap& bitmap );
--- a/include/wx/gtk1/gauge.h
+++ b/include/wx/gtk1/gauge.h
@@ -4,7 +4,7 @@
 // Author:      Robert Roebling
 // Id:          $Id$
 // Copyright:   (c) 1998 Robert Roebling
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __GTKGAUGEH__
@@ -99,5 +99,4 @@ private:

 #endif

-#endif
-    // __GTKGAUGEH__
+#endif // __GTKGAUGEH__
--- a/include/wx/gtk1/menu.h
+++ b/include/wx/gtk1/menu.h
@@ -92,10 +92,9 @@ private:
    // common part of Append (if pos == -1)  and Insert
    bool GtkAppend(wxMenuItem *item, int pos=-1);

-    GtkWidget *m_prevRadio;
+	GtkWidget *m_prevRadio;

    DECLARE_DYNAMIC_CLASS(wxMenu)
 };

-#endif
-    // __GTKMENUH__
+#endif // __GTKMENUH__
--- a/include/wx/gtk1/stattext.h
+++ b/include/wx/gtk1/stattext.h
@@ -4,7 +4,7 @@
 // Author:      Robert Roebling
 // Id:          $Id$
 // Copyright:   (c) 1998 Robert Roebling
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __GTKSTATICTEXTH__
@@ -74,5 +74,4 @@ protected:
    DECLARE_DYNAMIC_CLASS(wxStaticText)
 };

-#endif
-    // __GTKSTATICTEXTH__
+#endif // __GTKSTATICTEXTH__
--- a/include/wx/html/webkit.h
+++ b/include/wx/html/webkit.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/html/webkit.h
+// Name:        webkit.h
 // Purpose:     wxWebKitCtrl - embeddable web kit control
 // Author:      Jethro Grassie / Kevin Ollivier
 // Modified by:
@@ -63,8 +63,8 @@ public:
    bool CanGetPageSource();
    wxString GetPageSource();
    void SetPageSource(wxString& source, const wxString& baseUrl = wxEmptyString);
-    wxString GetPageURL(){ return m_currentURL; }
-    wxString GetPageTitle(){ return m_pageTitle; }
+	wxString GetPageURL(){ return m_currentURL; }
+	wxString GetPageTitle(){ return m_pageTitle; }

    //we need to resize the webview when the control size changes
    void OnSize(wxSizeEvent &event);
@@ -129,5 +129,4 @@ END_DECLARE_EVENT_TYPES()

 #endif // wxUSE_WEBKIT

-#endif
-    // _WX_WEBKIT_H_
+#endif // _WX_WEBKIT_H_
--- a/include/wx/mac/carbon/config_xcode.h
+++ b/include/wx/mac/carbon/config_xcode.h
@@ -12,133 +12,90 @@
 // from config.log confdefs

 #define HAVE_SSIZE_T 1
+#define HAVE_BOOL 1
+#define HAVE_CONST_CAST
+#define HAVE_COS 1
+#define HAVE_EXPLICIT 1
+#define HAVE_FCNTL 1
+#define HAVE_FLOOR 1
+#define HAVE_FNMATCH 1
+#define HAVE_FNMATCH_H 1
+#define HAVE_GETTIMEOFDAY 1
+#define HAVE_ICONV 1
+#define HAVE_INET_ADDR 1
+#define HAVE_INET_ADDR 1
+#define HAVE_INET_ATON 1
+#define HAVE_INET_ATON 1
+#define HAVE_INTTYPES_H 1
+#define HAVE_IOSTREAM 1
+#define HAVE_LANGINFO_H 1
+#define HAVE_LARGEFILE_SUPPORT 1
+#define HAVE_LOCALTIME 1
+#define HAVE_MEMORY_H 1
+#define HAVE_MKSTEMP 1
+#define HAVE_PTHREAD_CANCEL 1
+#define HAVE_PTHREAD_MUTEXATTR_T 1
+#define HAVE_PUTENV 1
+#define HAVE_PW_GECOS 1
+#define HAVE_REGCOMP 1
+#define HAVE_SCHED_H 1
+#define HAVE_SCHED_YIELD 1
+#define HAVE_SIGACTION 1
+#define HAVE_STATFS 1
+#define HAVE_STATIC_CAST
+#define HAVE_STDINT_H 1
+#define HAVE_STDLIB_H 1
+#define HAVE_STDLIB_H 1
+#define HAVE_STRCASECMP_IN_STRING_H 1
+#define HAVE_STRINGS_H 1
+#define HAVE_STRING_H 1
+#define HAVE_STRPTIME 1
+#define HAVE_STRTOK_R 1
+#define HAVE_SYS_STAT_H 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_THREAD_PRIORITY_FUNCTIONS 1
+#define HAVE_TIMEGM 1
+#define HAVE_UNAME 1
+#define HAVE_UNISTD_H 1
+#define HAVE_UNISTD_H 1
+#define HAVE_USLEEP 1
+#define HAVE_VSNPRINTF 1
+#define HAVE_VSNPRINTF_DECL 1
+#define HAVE_WCHAR_H 1
+#define HAVE_WCSLEN 1
+#define HAVE_WPRINTF 1
+#define HAVE_WCSRTOMBS 1
+#define HAVE_X11_XKBLIB_H 1
+#define HAVE_X11_XLIB_H 1
+#define ICONV_CONST const
+#define PACKAGE_BUGREPORT "wx-dev@lists.wxwidgets.org"
+#define PACKAGE_NAME "wxWidgets"
+#define PACKAGE_STRING "wxWidgets 2.5.1"
+#define PACKAGE_TARNAME "wxwidgets"
+#define PACKAGE_VERSION "2.5.1"
+#define SIZEOF_CHAR 1
+#define SIZEOF_INT 4
+#define SIZEOF_LONG 4
+#define SIZEOF_LONG_LONG 8
+#define SIZEOF_SHORT 2
+#define SIZEOF_SIZE_T 4
+#define SIZEOF_VOID_P 4
+#define SIZEOF_WCHAR_T 4
+#define SOCKLEN_T socklen_t
 #define STDC_HEADERS 1
+#define TARGET_CARBON 1
 #if __BIG_ENDIAN__
 #define WORDS_BIGENDIAN 1
 #endif
-#define wxUSE_UNIX 1
-#define __UNIX__ 1
+#define WXWIN_OS_DESCRIPTION "Darwin 7.3.0 Power Macintosh"
+#define WX_GMTOFF_IN_TM 1
+#define WX_NO_REGEX_ADVANCED 1
+#define WX_STATFS_T struct statfs
+#define WX_TIMEZONE timezone
+#define _FILE_OFFSET_BITS 64
 #define __BSD__ 1
 #define __DARWIN__ 1
-#define wx_USE_NANOX 0
-#define TARGET_CARBON 1
-
-#define HAVE_BOOL 1
-#define HAVE_EXPLICIT 1
-#define HAVE_CONST_CAST 
-#define HAVE_REINTERPRET_CAST 
-#define HAVE_STATIC_CAST 
-#define HAVE_VA_COPY 1
-#define HAVE_VARIADIC_MACROS 1
-#define CONST_COMPATIBILITY 0
-#define WX_TIMEZONE timezone
-#define WX_SOCKLEN_T socklen_t
-#define SOCKOPTLEN_T socklen_t
-#define WX_STATFS_T struct statfs
-#define wxTYPE_SA_HANDLER int
-#define WX_GMTOFF_IN_TM 1
-#define HAVE_PW_GECOS 1
-#define HAVE_GETTIMEOFDAY 1
-#define HAVE_FSYNC 1
-#define HAVE_LARGEFILE_SUPPORT 1
-#define HAVE_LOCALTIME 1
-#define HAVE_SCHED_YIELD 1
-#define HAVE_PTHREAD_MUTEXATTR_T 1
-#define HAVE_PTHREAD_MUTEXATTR_SETTYPE_DECL 1
-#define HAVE_PTHREAD_CANCEL 1
-#define HAVE_PTHREAD_ATTR_SETSTACKSIZE 1
-#define HAVE_SIGACTION 1
-#define HAVE_SNPRINTF 1
-#define HAVE_SNPRINTF_DECL 1
-#define HAVE_UNIX98_PRINTF 1
-#define HAVE_STATFS 1
-#define HAVE_STATFS_DECL 1
-#define HAVE_STRPTIME 1
-#define HAVE_STRPTIME_DECL 1
-#define HAVE_THREAD_PRIORITY_FUNCTIONS 1
-#define HAVE_TIMEGM 1
-#define HAVE_VSNPRINTF 1
-#define HAVE_VSNPRINTF_DECL 1
-#define HAVE_USLEEP 1
-#define HAVE_WCSLEN 1
-#define SIZEOF_CHAR 1
-#define SIZEOF_WCHAR_T 4
-#define SIZEOF_SHORT 2
-#define SIZEOF_INT 4
-#ifdef __LP64__
-#define SIZEOF_VOID_P 8
-#define SIZEOF_LONG 8
-#define SIZEOF_SIZE_T 8
-#else
-#define SIZEOF_VOID_P 4
-#define SIZEOF_LONG 4
-#define SIZEOF_SIZE_T 4
-#endif
-
-#define SIZEOF_LONG_LONG 8
+#define __POWERPC__ 1
+#define __UNIX__ 1
 #define wxSIZE_T_IS_ULONG 1
-#define HAVE_FCNTL 1
-#define HAVE_GETHOSTBYNAME 1
-#define HAVE_GETSERVBYNAME 1
-#define HAVE_GMTIME_R 1
-#define HAVE_INET_ADDR 1
-#define HAVE_INET_ATON 1
-#define HAVE_LOCALTIME_R 1
-#define HAVE_MKSTEMP 1
-#define HAVE_PUTENV 1
-#define HAVE_READDIR_R 1
-#define HAVE_STRTOK_R 1
-#define HAVE_UNAME 1
-#define HAVE_USLEEP 1
-#define HAVE_X11_XKBLIB_H 1
-#define HAVE_FNMATCH 1
-#define HAVE_FNMATCH_H 1
-#define HAVE_IOSTREAM 1
-#define HAVE_SCHED_H 1
-#define HAVE_UNISTD_H 1
-#define HAVE_WCHAR_H 1
-#define HAVE_ICONV 1
-#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5
-#define ICONV_CONST const
-#else
-#define ICONV_CONST
-#endif
-#define HAVE_LANGINFO_H 1
-#define HAVE_WCSRTOMBS 1
-#define HAVE_FPUTWS 1
-#define HAVE_STRCASECMP_IN_STRING_H 1
-#define HAVE_WPRINTF 1
-#define HAVE_SWPRINTF 1
-#define HAVE_VSWPRINTF 1
-#define HAVE_FSEEKO 1
-#define HAVE_SYS_SELECT_H 1
-
-#define WXWIN_OS_DESCRIPTION "Darwin 7.9.0 Power Macintosh"
-#define PACKAGE_BUGREPORT "wx-dev@lists.wxwidgets.org"
-#define PACKAGE_NAME "wxWidgets"
-#define PACKAGE_STRING "wxWidgets 2.7.1"
-#define PACKAGE_TARNAME "wxwidgets"
-#define PACKAGE_VERSION "2.7.1"
-
-// for regex
-#define WX_NO_REGEX_ADVANCED 1
-
-// for jpeg
-
-#define HAVE_STDLIB_H 1
-
-// OBSOLETE ?
- 
-#define HAVE_COS 1
-#define HAVE_FLOOR 1
-#define HAVE_INTTYPES_H 1
-#define HAVE_MEMORY_H 1
-
-#define HAVE_REGCOMP 1
-#define HAVE_STRINGS_H 1
-#define HAVE_STRING_H 1
-#define HAVE_SYS_STAT_H 1
-#define HAVE_SYS_TYPES_H 1
-#define HAVE_X11_XLIB_H 1
-#define SOCKLEN_T socklen_t
-#define _FILE_OFFSET_BITS 64
+#define wxTYPE_SA_HANDLER int
--- a/include/wx/mac/carbon/cursor.h
+++ b/include/wx/mac/carbon/cursor.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/mac/carbon/cursor.h
+// Name:        cursor.h
 // Purpose:     wxCursor class
 // Author:      Stefan Csomor
 // Modified by:
@@ -34,7 +34,7 @@ public:
  wxCursor(int cursor_type);
  virtual ~wxCursor();

-  bool CreateFromXpm(const char **bits) ;
+	bool CreateFromXpm(const char **bits) ;
  virtual bool Ok() const { return IsOk(); }
  virtual bool IsOk() const ;

--- a/include/wx/mac/carbon/dcmemory.h
+++ b/include/wx/mac/carbon/dcmemory.h
@@ -19,7 +19,7 @@ class WXDLLEXPORT wxMemoryDC: public wxPaintDC
  DECLARE_DYNAMIC_CLASS(wxMemoryDC)

  public:
-    wxMemoryDC( const wxBitmap& bitmap = wxNullBitmap );
+    wxMemoryDC(void);
    wxMemoryDC( wxDC *dc ); // Create compatible DC
    virtual ~wxMemoryDC(void);
    virtual void SelectObject( const wxBitmap& bitmap );
--- a/include/wx/mac/carbon/dnd.h
+++ b/include/wx/mac/carbon/dnd.h
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
-// Name:        wx/mac/carbon/dnd.h
+// Name:        dnd.h
 // Purpose:     Declaration of the wxDropTarget, wxDropSource class etc.
 // Author:      Stefan Csomor
 // RCS-ID:      $Id$
@@ -55,7 +55,7 @@ class WXDLLEXPORT wxDropTarget: public wxDropTargetBase
    virtual bool OnDrop(wxCoord x, wxCoord y);
    virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
    virtual bool GetData();
-
+    
    bool CurrentDragHasSupportedFormat() ;
    void SetCurrentDrag( void* drag ) { m_currentDrag = drag ; }
    void* GetCurrentDrag() { return m_currentDrag ; }
@@ -95,14 +95,16 @@ public:
    wxWindow*     GetWindow() { return m_window ; }
    void SetCurrentDrag( void* drag ) { m_currentDrag = drag ; }
    void* GetCurrentDrag() { return m_currentDrag ; }
-    bool MacInstallDefaultCursor(wxDragResult effect) ;
+	bool			MacInstallDefaultCursor(wxDragResult effect) ;
  protected :
-
+  	
    wxWindow        *m_window;
    void* m_currentDrag ;
 };

-#endif // wxUSE_DRAG_AND_DROP
-
 #endif
-   //_WX_DND_H_
+      // D&D
+
+#endif  
+       //_WX_DND_H_
+
--- a/include/wx/mac/carbon/drawer.h
+++ b/include/wx/mac/carbon/drawer.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/mac/carbon/drawer.h
+// Name:        drawer.h
 // Purpose:     Drawer child window class.
 //              Drawer windows appear under their parent window and
 //              behave like a drawer, opening and closing to reveal
@@ -28,26 +28,26 @@
 class WXDLLEXPORT wxDrawerWindow : public wxTopLevelWindow
 {
    DECLARE_DYNAMIC_CLASS(wxDrawerWindow)
-
+    
 public:

    wxDrawerWindow();
-
+    
    wxDrawerWindow(wxWindow* parent,
-                   wxWindowID id,
-                   const wxString& title,
-                   wxSize size = wxDefaultSize,
-                   wxDirection edge = wxLEFT,
-                   const wxString& name = wxT("drawerwindow"))
+     wxWindowID id,
+     const wxString& title,
+     wxSize size = wxDefaultSize,
+     wxDirection edge = wxLEFT,
+     const wxString& name = wxT("drawerwindow"))
    {
        this->Create(parent, id, title, size, edge, name);
    }
-
+     
    virtual ~wxDrawerWindow();
-
-    // Create a drawer window.
+    
+    // Create a drawer window. 
    // If parent is NULL, create as a tool window.
-    // If parent is not NULL, then wxTopLevelWindow::Attach this window to parent.
+    // If parent is not NULL, then wxTopLevelWindow::Attach this window to parent. 
    bool Create(wxWindow *parent,
     wxWindowID id,
     const wxString& title,
@@ -58,14 +58,13 @@ public:
    bool Open(bool show = true); // open or close the drawer, possibility for async param, i.e. animate
    bool Close() { return this->Open(false); }
    bool IsOpen() const;
-
+    
    // Set the edge of the parent where the drawer attaches.
    bool SetPreferredEdge(wxDirection edge);
    wxDirection GetPreferredEdge() const;
-    wxDirection GetCurrentEdge() const; // not necessarily the preferred, due to screen constraints
+    wxDirection GetCurrentEdge() const;	// not necessarily the preferred, due to screen constraints
 };

 #endif // defined( __WXMAC__ ) && TARGET_API_MAC_OSX && ( MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_2 )

-#endif
-    // _WX_DRAWERWINDOW_H_
+#endif // _WX_DRAWERWINDOW_H_
--- a/include/wx/mac/carbon/fontdlg.h
+++ b/include/wx/mac/carbon/fontdlg.h
@@ -1,6 +1,6 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/mac/carbon/fontdlg.h
-// Purpose:     wxFontDialog class using fonts window services (10.2+).
+// Name:        fontdlg.h
+// Purpose:     wxFontDialog class using fonts window services (10.2+). 
 // Author:      Ryan Norton
 // Modified by:
 // Created:     2004-09-25
@@ -157,10 +157,11 @@ public:
 protected:
    wxWindow*   m_dialogParent;
    wxFontData  m_fontData;
-    void*       m_pEventHandlerRef;
+    void*		m_pEventHandlerRef;
 };

 #endif

 #endif
    // _WX_FONTDLG_H_
+
--- a/include/wx/mac/carbon/mimetype.h
+++ b/include/wx/mac/carbon/mimetype.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/mac/carbon/mimetype.h
+// Name:        wx/mac/mimetype.h
 // Purpose:     Mac Carbon implementation for wx mime-related classes
 // Author:      Ryan Norton
 // Modified by:
@@ -19,11 +19,11 @@
 class wxMimeTypesManagerImpl
 {
 public :
-    //kinda kooky but in wxMimeTypesManager::EnsureImpl it doesn't call
+    //kinda kooky but in wxMimeTypesManager::EnsureImpl it doesn't call 
    //intialize, so we do it ourselves
    wxMimeTypesManagerImpl() : m_hIC(NULL) { Initialize(); }
    ~wxMimeTypesManagerImpl() { ClearData(); }
-
+ 
    // load all data into memory - done when it is needed for the first time
    void Initialize(int mailcapStyles = wxMAILCAP_STANDARD,
                    const wxString& extraDir = wxEmptyString);
@@ -48,20 +48,20 @@ public :
    wxFileType *Associate(const wxFileTypeInfo& ftInfo);
    // remove association
    bool Unassociate(wxFileType *ft);
-
+    
 private:
    wxArrayFileTypeInfo m_fallbacks;
-    void*  m_hIC;
-    void** m_hDatabase;
-    long   m_lCount;
-
+    void* 				m_hIC;
+    void** 				m_hDatabase;
+    long				m_lCount;
+    
    void* pReserved1;
    void* pReserved2;
    void* pReserved3;
    void* pReserved4;
    void* pReserved5;
    void* pReserved6;
-
+    
    friend class wxFileTypeImpl;
 };

@@ -71,7 +71,7 @@ public:
    //kind of nutty, but mimecmn.cpp creates one with an empty new
    wxFileTypeImpl() : m_manager(NULL) {}
    ~wxFileTypeImpl() {} //for those broken compilers
-
+    
    // implement accessor functions
    bool GetExtensions(wxArrayString& extensions);
    bool GetMimeType(wxString *mimeType) const;
@@ -99,15 +99,15 @@ public:
    bool SetDefaultIcon(const wxString& strIcon = wxEmptyString, int index = 0);

 private:
-    void Init(wxMimeTypesManagerImpl *manager, long lIndex)
+    void Init(wxMimeTypesManagerImpl *manager, long lIndex) 
    { m_manager=(manager); m_lIndex=(lIndex); }

    // helper function
    wxString GetCommand(const wxString& verb) const;
-
+    
    wxMimeTypesManagerImpl *m_manager;
-    long                    m_lIndex;
-
+    long                    m_lIndex; 
+    
    void* pReserved1;
    void* pReserved2;
    void* pReserved3;
@@ -119,4 +119,4 @@ public:
 };

 #endif
-    //_MIMETYPE_H
+  //_MIMETYPE_H
--- a/include/wx/mac/carbon/private.h
+++ b/include/wx/mac/carbon/private.h
@@ -43,10 +43,6 @@
    #define MAC_OS_X_VERSION_10_4 1040
 #endif

-#ifndef MAC_OS_X_VERSION_10_5
-    #define MAC_OS_X_VERSION_10_5 1050
-#endif
-
 #ifdef __WXMAC_CARBON__
 #include "wx/mac/corefoundation/cfstring.h"
 #endif
@@ -64,17 +60,10 @@ inline int    FixedToInt( Fixed inFixed )
 }
 #endif

-#if MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_5
-typedef UInt32 URefCon;
-typedef SInt32 SRefCon;
-#endif
-
 #if wxUSE_GUI

 #include "wx/listbox.h"

-#ifndef __LP64__
-
 class wxMacPortStateHelper
 {
    DECLARE_NO_COPY_CLASS(wxMacPortStateHelper)
@@ -151,7 +140,6 @@ private:
    GrafPtr   m_newPort;
    ThemeDrawingState m_themeDrawingState;
 };
-#endif

 #if wxMAC_USE_CORE_GRAPHICS
 class WXDLLEXPORT wxMacCGContextStateSaver
@@ -508,7 +496,7 @@ public :
    virtual ControlRef * GetControlRefAddr() { return &m_controlRef; }
    virtual ControlRef GetControlRef() const { return m_controlRef; }

-    virtual void SetReference( URefCon data );
+    virtual void SetReference( SInt32 data );
    /*
    void operator= (ControlRef c) { m_controlRef = c; }
    operator ControlRef () { return m_controlRef; }
@@ -675,7 +663,7 @@ public :
    OSStatus GetItemCount( DataBrowserItemID container,
            Boolean recurse,
            DataBrowserItemState state,
-            ItemCount *numItems) const;
+            UInt32 *numItems) const;

    OSStatus GetItems( DataBrowserItemID container,
            Boolean recurse,
@@ -739,8 +727,8 @@ public :

    OSStatus GetColumnIDFromIndex( DataBrowserTableViewColumnIndex position, DataBrowserTableViewColumnID* id );

-    OSStatus GetColumnPosition( DataBrowserPropertyID column, DataBrowserTableViewColumnIndex *position) const;
-    OSStatus SetColumnPosition( DataBrowserPropertyID column, DataBrowserTableViewColumnIndex position);
+    OSStatus GetColumnPosition( DataBrowserPropertyID column, UInt32 *position) const;
+    OSStatus SetColumnPosition( DataBrowserPropertyID column, UInt32 position);

    OSStatus GetScrollPosition( UInt32 *top , UInt32 *left ) const;
    OSStatus SetScrollPosition( UInt32 top , UInt32 left );
@@ -785,14 +773,14 @@ protected :
        Boolean changeValue ) = 0;

    static pascal Boolean DataBrowserCompareProc(
-        ControlRef browser,
-        DataBrowserItemID itemOneID,
-        DataBrowserItemID itemTwoID,
-        DataBrowserPropertyID sortProperty);
+	    ControlRef browser,
+	    DataBrowserItemID itemOneID,
+	    DataBrowserItemID itemTwoID,
+	    DataBrowserPropertyID sortProperty);

-    virtual Boolean CompareItems(DataBrowserItemID itemOneID,
-        DataBrowserItemID itemTwoID,
-        DataBrowserPropertyID sortProperty) = 0;
+	virtual Boolean CompareItems(DataBrowserItemID itemOneID,
+	    DataBrowserItemID itemTwoID,
+	    DataBrowserPropertyID sortProperty) = 0;
 };

 // ============================================================================
@@ -1273,8 +1261,6 @@ private :

 ControlRef wxMacFindControlUnderMouse( wxTopLevelWindowMac* toplevelWindow, const Point& location , WindowRef window , ControlPartCode *outPart );

-#ifndef __LP64__
-
 #ifdef WORDS_BIGENDIAN
    inline Rect* wxMacGetPictureBounds( PicHandle pict , Rect* rect )
    {
@@ -1288,8 +1274,6 @@ ControlRef wxMacFindControlUnderMouse( wxTopLevelWindowMac* toplevelWindow, cons
    }
 #endif

-#endif
-
 #endif // wxUSE_GUI

 #define wxMAC_DEFINE_PROC_GETTER( UPP , x ) \
@@ -1317,14 +1301,5 @@ wxString wxMacFSRefToPath( const FSRef *fsRef , CFStringRef additionalPathCompon
 OSStatus wxMacPathToFSRef( const wxString&path , FSRef *fsRef );
 wxString wxMacHFSUniStrToString( ConstHFSUniStr255Param uniname );

-#if wxUSE_GUI
-
-// deprecating QD
-
-void wxMacLocalToGlobal( WindowRef window , Point*pt );
-void wxMacGlobalToLocal( WindowRef window , Point*pt );
-
-#endif
-
 #endif
    // _WX_PRIVATE_H_
--- a/include/wx/mac/carbon/private/print.h
+++ b/include/wx/mac/carbon/private/print.h
@@ -1,10 +1,10 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/mac/carbon/private/print.h
+// Name:        print.h
 // Purpose:     private implementation for printing on MacOS
 // Author:      Stefan Csomor
 // Modified by:
 // Created:     03/02/99
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) Stefan Csomor
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
--- a/include/wx/mac/carbon/toolbar.h
+++ b/include/wx/mac/carbon/toolbar.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/mac/carbon/toolbar.h
+// Name:        toolbar.h
 // Purpose:     wxToolBar class
 // Author:      Stefan Csomor
 // Modified by:
@@ -93,9 +93,9 @@ protected:
    virtual wxToolBarToolBase *CreateTool(wxControl *control);

    DECLARE_EVENT_TABLE()
-#if wxMAC_USE_NATIVE_TOOLBAR
-    bool m_macUsesNativeToolbar ;
-    void* m_macHIToolbarRef ;
+#if wxMAC_USE_NATIVE_TOOLBAR    
+	bool m_macUsesNativeToolbar ;
+	void* m_macHIToolbarRef ;
 #endif
 };

--- a/include/wx/mac/carbon/uma.h
+++ b/include/wx/mac/carbon/uma.h
@@ -1,10 +1,10 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/mac/carbon/uma.h
+// Name:        uma.h
 // Purpose:     Universal MacOS API
 // Author:      Stefan Csomor
 // Modified by:
 // Created:     03/02/99
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) Stefan Csomor
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
@@ -17,6 +17,11 @@
 void UMAInitToolbox( UInt16 inMoreMastersCalls, bool isEmbedded) ;
 void UMACleanupToolbox() ;
 long UMAGetSystemVersion() ;
+bool UMAHasAppearance() ;
+long UMAGetAppearanceVersion() ;
+bool UMAHasWindowManager() ;
+long UMAGetWindowManagerAttr() ;
+bool UMAHasAquaLayout() ;

 bool UMASystemIsInitialized() ;
 void UMASetSystemIsInitialized(bool val);
--- a/include/wx/mac/carbon/window.h
+++ b/include/wx/mac/carbon/window.h
@@ -65,8 +65,7 @@ public:
                          const wxRect *rect = NULL );
    virtual void Freeze();
    virtual void Thaw();
-    virtual bool IsFrozen() const;
-    
+
    virtual void Update() ;
    virtual void ClearBackground();

--- a/include/wx/mac/classic/cursor.h
+++ b/include/wx/mac/classic/cursor.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/mac/classic/cursor.h
+// Name:        cursor.h
 // Purpose:     wxCursor class
 // Author:      Stefan Csomor
 // Modified by:
@@ -17,7 +17,7 @@
 class WXDLLEXPORT wxCursorRefData: public wxBitmapRefData
 {
    DECLARE_NO_COPY_CLASS(wxCursorRefData)
-
+        
    friend class WXDLLEXPORT wxBitmap;
    friend class WXDLLEXPORT wxCursor;
 public:
@@ -55,7 +55,7 @@ public:
  wxCursor(int cursor_type);
  virtual ~wxCursor();

-  bool CreateFromXpm(const char **bits) ;
+	bool CreateFromXpm(const char **bits) ;
  virtual bool Ok() const { return IsOk(); }
  virtual bool IsOk() const { return (m_refData != NULL && ( M_CURSORDATA->m_hCursor != NULL || M_CURSORDATA->m_themeCursor != -1 ) ) ; }

--- a/include/wx/mac/classic/dcmemory.h
+++ b/include/wx/mac/classic/dcmemory.h
@@ -19,7 +19,7 @@ class WXDLLEXPORT wxMemoryDC: public wxPaintDC
  DECLARE_DYNAMIC_CLASS(wxMemoryDC)

  public:
-    wxMemoryDC( const wxBitmap& bitmap = wxNullBitmap );
+    wxMemoryDC(void);
    wxMemoryDC( wxDC *dc ); // Create compatible DC
    virtual ~wxMemoryDC(void);
    virtual void SelectObject( const wxBitmap& bitmap );
--- a/include/wx/mac/classic/dnd.h
+++ b/include/wx/mac/classic/dnd.h
@@ -1,5 +1,5 @@
 ///////////////////////////////////////////////////////////////////////////////
-// Name:        wx/mac/classic/dnd.h
+// Name:        dnd.h
 // Purpose:     Declaration of the wxDropTarget, wxDropSource class etc.
 // Author:      Stefan Csomor
 // RCS-ID:      $Id$
@@ -55,7 +55,7 @@ class WXDLLEXPORT wxDropTarget: public wxDropTargetBase
    virtual bool OnDrop(wxCoord x, wxCoord y);
    virtual wxDragResult OnData(wxCoord x, wxCoord y, wxDragResult def);
    virtual bool GetData();
-
+    
    bool CurrentDragHasSupportedFormat() ;
    void SetCurrentDrag( void* drag ) { m_currentDrag = drag ; }
    void* GetCurrentDrag() { return m_currentDrag ; }
@@ -95,14 +95,16 @@ public:
    wxWindow*     GetWindow() { return m_window ; }
    void SetCurrentDrag( void* drag ) { m_currentDrag = drag ; }
    void* GetCurrentDrag() { return m_currentDrag ; }
-    bool MacInstallDefaultCursor(wxDragResult effect) ;
-protected :
-
+	bool			MacInstallDefaultCursor(wxDragResult effect) ;
+  protected :
+  	
    wxWindow        *m_window;
    void* m_currentDrag ;
 };

-#endif // wxUSE_DRAG_AND_DROP
-
 #endif
-    //_WX_DND_H_
+      // D&D
+
+#endif  
+       //_WX_DND_H_
+
--- a/include/wx/mac/classic/private.h
+++ b/include/wx/mac/classic/private.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/mac/classic/private.h
+// Name:        private.h
 // Purpose:     Private declarations: as this header is only included by
 //              wxWidgets itself, it may contain identifiers which don't start
 //              with "wx".
@@ -37,12 +37,12 @@

 #include "wx/window.h"

-class wxMacPortStateHelper
+class wxMacPortStateHelper 
 {
    DECLARE_NO_COPY_CLASS(wxMacPortStateHelper)
-
+        
 public:
-    wxMacPortStateHelper( GrafPtr newport) ;
+    wxMacPortStateHelper( GrafPtr newport) ; 
    wxMacPortStateHelper() ;
    ~wxMacPortStateHelper() ;

@@ -65,7 +65,7 @@ private:
 class WXDLLEXPORT wxMacPortSetter
 {
    DECLARE_NO_COPY_CLASS(wxMacPortSetter)
-
+        
 public:
    wxMacPortSetter( const wxDC* dc ) ;
    ~wxMacPortSetter() ;
@@ -77,7 +77,7 @@ private:
 class WXDLLEXPORT wxMacWindowClipper
 {
    DECLARE_NO_COPY_CLASS(wxMacWindowClipper)
-
+        
 public:
    wxMacWindowClipper( const wxWindow* win ) ;
    ~wxMacWindowClipper() ;
@@ -89,7 +89,7 @@ private:
 class wxMacDrawingHelper
 {
    DECLARE_NO_COPY_CLASS(wxMacDrawingHelper)
-
+        
 public:
    wxMacDrawingHelper( wxWindowMac * theWindow , bool clientArea = false ) ;
    ~wxMacDrawingHelper() ;
@@ -177,57 +177,57 @@ void wxMacConvertNewlines10To13( wxChar * data ) ;

 #if TARGET_CARBON

-class wxMacCFStringHolder
-{
-public:
-    wxMacCFStringHolder()
-    {
-        m_cfs = NULL ;
-        m_release = false ;
-    }
-
-    wxMacCFStringHolder(const wxString &str , wxFontEncoding encoding )
-    {
-        m_cfs = NULL ;
-        m_release = false ;
-        Assign( str , encoding ) ;
-    }
-
-    wxMacCFStringHolder(CFStringRef ref , bool release = true )
-    {
+class wxMacCFStringHolder                                                             
+{                                                                           
+public:      
+	wxMacCFStringHolder()
+	{
+    	m_cfs = NULL ;
+    	m_release = false ;                                                                 
+	}
+	                                                               
+    wxMacCFStringHolder(const wxString &str , wxFontEncoding encoding )                                          
+    {      
+    	m_cfs = NULL ;
+    	m_release = false ;  
+    	Assign( str , encoding ) ;
+    }                                                                       
+                                                                            
+    wxMacCFStringHolder(CFStringRef ref , bool release = true )                                                   
+    {                                                                       
        m_cfs = ref ;
-        m_release = release ;
-    }
-
-    ~wxMacCFStringHolder()
-    {
-        Release() ;
-    }
+        m_release = release ;                                           
+    }                                                                       
+                                                                            
+    ~wxMacCFStringHolder() 
+    { 
+    	Release() ;
+    }                                           

    CFStringRef Detach()
    {
-        CFStringRef retval = m_cfs ;
-        m_release = false ;
-        m_cfs = NULL ;
-        return retval ;
-    }
-
+    	CFStringRef retval = m_cfs ;
+    	m_release = false ;
+    	m_cfs = NULL ;
+    	return retval ;
+    }         
+                                                                   
    void Release()
    {
-        if ( m_release && m_cfs)
-            CFRelease( m_cfs ) ;
-        m_cfs = NULL ;
-    }
+    	if ( m_release && m_cfs)
+    		CFRelease( m_cfs ) ;
+    	m_cfs = NULL ;
+    }         

-    void Assign( const wxString &str , wxFontEncoding encoding ) ;
+	void Assign( const wxString &str , wxFontEncoding encoding ) ;

-    operator CFStringRef () { return m_cfs; }
+    operator CFStringRef () { return m_cfs; }   
    wxString AsString( wxFontEncoding encoding = wxFONTENCODING_DEFAULT ) ;
-
-private:
-
+             
+private:             
+    	                                                       
    CFStringRef m_cfs;
-    bool m_release ;
+    bool m_release ;                                                        
 } ;

 #endif
--- a/include/wx/mac/classic/private/print.h
+++ b/include/wx/mac/classic/private/print.h
@@ -1,10 +1,10 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/mac/classic/private/print.h
+// Name:        print.h
 // Purpose:     private implementation for printing on MacOS
 // Author:      Stefan Csomor
 // Modified by:
 // Created:     03/02/99
-// RCS-ID:      $Id$
+// RCS-ID:      $Id: 
 // Copyright:   (c) Stefan Csomor
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
@@ -23,7 +23,7 @@
 #  include "Printing.h"
 #endif

-#if TARGET_CARBON
+#if TARGET_CARBON 
 #if !PM_USE_SESSION_APIS
 #error "only Carbon Printing Session API is supported"
 #endif
@@ -34,48 +34,48 @@ class wxNativePrintData
 public :
                            wxNativePrintData() {}
    virtual                 ~wxNativePrintData() {}
-
+    
    virtual void            TransferFrom( wxPrintData * ) = 0 ;
    virtual void            TransferTo( wxPrintData * ) = 0 ;
-
+    
    virtual void            TransferFrom( wxPageSetupDialogData * ) = 0 ;
    virtual void            TransferTo( wxPageSetupDialogData * ) = 0 ;
-
+    
    virtual void            TransferFrom( wxPrintDialogData * ) = 0 ;
    virtual void            TransferTo( wxPrintDialogData * ) = 0 ;
-
+    
    virtual void            CopyFrom( wxNativePrintData * ) = 0;
-
+ 
    virtual int             ShowPrintDialog() = 0 ;
    virtual int             ShowPageSetupDialog() = 0 ;
-
+   
    static wxNativePrintData* Create() ;
 } ;

 #if TARGET_CARBON

-class wxMacCarbonPrintData : public wxNativePrintData
+class wxMacCarbonPrintData : public wxNativePrintData 
 {
 public :
                            wxMacCarbonPrintData() ;
                            ~wxMacCarbonPrintData() ;
-
+                            
    virtual void            TransferFrom( wxPrintData * ) ;
    virtual void            TransferTo( wxPrintData * )  ;
-
+    
    virtual void            TransferFrom( wxPageSetupDialogData * )  ;
    virtual void            TransferTo( wxPageSetupDialogData * ) ;
-
+    
    virtual void            TransferFrom( wxPrintDialogData * )  ;
    virtual void            TransferTo( wxPrintDialogData * ) ;
-
+    
    virtual void            CopyFrom( wxNativePrintData * ) ;
    virtual int             ShowPrintDialog() ;
    virtual int             ShowPageSetupDialog() ;
 private :
    virtual void            ValidateOrCreate() ;
 public :
-    PMPrintSession          m_macPrintSession ;
+    PMPrintSession			m_macPrintSession ;
    PMPageFormat            m_macPageFormat ;
    PMPrintSettings         m_macPrintSettings ;
 } ;
@@ -105,4 +105,3 @@ public :
 #endif

 #endif
-    // _WX_MAC_PRIVATE_PRINT_H_
--- a/include/wx/mac/classic/taskbarosx.h
+++ b/include/wx/mac/classic/taskbarosx.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////
-// File:        wx/mac/classic/taskbarosx.h
+// File:        wx/mac/taskbarosx.h
 // Purpose:     Defines wxTaskBarIcon class for OSX
 // Author:      Ryan Norton
 // Modified by:
@@ -18,14 +18,14 @@ class WXDLLEXPORT wxMenu;
 class WXDLLEXPORT wxTaskBarIcon : public wxTaskBarIconBase
 {
 public:
-    //type of taskbar item to create (currently only DOCK is implemented)
-    enum wxTaskBarIconType
-    {
-        DOCK,
-        STATUSITEM,
-        MENUEXTRA
-    };
-
+	//type of taskbar item to create (currently only DOCK is implemented)
+	enum wxTaskBarIconType
+	{
+		DOCK,
+		STATUSITEM,
+		MENUEXTRA
+	};
+	
    wxTaskBarIcon(const wxTaskBarIconType& nType = DOCK);
    virtual ~wxTaskBarIcon();

@@ -36,7 +36,7 @@ public:

 protected:
    wxTaskBarIconType m_nType;
-
+	
    DECLARE_DYNAMIC_CLASS(wxTaskBarIcon)
 };

--- a/include/wx/mac/classic/uma.h
+++ b/include/wx/mac/classic/uma.h
@@ -1,10 +1,10 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/mac/classic/uma.h
+// Name:        uma.h
 // Purpose:     Universal MacOS API
 // Author:      Stefan Csomor
 // Modified by:
 // Created:     03/02/99
-// RCS-ID:      $Id$
+// RCS-ID:      $Id:
 // Copyright:   (c) Stefan Csomor
 // Licence:     wxWindows licence
 /////////////////////////////////////////////////////////////////////////////
--- a/include/wx/mac/corefoundation/hid.h
+++ b/include/wx/mac/corefoundation/hid.h
@@ -91,7 +91,7 @@ protected:
    wxString    m_szProductName; //product name
    int         m_nProductId; //product id
    int         m_nManufacturerId; //manufacturer id
-    mach_port_t m_pPort;            //mach port to use
+    mach_port_t 			m_pPort;            //mach port to use
 };

 // ---------------------------------------------------------------------------
@@ -112,5 +112,4 @@ public:

 #endif //__DARWIN__

-#endif
-    // _WX_MACCARBONHID_H_
+#endif //WX_MACCARBONHID_H
--- a/include/wx/mgl/dcmemory.h
+++ b/include/wx/mgl/dcmemory.h
@@ -26,7 +26,7 @@ class WXDLLEXPORT wxMemoryDC;
 class WXDLLEXPORT wxMemoryDC : public wxDC
 {
 public:
-    wxMemoryDC( const wxBitmap& bitmap = wxNullBitmap );
+    wxMemoryDC();
    wxMemoryDC(wxDC *dc); // Create compatible DC
    virtual ~wxMemoryDC();
    virtual void SelectObject(const wxBitmap& bitmap);
--- a/include/wx/motif/dcmemory.h
+++ b/include/wx/motif/dcmemory.h
@@ -19,7 +19,7 @@ class WXDLLIMPEXP_CORE wxMemoryDC : public wxWindowDC
    DECLARE_DYNAMIC_CLASS(wxMemoryDC)

 public:
-    wxMemoryDC( const wxBitmap& bitmap = wxNullBitmap );
+    wxMemoryDC();
    wxMemoryDC( wxDC *dc ); // Create compatible DC
    virtual ~wxMemoryDC();

--- a/include/wx/motif/toolbar.h
+++ b/include/wx/motif/toolbar.h
@@ -6,7 +6,7 @@
 // Created:     17/09/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_TOOLBAR_H_
@@ -17,7 +17,7 @@ class WXDLLEXPORT wxToolBar : public wxToolBarBase
 public:
    // ctors and dtor
    wxToolBar() { Init(); }
-
+    
    wxToolBar(wxWindow *parent,
        wxWindowID id,
        const wxPoint& pos = wxDefaultPosition,
@@ -26,41 +26,41 @@ public:
        const wxString& name = wxToolBarNameStr)
    {
        Init();
-
+        
        Create(parent, id, pos, size, style, name);
    }
-
+    
    bool Create(wxWindow *parent,
        wxWindowID id,
        const wxPoint& pos = wxDefaultPosition,
        const wxSize& size = wxDefaultSize,
        long style = wxNO_BORDER | wxTB_HORIZONTAL,
        const wxString& name = wxToolBarNameStr);
-
+    
    virtual ~wxToolBar();
-
+    
    // override/implement base class virtuals
    virtual wxToolBarToolBase *FindToolForPosition(wxCoord x, wxCoord y) const;
-
+    
    virtual bool Realize();
-
+    
    // implementation from now on
-
+    
    // find tool by widget
    wxToolBarToolBase *FindToolByWidget(WXWidget w) const;
-
+    
 private:
    // common part of all ctors
    void Init();
-
+    
    // implement base class pure virtuals
    virtual bool DoInsertTool(size_t pos, wxToolBarToolBase *tool);
    virtual bool DoDeleteTool(size_t pos, wxToolBarToolBase *tool);
-
+    
    virtual void DoEnableTool(wxToolBarToolBase *tool, bool enable);
    virtual void DoToggleTool(wxToolBarToolBase *tool, bool toggle);
    virtual void DoSetToggle(wxToolBarToolBase *tool, bool toggle);
-
+    
    virtual wxToolBarToolBase *CreateTool(int id,
                                          const wxString& label,
                                          const wxBitmap& bmpNormal,
@@ -79,4 +79,4 @@ private:
 };

 #endif
-    // _WX_TOOLBAR_H_
+// _WX_TOOLBAR_H_
--- a/include/wx/msw/dcmemory.h
+++ b/include/wx/msw/dcmemory.h
@@ -17,7 +17,7 @@
 class WXDLLEXPORT wxMemoryDC : public wxDC
 {
 public:
-    wxMemoryDC( const wxBitmap& bitmap = wxNullBitmap );
+    wxMemoryDC();
    wxMemoryDC(wxDC *dc); // Create compatible DC

    virtual void SelectObject(const wxBitmap& bitmap);
--- a/include/wx/msw/missing.h
+++ b/include/wx/msw/missing.h
@@ -190,7 +190,7 @@ typedef OSVERSIONINFOEXA OSVERSIONINFOEX,*POSVERSIONINFOEX,*LPOSVERSIONINFOEX;
 // NMLVCUSTOMDRAW originally didn't have the iSubItem member. It was added
 // with IE4, as was IPN_FIRST which is used as a test :-(.
 //
-#ifndef IPN_FIRST
+#ifndef IPN_FIRST	

 typedef struct wxtagNMLVCUSTOMDRAW_ {
    NMCUSTOMDRAW nmcd;
@@ -202,7 +202,7 @@ typedef struct wxtagNMLVCUSTOMDRAW_ {
 #define NMLVCUSTOMDRAW wxNMLVCUSTOMDRAW_
 #define LPNMLVCUSTOMDRAW wxLPNMLVCUSTOMDRAW_

-#endif // defined IPN_FIRST
+#endif // defined IPN_FIRST	

 #endif // defined __VISUALC__ && __VISUALC__ <= 1100

--- a/include/wx/object.h
+++ b/include/wx/object.h
@@ -17,6 +17,7 @@
 // headers
 // ----------------------------------------------------------------------------

+#include "wx/defs.h"
 #include "wx/memory.h"

 class WXDLLIMPEXP_BASE wxObject;
@@ -470,16 +471,13 @@ public:
    // destroy a reference
    void UnRef();

-    // Make sure this object has only one reference
-    void UnShare() { AllocExclusive(); }
-
 protected:
    // ensure that our data is not shared with anybody else: if we have no
    // data, it is created using CreateRefData() below, if we have shared data
    // it is copied using CloneRefData(), otherwise nothing is done
    void AllocExclusive();

-    // both methods must be implemented if AllocExclusive() is used, not pure virtual
+    // both methods must be implemented if Unshare() is used, not pure virtual
    // only because of the backwards compatibility reasons

    // create a new m_refData
--- a/include/wx/os2/dcmemory.h
+++ b/include/wx/os2/dcmemory.h
@@ -17,7 +17,7 @@
 class WXDLLEXPORT wxMemoryDC: public wxDC
 {
 public:
-    wxMemoryDC( const wxBitmap& bitmap = wxNullBitmap );
+    wxMemoryDC(void);
    wxMemoryDC(wxDC* pDC); // Create compatible DC

    virtual void SelectObject(const wxBitmap& rBitmap);
--- a/include/wx/os2/helpwin.h
+++ b/include/wx/os2/helpwin.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/os2/helpwin.h
+// Name:        helpxxxx.h
 // Purpose:     Help system: native implementation for your system.
 // Author:      David Webster
 // Modified by:
-// Created:     10/09/99
+// Created:      10/09/99
 // RCS-ID:      $Id$
 // Copyright:   (c) David Webster
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_HELPWIN_H_
--- a/include/wx/os2/pnghand.h
+++ b/include/wx/os2/pnghand.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/os2/pnghand.h
+// Name:        pnghand.h
 // Purpose:     PNG bitmap handler
 // Author:      Julian Smart
 // Modified by:
 // Created:     04/01/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Microsoft, Julian Smart
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_PNGHAND_H_
@@ -38,4 +38,5 @@ public:
 };

 #endif
-    // _WX_PNGHAND_H_
+  // _WX_PNGHAND_H_
+
--- a/include/wx/os2/pngread.h
+++ b/include/wx/os2/pngread.h
@@ -1,10 +1,9 @@
 /*
- * File:    wx/os2/pngread.h
- * Purpose: PNG file reader
- * Author:  Alejandro Aguilar Sierra/Julian Smart
- * Created: 1995
- * RCS-ID:  $Id$
- * Copyright: (c) 1995, Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
+ * File:	pngread.h
+ * Purpose:	PNG file reader
+ * Author:	Alejandro Aguilar Sierra/Julian Smart
+ * Created:	1995
+ * Copyright:	(c) 1995, Alejandro Aguilar Sierra <asierra@servidor.unam.mx>
 *
 *
 */
@@ -22,15 +21,15 @@ typedef byte* ImagePointerType;

 typedef struct
 {
-    byte red;
-    byte green;
-    byte blue;
+	byte red;
+	byte green;
+   byte blue;
 } rgb_color_struct;


-#define COLORTYPE_PALETTE  1
-#define COLORTYPE_COLOR    2
-#define COLORTYPE_ALPHA    4
+#define COLORTYPE_PALETTE	1
+#define COLORTYPE_COLOR		2
+#define COLORTYPE_ALPHA		4

 class wxPNGReader
 {
@@ -144,7 +143,7 @@ inline
 wxPNGReaderIter::wxPNGReaderIter(wxPNGReader *imax): ima(imax)
 {
  if (ima)
-    IterImage = ima->RawImage;
+	 IterImage = ima->RawImage;
  Itx = Ity = 0;
  Stepx = Stepy = 0;
 }
@@ -159,9 +158,9 @@ inline
 bool wxPNGReaderIter::ItOK ()
 {
  if (ima)
-    return ima->Inside(Itx, Ity);
+	 return ima->Inside(Itx, Ity);
  else
-    return FALSE;
+	 return FALSE;
 }


@@ -207,7 +206,7 @@ inline void wxPNGReaderIter::SetRow(byte *buf, int n)
 // Here should be bcopy or memcpy
  //_fmemcpy(IterImage, (void far *)buf, n);
  if (n<0)
-    n = ima->GetWidth();
+	 n = ima->GetWidth();

  for (int i=0; i<n; i++) IterImage[i] = buf[i];
 }
@@ -285,4 +284,4 @@ inline bool wxPNGReaderIter::PrevStep()
 }

 #endif
-    // _WX_PNGREAD__
+
--- a/include/wx/palmos/dcmemory.h
+++ b/include/wx/palmos/dcmemory.h
@@ -17,7 +17,7 @@
 class WXDLLEXPORT wxMemoryDC : public wxDC
 {
 public:
-    wxMemoryDC( const wxBitmap& bitmap = wxNullBitmap );
+    wxMemoryDC();
    wxMemoryDC(wxDC *dc); // Create compatible DC

    virtual void SelectObject(const wxBitmap& bitmap);
--- a/include/wx/platform.h
+++ b/include/wx/platform.h
@@ -33,7 +33,6 @@
 #    if defined(__MACH__)
 #        define __WXMAC_OSX__
 #        define __WXMAC_CARBON__
-#        include <AvailabilityMacros.h>
 #        ifdef __WXMAC_XCODE__
 #            include <unistd.h>
 #            include "wx/mac/carbon/config_xcode.h"
--- a/include/wx/richtext/richtextbuffer.h
+++ b/include/wx/richtext/richtextbuffer.h
@@ -98,7 +98,6 @@ class WXDLLIMPEXP_RICHTEXT wxRichTextParagraph;
 class WXDLLIMPEXP_RICHTEXT wxRichTextFileHandler;
 class WXDLLIMPEXP_RICHTEXT wxRichTextStyleSheet;
 class WXDLLIMPEXP_RICHTEXT wxTextAttrEx;
-class WXDLLIMPEXP_RICHTEXT wxRichTextListStyleDefinition;

 /*!
 * Flags determining the available space, passed to Layout
@@ -134,7 +133,7 @@ class WXDLLIMPEXP_RICHTEXT wxRichTextListStyleDefinition;
 #define wxRICHTEXT_UNFORMATTED      0x02

 /*!
- * Flags for SetStyle/SetListStyle
+ * Flags for SetStyle
 */

 #define wxRICHTEXT_SETSTYLE_NONE            0x00
@@ -156,14 +155,6 @@ class WXDLLIMPEXP_RICHTEXT wxRichTextListStyleDefinition;
 // preserved independently from that of e.g. a named paragraph style.
 #define wxRICHTEXT_SETSTYLE_CHARACTERS_ONLY 0x08

-// For SetListStyle only: specifies starting from the given number, otherwise
-// deduces number from existing attributes
-#define wxRICHTEXT_SETSTYLE_RENUMBER        0x10
-
-// For SetListStyle only: specifies the list level for all paragraphs, otherwise
-// the current indentation will be used
-#define wxRICHTEXT_SETSTYLE_SPECIFY_LEVEL   0x20
-
 /*!
 * Flags for text insertion
 */
@@ -183,7 +174,6 @@ class WXDLLIMPEXP_RICHTEXT wxRichTextListStyleDefinition;
 #define wxTEXT_ATTR_BULLET_STYLE            0x00010000
 #define wxTEXT_ATTR_BULLET_NUMBER           0x00020000
 #define wxTEXT_ATTR_BULLET_SYMBOL           0x00040000
-#define wxTEXT_ATTR_LIST_STYLE_NAME         0x00080000

 /*!
 * Styles for wxTextAttrEx::SetBulletStyle
@@ -284,22 +274,18 @@ public:
    wxTextAttrEx(const wxTextAttr& attr) { Init(); (*this) = attr; }
    wxTextAttrEx() { Init(); }

-    // Initialise this object
+    // Initialise this object.
    void Init();

    // Assignment from a wxTextAttrEx object
    void operator= (const wxTextAttrEx& attr);

-    // Assignment from a wxTextAttr object
+    // Assignment from a wxTextAttr object.
    void operator= (const wxTextAttr& attr);

-    // Equality test
-    bool operator== (const wxTextAttrEx& attr) const;
-
    // setters
    void SetCharacterStyleName(const wxString& name) { m_characterStyleName = name; SetFlags(GetFlags() | wxTEXT_ATTR_CHARACTER_STYLE_NAME); }
    void SetParagraphStyleName(const wxString& name) { m_paragraphStyleName = name; SetFlags(GetFlags() | wxTEXT_ATTR_PARAGRAPH_STYLE_NAME); }
-    void SetListStyleName(const wxString& name) { m_listStyleName = name; SetFlags(GetFlags() | wxTEXT_ATTR_LIST_STYLE_NAME); }
    void SetParagraphSpacingAfter(int spacing) { m_paragraphSpacingAfter = spacing; SetFlags(GetFlags() | wxTEXT_ATTR_PARA_SPACING_AFTER); }
    void SetParagraphSpacingBefore(int spacing) { m_paragraphSpacingBefore = spacing; SetFlags(GetFlags() | wxTEXT_ATTR_PARA_SPACING_BEFORE); }
    void SetLineSpacing(int spacing) { m_lineSpacing = spacing; SetFlags(GetFlags() | wxTEXT_ATTR_LINE_SPACING); }
@@ -310,7 +296,6 @@ public:

    const wxString& GetCharacterStyleName() const { return m_characterStyleName; }
    const wxString& GetParagraphStyleName() const { return m_paragraphStyleName; }
-    const wxString& GetListStyleName() const { return m_listStyleName; }
    int GetParagraphSpacingAfter() const { return m_paragraphSpacingAfter; }
    int GetParagraphSpacingBefore() const { return m_paragraphSpacingBefore; }
    int GetLineSpacing() const { return m_lineSpacing; }
@@ -330,7 +315,6 @@ public:
    bool HasLineSpacing() const { return HasFlag(wxTEXT_ATTR_LINE_SPACING); }
    bool HasCharacterStyleName() const { return HasFlag(wxTEXT_ATTR_CHARACTER_STYLE_NAME) || !m_characterStyleName.IsEmpty(); }
    bool HasParagraphStyleName() const { return HasFlag(wxTEXT_ATTR_PARAGRAPH_STYLE_NAME) || !m_paragraphStyleName.IsEmpty(); }
-    bool HasListStyleName() const { return HasFlag(wxTEXT_ATTR_LIST_STYLE_NAME) || !m_listStyleName.IsEmpty(); }
    bool HasBulletStyle() const { return HasFlag(wxTEXT_ATTR_BULLET_STYLE); }
    bool HasBulletNumber() const { return HasFlag(wxTEXT_ATTR_BULLET_NUMBER); }
    bool HasBulletSymbol() const { return HasFlag(wxTEXT_ATTR_BULLET_SYMBOL); }
@@ -347,8 +331,7 @@ public:
        return !HasTextColour() && !HasBackgroundColour() && !HasFont() && !HasAlignment() &&
               !HasTabs() && !HasLeftIndent() && !HasRightIndent() &&
               !HasParagraphSpacingAfter() && !HasParagraphSpacingBefore() && !HasLineSpacing() &&
-               !HasCharacterStyleName() && !HasParagraphStyleName() && !HasListStyleName() &&
-               !HasBulletNumber() && !HasBulletStyle() && !HasBulletSymbol();
+               !HasCharacterStyleName() && !HasParagraphStyleName() && !HasBulletNumber() && !HasBulletStyle() && !HasBulletSymbol();
    }

    // return the attribute having the valid font and colours: it uses the
@@ -373,9 +356,6 @@ private:

    // Paragraph style
    wxString            m_paragraphStyleName;
-
-    // List style
-    wxString            m_listStyleName;
 };

 /*!
@@ -435,7 +415,6 @@ public:

    void SetCharacterStyleName(const wxString& name) { m_characterStyleName = name; m_flags |= wxTEXT_ATTR_CHARACTER_STYLE_NAME; }
    void SetParagraphStyleName(const wxString& name) { m_paragraphStyleName = name; m_flags |= wxTEXT_ATTR_PARAGRAPH_STYLE_NAME; }
-    void SetListStyleName(const wxString& name) { m_listStyleName = name; SetFlags(GetFlags() | wxTEXT_ATTR_LIST_STYLE_NAME); }
    void SetParagraphSpacingAfter(int spacing) { m_paragraphSpacingAfter = spacing; m_flags |= wxTEXT_ATTR_PARA_SPACING_AFTER; }
    void SetParagraphSpacingBefore(int spacing) { m_paragraphSpacingBefore = spacing; m_flags |= wxTEXT_ATTR_PARA_SPACING_BEFORE; }
    void SetLineSpacing(int spacing) { m_lineSpacing = spacing; m_flags |= wxTEXT_ATTR_LINE_SPACING; }
@@ -461,7 +440,6 @@ public:

    const wxString& GetCharacterStyleName() const { return m_characterStyleName; }
    const wxString& GetParagraphStyleName() const { return m_paragraphStyleName; }
-    const wxString& GetListStyleName() const { return m_listStyleName; }
    int GetParagraphSpacingAfter() const { return m_paragraphSpacingAfter; }
    int GetParagraphSpacingBefore() const { return m_paragraphSpacingBefore; }
    int GetLineSpacing() const { return m_lineSpacing; }
@@ -489,7 +467,6 @@ public:
    bool HasLineSpacing() const { return (m_flags & wxTEXT_ATTR_LINE_SPACING) != 0; }
    bool HasCharacterStyleName() const { return (m_flags & wxTEXT_ATTR_CHARACTER_STYLE_NAME) != 0 || !m_characterStyleName.IsEmpty(); }
    bool HasParagraphStyleName() const { return (m_flags & wxTEXT_ATTR_PARAGRAPH_STYLE_NAME) != 0 || !m_paragraphStyleName.IsEmpty(); }
-    bool HasListStyleName() const { return HasFlag(wxTEXT_ATTR_LIST_STYLE_NAME) || !m_listStyleName.IsEmpty(); }
    bool HasBulletStyle() const { return (m_flags & wxTEXT_ATTR_BULLET_STYLE) != 0; }
    bool HasBulletNumber() const { return (m_flags & wxTEXT_ATTR_BULLET_NUMBER) != 0; }
    bool HasBulletSymbol() const { return (m_flags & wxTEXT_ATTR_BULLET_SYMBOL) != 0; }
@@ -508,8 +485,7 @@ public:
        return !HasTextColour() && !HasBackgroundColour() && !HasFont() && !HasAlignment() &&
               !HasTabs() && !HasLeftIndent() && !HasRightIndent() &&
               !HasParagraphSpacingAfter() && !HasParagraphSpacingBefore() && !HasLineSpacing() &&
-               !HasCharacterStyleName() && !HasParagraphStyleName() && !HasListStyleName() &&
-               !HasBulletNumber() && !HasBulletStyle() && !HasBulletSymbol();
+               !HasCharacterStyleName() && !HasParagraphStyleName() && !HasBulletNumber() && !HasBulletStyle() && !HasBulletSymbol();
    }

    // return the attribute having the valid font and colours: it uses the
@@ -552,16 +528,13 @@ private:

    // Paragraph style
    wxString            m_paragraphStyleName;
-
-    // List style
-    wxString            m_listStyleName;
 };

 #define wxTEXT_ATTR_CHARACTER (wxTEXT_ATTR_FONT | wxTEXT_ATTR_BACKGROUND_COLOUR | wxTEXT_ATTR_TEXT_COLOUR | wxTEXT_ATTR_CHARACTER_STYLE_NAME)

 #define wxTEXT_ATTR_PARAGRAPH (wxTEXT_ATTR_ALIGNMENT|wxTEXT_ATTR_LEFT_INDENT|wxTEXT_ATTR_RIGHT_INDENT|wxTEXT_ATTR_TABS|\
    wxTEXT_ATTR_PARA_SPACING_BEFORE|wxTEXT_ATTR_PARA_SPACING_AFTER|wxTEXT_ATTR_LINE_SPACING|\
-    wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_BULLET_NUMBER|wxTEXT_ATTR_BULLET_SYMBOL|wxTEXT_ATTR_PARAGRAPH_STYLE_NAME|wxTEXT_ATTR_LIST_STYLE_NAME)
+    wxTEXT_ATTR_BULLET_STYLE|wxTEXT_ATTR_BULLET_NUMBER|wxTEXT_ATTR_BULLET_SYMBOL|wxTEXT_ATTR_PARAGRAPH_STYLE_NAME)

 #define wxTEXT_ATTR_ALL (wxTEXT_ATTR_CHARACTER|wxTEXT_ATTR_PARAGRAPH)

@@ -885,10 +858,6 @@ public:
    void SetPartialParagraph(bool partialPara) { m_partialParagraph = partialPara; }
    bool GetPartialParagraph() const { return m_partialParagraph; }

-    /// If this is a buffer, returns the current style sheet. The base layout box
-    /// class doesn't have an associated style sheet.
-    virtual wxRichTextStyleSheet* GetStyleSheet() const { return NULL; }
-
 // Operations

    /// Initialize the object.
@@ -984,27 +953,6 @@ public:
    /// content.
    bool CollectStyle(wxTextAttrEx& currentStyle, const wxTextAttrEx& style, long& multipleStyleAttributes);

-    /// Set list style
-    virtual bool SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
-    virtual bool SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
-
-    /// Clear list for given range
-    virtual bool ClearListStyle(const wxRichTextRange& range, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
-
-    /// Number/renumber any list elements in the given range.
-    /// def/defName can be NULL/empty to indicate that the existing list style should be used.
-    virtual bool NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
-    virtual bool NumberList(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
-
-    /// Promote the list items within the given range. promoteBy can be a positive or negative number, e.g. 1 or -1
-    /// def/defName can be NULL/empty to indicate that the existing list style should be used.
-    virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
-    virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
-
-    /// Helper for NumberList and PromoteList, that does renumbering and promotion simultaneously
-    /// def/defName can be NULL/empty to indicate that the existing list style should be used.
-    virtual bool DoNumberList(const wxRichTextRange& range, const wxRichTextRange& promotionRange, int promoteBy, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
-
    /// Test if this whole range has character attributes of the specified kind. If any
    /// of the attributes are different within the range, the test fails. You
    /// can use this to implement, for example, bold button updating. style must have
@@ -1257,21 +1205,9 @@ public:
    /// Get combined attributes of the base style and paragraph style.
    wxTextAttrEx GetCombinedAttributes() const;

-    /// Create default tabstop array
-    static void InitDefaultTabs();
-
-    /// Clear default tabstop array
-    static void ClearDefaultTabs();
-
-    /// Get default tabstop array
-    static const wxArrayInt& GetDefaultTabs() { return sm_defaultTabs; }
-
 protected:
    /// The lines that make up the wrapped paragraph
    wxRichTextLineList m_cachedLines;
-
-    /// Default tabstops
-    static wxArrayInt  sm_defaultTabs;
 };

 /*!
@@ -1517,13 +1453,7 @@ public:

    /// Set style sheet, if any.
    void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { m_styleSheet = styleSheet; }
-    virtual wxRichTextStyleSheet* GetStyleSheet() const { return m_styleSheet; }
-
-    /// Push style sheet to top of stack
-    bool PushStyleSheet(wxRichTextStyleSheet* styleSheet);
-
-    /// Pop style sheet from top of stack
-    wxRichTextStyleSheet* PopStyleSheet();
+    wxRichTextStyleSheet* GetStyleSheet() const { return m_styleSheet; }

 // Operations

@@ -2073,9 +2003,6 @@ void wxSetFontPreservingStyles(wxTextAttr& attr, const wxFont& font);
 /// Convert a decimal to Roman numerals
 wxString wxRichTextDecimalToRoman(long n);

-
-WXDLLIMPEXP_RICHTEXT void wxRichTextModuleInit();
-
 #endif
    // wxUSE_RICHTEXT

--- a/include/wx/richtext/richtextctrl.h
+++ b/include/wx/richtext/richtextctrl.h
@@ -196,23 +196,6 @@ public:
    virtual const wxTextAttrEx& GetDefaultStyleEx() const;
    virtual const wxTextAttr& GetDefaultStyle() const;

-    /// Set list style
-    virtual bool SetListStyle(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
-    virtual bool SetListStyle(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
-
-    /// Clear list for given range
-    virtual bool ClearListStyle(const wxRichTextRange& range, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO);
-
-    /// Number/renumber any list elements in the given range
-    /// def/defName can be NULL/empty to indicate that the existing list style should be used.
-    virtual bool NumberList(const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
-    virtual bool NumberList(const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int startFrom = 1, int specifiedLevel = -1);
-
-    /// Promote the list items within the given range. promoteBy can be a positive or negative number, e.g. 1 or -1
-    /// def/defName can be NULL/empty to indicate that the existing list style should be used.
-    virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, wxRichTextListStyleDefinition* def, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
-    virtual bool PromoteList(int promoteBy, const wxRichTextRange& range, const wxString& defName, int flags = wxRICHTEXT_SETSTYLE_WITH_UNDO, int specifiedLevel = -1);
-
    // translate between the position (which is just an index in the text ctrl
    // considering all its contents as a single strings) and (x, y) coordinates
    // which represent column and line.
@@ -547,16 +530,10 @@ public:
    /// Apply a named style to the selection
    virtual bool ApplyStyle(wxRichTextStyleDefinition* def);

-    /// Set style sheet, if any
+    /// Set style sheet, if any.
    void SetStyleSheet(wxRichTextStyleSheet* styleSheet) { GetBuffer().SetStyleSheet(styleSheet); }
    wxRichTextStyleSheet* GetStyleSheet() const { return GetBuffer().GetStyleSheet(); }

-    /// Push style sheet to top of stack
-    bool PushStyleSheet(wxRichTextStyleSheet* styleSheet) { return GetBuffer().PushStyleSheet(styleSheet); }
-
-    /// Pop style sheet from top of stack
-    wxRichTextStyleSheet* PopStyleSheet() { return GetBuffer().PopStyleSheet(); }
-
    /// Apply the style sheet to the buffer, for example if the styles have changed.
    bool ApplyStyleSheet(wxRichTextStyleSheet* styleSheet = NULL);

--- a/include/wx/richtext/richtexthtml.h
+++ b/include/wx/richtext/richtexthtml.h
@@ -1,5 +1,5 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/richtext/richtexthtml.h
+// Name:        wx/richtext/richedithtml.h
 // Purpose:     HTML I/O for wxRichTextCtrl
 // Author:      Julian Smart
 // Modified by:
@@ -49,54 +49,54 @@ protected:
    /// Output character formatting
    virtual void BeginCharacterFormatting(const wxTextAttrEx& currentStyle, const wxTextAttrEx& thisStyle, const wxTextAttrEx& paraStyle, wxOutputStream& stream );
    virtual void EndCharacterFormatting(const wxTextAttrEx& WXUNUSED(currentStyle), const wxTextAttrEx& thisStyle, const wxTextAttrEx& paraStyle, wxOutputStream& stream );
-
-    /// Output paragraph formatting
+	
+	/// Output paragraph formatting
    virtual void OutputParagraphFormatting(const wxTextAttrEx& WXUNUSED(currentStyle), const wxTextAttrEx& thisStyle, wxOutputStream& stream/*, bool start*/);
-
-    /// Converts an image to its base64 equivalent
-    void Image_to_Base64(wxRichTextImage* image, wxOutputStream& stream);
-
-    /// Builds required indentation
-    void Indent( const wxTextAttrEx& thisStyle, wxTextOutputStream& str );
-
-    /// Left indent
-    void LIndent( const wxTextAttrEx& thisStyle, wxTextOutputStream& str );
-
-    /// Converts from pt to size property compatible height
-    long Pt_To_Size(long size);
-
-    /// Typical base64 encoder
-    wxChar* b64enc( unsigned char* input, size_t in_len );
-
-    /// Gets the mime type of the given wxBITMAP_TYPE
+	
+	/// Converts an image to its base64 equivalent
+	void Image_to_Base64(wxRichTextImage* image, wxOutputStream& stream);
+	
+	/// Builds required indentation 
+	void Indent( const wxTextAttrEx& thisStyle, wxTextOutputStream& str );
+	
+	/// Left indent
+	void LIndent( const wxTextAttrEx& thisStyle, wxTextOutputStream& str );
+	
+	/// Converts from pt to size property compatible height
+	long Pt_To_Size(long size);
+	
+	/// Typical base64 encoder
+	wxChar* b64enc( unsigned char* input, size_t in_len );
+	
+	/// Gets the mime type of the given wxBITMAP_TYPE
    const wxChar* GetMimeType(int imageType);
+	
+	/// Gets the html equivalent of the specified value
+	wxString GetAlignment( const wxTextAttrEx& thisStyle );

-    /// Gets the html equivalent of the specified value
-    wxString GetAlignment( const wxTextAttrEx& thisStyle );
+	/// Generates &nbsp; array for indentations
+	wxString SymbolicIndent(long indent);
+	
+	/// Finds the html equivalent of the specified bullet
+	void TypeOfList( const wxTextAttrEx& thisStyle, wxString& tag );
+	
+	/// Closes existings or Opens new tables for navigation to an item's horizontal position.
+	void NavigateToListPosition( const wxTextAttrEx& thisStyle, wxTextOutputStream& str );
+	
+	/// Indentation values of the table tags
+	wxArrayInt m_indents;
+	
+	/// Horizontal position of the current table
+	long m_indent;

-    /// Generates &nbsp; array for indentations
-    wxString SymbolicIndent(long indent);
+	/// Is there any opened font tag 
+	bool m_font;

-    /// Finds the html equivalent of the specified bullet
-    void TypeOfList( const wxTextAttrEx& thisStyle, wxString& tag );
+	/// Is there any opened ul/ol tag
+	bool m_list;

-    /// Closes existings or Opens new tables for navigation to an item's horizontal position.
-    void NavigateToListPosition( const wxTextAttrEx& thisStyle, wxTextOutputStream& str );
-
-    /// Indentation values of the table tags
-    wxArrayInt m_indents;
-
-    /// Horizontal position of the current table
-    long m_indent;
-
-    /// Is there any opened font tag
-    bool m_font;
-
-    /// Is there any opened ul/ol tag
-    bool m_list;
-
-    /// type of list, ul or ol?
-    bool m_is_ul;
+	/// type of list, ul or ol?
+	bool m_is_ul;

 };

--- a/include/wx/richtext/richtextstyles.h
+++ b/include/wx/richtext/richtextstyles.h
@@ -30,8 +30,6 @@
 #include "wx/combo.h"
 #endif

-#include "wx/choice.h"
-
 /*!
 * Forward declarations
 */
@@ -49,47 +47,32 @@ class WXDLLIMPEXP_RICHTEXT wxRichTextStyleDefinition: public wxObject
    DECLARE_CLASS(wxRichTextStyleDefinition)
 public:

-    /// Copy constructors
+// Constructors
+
    wxRichTextStyleDefinition(const wxRichTextStyleDefinition& def)
    : wxObject()
    {
-        Init();
        Copy(def);
    }
-
-    /// Default constructor
    wxRichTextStyleDefinition(const wxString& name = wxEmptyString) { Init(); m_name = name; }
-
-    /// Destructor
    virtual ~wxRichTextStyleDefinition() {}

-    /// Initialises members
    void Init() {}
-
-    /// Copies from def
    void Copy(const wxRichTextStyleDefinition& def);
-
-    /// Equality test
    bool Eq(const wxRichTextStyleDefinition& def) const;
-
-    /// Assignment operator
    void operator =(const wxRichTextStyleDefinition& def) { Copy(def); }
-
-    /// Equality operator
    bool operator ==(const wxRichTextStyleDefinition& def) const { return Eq(def); }
-
-    /// Override to clone the object
    virtual wxRichTextStyleDefinition* Clone() const = 0;

-    /// Sets and gets the name of the style
+    /// The name of the style.
    void SetName(const wxString& name) { m_name = name; }
    const wxString& GetName() const { return m_name; }

-    /// Sets and gets the name of the style that this style is based on
+    /// The name of the style that this style is based on.
    void SetBaseStyle(const wxString& name) { m_baseStyle = name; }
    const wxString& GetBaseStyle() const { return m_baseStyle; }

-    /// Sets the style
+    /// The style.
    void SetStyle(const wxRichTextAttr& style) { m_style = style; }
    const wxRichTextAttr& GetStyle() const { return m_style; }
    wxRichTextAttr& GetStyle() { return m_style; }
@@ -109,17 +92,13 @@ class WXDLLIMPEXP_RICHTEXT wxRichTextCharacterStyleDefinition: public wxRichText
    DECLARE_DYNAMIC_CLASS(wxRichTextCharacterStyleDefinition)
 public:

-    /// Copy constructor
-    wxRichTextCharacterStyleDefinition(const wxRichTextCharacterStyleDefinition& def): wxRichTextStyleDefinition(def) {}
+// Constructors

-    /// Default constructor
+    wxRichTextCharacterStyleDefinition(const wxRichTextCharacterStyleDefinition& def): wxRichTextStyleDefinition(def) {}
    wxRichTextCharacterStyleDefinition(const wxString& name = wxEmptyString):
        wxRichTextStyleDefinition(name) {}
-
-    /// Destructor
    virtual ~wxRichTextCharacterStyleDefinition() {}

-    /// Clones the object
    virtual wxRichTextStyleDefinition* Clone() const { return new wxRichTextCharacterStyleDefinition(*this); }

 protected:
@@ -134,30 +113,21 @@ class WXDLLIMPEXP_RICHTEXT wxRichTextParagraphStyleDefinition: public wxRichText
    DECLARE_DYNAMIC_CLASS(wxRichTextParagraphStyleDefinition)
 public:

-    /// Copy constructor
-    wxRichTextParagraphStyleDefinition(const wxRichTextParagraphStyleDefinition& def): wxRichTextStyleDefinition(def) { m_nextStyle = def.m_nextStyle; }
+// Constructors

-    /// Default constructor
+    wxRichTextParagraphStyleDefinition(const wxRichTextParagraphStyleDefinition& def): wxRichTextStyleDefinition(def) { m_nextStyle = def.m_nextStyle; }
    wxRichTextParagraphStyleDefinition(const wxString& name = wxEmptyString):
        wxRichTextStyleDefinition(name) {}
-
-    // Destructor
    virtual ~wxRichTextParagraphStyleDefinition() {}

-    /// Sets and gets the next style
+    /// The next style.
    void SetNextStyle(const wxString& name) { m_nextStyle = name; }
    const wxString& GetNextStyle() const { return m_nextStyle; }

-    /// Copies from def
    void Copy(const wxRichTextParagraphStyleDefinition& def);
-
-    /// Assignment operator
    void operator =(const wxRichTextParagraphStyleDefinition& def) { Copy(def); }
-
-    /// Equality operator
    bool operator ==(const wxRichTextParagraphStyleDefinition& def) const;

-    /// Clones the object
    virtual wxRichTextStyleDefinition* Clone() const { return new wxRichTextParagraphStyleDefinition(*this); }

 protected:
@@ -166,72 +136,6 @@ protected:
    wxString    m_nextStyle;
 };

-/*!
- * wxRichTextListStyleDefinition class declaration
- */
-
-class WXDLLIMPEXP_RICHTEXT wxRichTextListStyleDefinition: public wxRichTextParagraphStyleDefinition
-{
-    DECLARE_DYNAMIC_CLASS(wxRichTextListStyleDefinition)
-public:
-
-    /// Copy constructor
-    wxRichTextListStyleDefinition(const wxRichTextListStyleDefinition& def): wxRichTextParagraphStyleDefinition(def) { Init(); Copy(def); }
-
-    /// Default constructor
-    wxRichTextListStyleDefinition(const wxString& name = wxEmptyString):
-        wxRichTextParagraphStyleDefinition(name) { Init(); }
-
-    /// Destructor
-    virtual ~wxRichTextListStyleDefinition() {}
-
-    /// Copies from def
-    void Copy(const wxRichTextListStyleDefinition& def);
-
-    /// Assignment operator
-    void operator =(const wxRichTextListStyleDefinition& def) { Copy(def); }
-
-    /// Equality operator
-    bool operator ==(const wxRichTextListStyleDefinition& def) const;
-
-    /// Clones the object
-    virtual wxRichTextStyleDefinition* Clone() const { return new wxRichTextListStyleDefinition(*this); }
-
-    /// Sets/gets the attributes for the given level
-    void SetLevelAttributes(int i, const wxTextAttrEx& attr);
-    wxTextAttrEx* GetLevelAttributes(int i);
-    const wxTextAttrEx* GetLevelAttributes(int i) const;
-
-    /// Convenience function for setting the major attributes for a list level specification
-    void SetAttributes(int i, int leftIndent, int leftSubIndent, int bulletStyle, const wxString& bulletSymbol = wxEmptyString);
-
-    /// Finds the level corresponding to the given indentation
-    int FindLevelForIndent(int indent) const;
-
-    /// Combine the base and list style with a paragraph style, using the given indent (from which
-    /// an appropriate level is found)
-    wxTextAttrEx CombineWithParagraphStyle(int indent, const wxTextAttrEx& paraStyle);
-
-    /// Combine the base and list style, using the given indent (from which
-    /// an appropriate level is found)
-    wxTextAttrEx GetCombinedStyle(int indent);
-
-    /// Combine the base and list style, using the given level from which
-    /// an appropriate level is found)
-    wxTextAttrEx GetCombinedStyleForLevel(int level);
-
-    /// Gets the number of available levels
-    int GetLevelCount() const { return 10; }
-
-    /// Is this a numbered list?
-    bool IsNumbered(int i) const;
-
-protected:
-
-    /// The styles for each level (up to 10)
-    wxTextAttrEx m_levelStyles[10];
-};
-
 /*!
 * The style sheet
 */
@@ -248,7 +152,7 @@ public:
        Copy(sheet);
    }
    wxRichTextStyleSheet() { Init(); }
-    virtual ~wxRichTextStyleSheet();
+    virtual ~wxRichTextStyleSheet() { DeleteStyles(); }

    /// Initialisation
    void Init();
@@ -268,65 +172,33 @@ public:
    /// Add a definition to the paragraph style list
    bool AddParagraphStyle(wxRichTextParagraphStyleDefinition* def);

-    /// Add a definition to the list style list
-    bool AddListStyle(wxRichTextListStyleDefinition* def);
-
    /// Remove a character style
    bool RemoveCharacterStyle(wxRichTextStyleDefinition* def, bool deleteStyle = false) { return RemoveStyle(m_characterStyleDefinitions, def, deleteStyle); }

    /// Remove a paragraph style
    bool RemoveParagraphStyle(wxRichTextStyleDefinition* def, bool deleteStyle = false) { return RemoveStyle(m_paragraphStyleDefinitions, def, deleteStyle); }

-    /// Remove a list style
-    bool RemoveListStyle(wxRichTextStyleDefinition* def, bool deleteStyle = false) { return RemoveStyle(m_listStyleDefinitions, def, deleteStyle); }
-
    /// Find a character definition by name
-    wxRichTextCharacterStyleDefinition* FindCharacterStyle(const wxString& name, bool recurse = true) const { return (wxRichTextCharacterStyleDefinition*) FindStyle(m_characterStyleDefinitions, name, recurse); }
+    wxRichTextCharacterStyleDefinition* FindCharacterStyle(const wxString& name) const { return (wxRichTextCharacterStyleDefinition*) FindStyle(m_characterStyleDefinitions, name); }

    /// Find a paragraph definition by name
-    wxRichTextParagraphStyleDefinition* FindParagraphStyle(const wxString& name, bool recurse = true) const { return (wxRichTextParagraphStyleDefinition*) FindStyle(m_paragraphStyleDefinitions, name, recurse); }
+    wxRichTextParagraphStyleDefinition* FindParagraphStyle(const wxString& name) const { return (wxRichTextParagraphStyleDefinition*) FindStyle(m_paragraphStyleDefinitions, name); }

-    /// Find a list definition by name
-    wxRichTextListStyleDefinition* FindListStyle(const wxString& name, bool recurse = true) const { return (wxRichTextListStyleDefinition*) FindStyle(m_listStyleDefinitions, name, recurse); }
-
-    /// Return the number of character styles
+    /// Return the number of character styes.
    size_t GetCharacterStyleCount() const { return m_characterStyleDefinitions.GetCount(); }

-    /// Return the number of paragraph styles
+    /// Return the number of paragraph styes.
    size_t GetParagraphStyleCount() const { return m_paragraphStyleDefinitions.GetCount(); }

-    /// Return the number of list styles
-    size_t GetListStyleCount() const { return m_listStyleDefinitions.GetCount(); }
-
    /// Return the nth character style
    wxRichTextCharacterStyleDefinition* GetCharacterStyle(size_t n) const { return (wxRichTextCharacterStyleDefinition*) m_characterStyleDefinitions.Item(n)->GetData(); }

    /// Return the nth paragraph style
    wxRichTextParagraphStyleDefinition* GetParagraphStyle(size_t n) const { return (wxRichTextParagraphStyleDefinition*) m_paragraphStyleDefinitions.Item(n)->GetData(); }

-    /// Return the nth list style
-    wxRichTextListStyleDefinition* GetListStyle(size_t n) const { return (wxRichTextListStyleDefinition*) m_listStyleDefinitions.Item(n)->GetData(); }
-
    /// Delete all styles
    void DeleteStyles();

-    /// Insert into list of style sheets
-    bool InsertSheet(wxRichTextStyleSheet* before);
-
-    /// Append to list of style sheets
-    bool AppendSheet(wxRichTextStyleSheet* after);
-
-    /// Unlink from the list of style sheets
-    void Unlink();
-
-    /// Get/set next sheet
-    wxRichTextStyleSheet* GetNextSheet() const { return m_nextSheet; }
-    void SetNextSheet(wxRichTextStyleSheet* sheet) { m_nextSheet = sheet; }
-
-    /// Get/set previous sheet
-    wxRichTextStyleSheet* GetPreviousSheet() const { return m_previousSheet; }
-    void SetPreviousSheet(wxRichTextStyleSheet* sheet) { m_previousSheet = sheet; }
-
 /// Implementation

    /// Add a definition to one of the style lists
@@ -336,16 +208,12 @@ public:
    bool RemoveStyle(wxList& list, wxRichTextStyleDefinition* def, bool deleteStyle);

    /// Find a definition by name
-    wxRichTextStyleDefinition* FindStyle(const wxList& list, const wxString& name, bool recurse = true) const;
+    wxRichTextStyleDefinition* FindStyle(const wxList& list, const wxString& name) const;

 protected:

    wxList  m_characterStyleDefinitions;
    wxList  m_paragraphStyleDefinitions;
-    wxList  m_listStyleDefinitions;
-
-    wxRichTextStyleSheet* m_previousSheet;
-    wxRichTextStyleSheet* m_nextSheet;
 };

 #if wxUSE_HTML
@@ -360,15 +228,6 @@ class WXDLLIMPEXP_RICHTEXT wxRichTextStyleListBox: public wxHtmlListBox
    DECLARE_EVENT_TABLE()

 public:
-    /// Which type of style definition is currently showing?
-    enum wxRichTextStyleType
-    {
-        wxRICHTEXT_STYLE_ALL,
-        wxRICHTEXT_STYLE_PARAGRAPH,
-        wxRICHTEXT_STYLE_CHARACTER,
-        wxRICHTEXT_STYLE_LIST
-    };
-
    wxRichTextStyleListBox()
    {
        Init();
@@ -381,8 +240,7 @@ public:
    {
        m_styleSheet = NULL;
        m_richTextCtrl = NULL;
-        m_applyOnSelection = false;
-        m_styleType = wxRICHTEXT_STYLE_PARAGRAPH;
+        m_applyOnSelection = true;
    }

    bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition,
@@ -420,12 +278,14 @@ public:
    /// Left click
    void OnLeftDown(wxMouseEvent& event);

-    /// Left double-click
-    void OnLeftDoubleClick(wxMouseEvent& event);
-
    /// Auto-select from style under caret in idle time
    void OnIdle(wxIdleEvent& event);

+#if 0
+    virtual wxColour GetSelectedTextColour(const wxColour& colFg) const;
+    virtual wxColour GetSelectedTextBgColour(const wxColour& colBg) const;
+#endif
+
    /// Convert units in tends of a millimetre to device units
    int ConvertTenthsMMToPixels(wxDC& dc, int units) const;

@@ -437,13 +297,6 @@ public:
    void SetApplyOnSelection(bool applyOnSel) { m_applyOnSelection = applyOnSel; }
    bool GetApplyOnSelection() const { return m_applyOnSelection; }

-    /// Set the style type to display
-    void SetStyleType(wxRichTextStyleType styleType) { m_styleType = styleType; UpdateStyles(); }
-    wxRichTextStyleType GetStyleType() const { return m_styleType; }
-
-    /// Helper for listbox and combo control
-    static wxString GetStyleToShowInIdleTime(wxRichTextCtrl* ctrl, wxRichTextStyleType styleType);
-
 protected:
    /// Returns the HTML for this item
    virtual wxString OnGetItem(size_t n) const;
@@ -453,84 +306,6 @@ private:
    wxRichTextStyleSheet*   m_styleSheet;
    wxRichTextCtrl*         m_richTextCtrl;
    bool                    m_applyOnSelection; // if true, applies style on selection
-    wxRichTextStyleType     m_styleType; // style type to display
-};
-
-/*!
- * wxRichTextStyleListCtrl class declaration
- * This is a container for the list control plus a combobox to switch between
- * style types.
- */
-
-class WXDLLIMPEXP_RICHTEXT wxRichTextStyleListCtrl: public wxControl
-{
-    DECLARE_CLASS(wxRichTextStyleListCtrl)
-    DECLARE_EVENT_TABLE()
-
-public:
-
-    /// Constructors
-    wxRichTextStyleListCtrl()
-    {
-        Init();
-    }
-
-    wxRichTextStyleListCtrl(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition,
-        const wxSize& size = wxDefaultSize, long style = 0);
-
-    /// Constructors
-    virtual ~wxRichTextStyleListCtrl();
-
-    /// Member initialisation
-    void Init()
-    {
-        m_styleListBox = NULL;
-        m_styleChoice = NULL;
-        m_dontUpdate = false;
-    }
-
-    /// Creates the windows
-    bool Create(wxWindow* parent, wxWindowID id = wxID_ANY, const wxPoint& pos = wxDefaultPosition,
-        const wxSize& size = wxDefaultSize, long style = 0);
-
-    /// Associates the control with a style manager
-    void SetStyleSheet(wxRichTextStyleSheet* styleSheet);
-    wxRichTextStyleSheet* GetStyleSheet() const;
-
-    /// Associates the control with a wxRichTextCtrl
-    void SetRichTextCtrl(wxRichTextCtrl* ctrl);
-    wxRichTextCtrl* GetRichTextCtrl() const;
-
-    /// Updates the style list box
-    void UpdateStyles();
-
-    /// Set/get the style type to display
-    void SetStyleType(wxRichTextStyleListBox::wxRichTextStyleType styleType);
-    wxRichTextStyleListBox::wxRichTextStyleType GetStyleType() const;
-
-    /// Get the choice index for style type
-    int StyleTypeToIndex(wxRichTextStyleListBox::wxRichTextStyleType styleType);
-
-    /// Get the style type for choice index
-    wxRichTextStyleListBox::wxRichTextStyleType StyleIndexToType(int i);
-
-    /// Get the listbox
-    wxRichTextStyleListBox* GetStyleListBox() const { return m_styleListBox; }
-
-    /// Get the choice
-    wxChoice* GetStyleChoice() const { return m_styleChoice; }
-
-    /// React to style type choice
-    void OnChooseType(wxCommandEvent& event);
-
-    /// Lay out the controls
-    void OnSize(wxSizeEvent& event);
-
-private:
-
-    wxRichTextStyleListBox* m_styleListBox;
-    wxChoice*               m_styleChoice;
-    bool                    m_dontUpdate;
 };

 #if wxUSE_COMBOCTRL
--- a/include/wx/unix/joystick.h
+++ b/include/wx/unix/joystick.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/unix/joystick.h
+// Name:        joystick.h
 // Purpose:     wxJoystick class
 // Author:      Guilhem Lavaux
 // Modified by:
 // Created:     01/02/97
 // RCS-ID:      $Id$
 // Copyright:   (c) Guilhem Lavaux
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef __JOYSTICKH__
@@ -92,4 +92,5 @@ protected:
 };

 #endif
-    // __JOYSTICKH__
+// __JOYSTICKH__
+
--- a/include/wx/unix/sound.h
+++ b/include/wx/unix/sound.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/unix/sound.h
+// Name:        sound.h
 // Purpose:     wxSound class
 // Author:      Julian Smart, Vaclav Slavik
 // Modified by:
 // Created:     25/10/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart, Vaclav Slavik
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_SOUND_H_
@@ -33,7 +33,7 @@ public:
    wxSoundData() : m_refCnt(1) {}
    void IncRef();
    void DecRef();
-
+    
    // .wav header information:
    unsigned m_channels;       // num of channels (mono:1, stereo:2)
    unsigned m_samplingRate;
@@ -41,7 +41,7 @@ public:
                               // samples (wxUint8), if 16 then signed 16bit
                               // (wxInt16)
    unsigned m_samples;        // length in samples:
-
+    
    // wave data:
    size_t   m_dataBytes;
    wxUint8 *m_data;           // m_dataBytes bytes of data
@@ -69,23 +69,23 @@ public:
    bool Create(int size, const wxByte* data);

    bool IsOk() const { return m_data != NULL; }
-
+   
    // Stop playing any sound
    static void Stop();

    // Returns true if a sound is being played
    static bool IsPlaying();
-
+    
    // for internal use
    static void UnloadBackend();
-
+    
 protected:
    bool DoPlay(unsigned flags) const;

    static void EnsureBackend();
    void Free();
    bool LoadWAV(const wxUint8 *data, size_t length, bool copyData);
-
+    
    static wxSoundBackend *ms_backend;
 #if wxUSE_LIBSDL && wxUSE_PLUGINS
    // FIXME - temporary, until we have plugins architecture
@@ -98,7 +98,7 @@ private:


 // ----------------------------------------------------------------------------
-// wxSoundBackend:
+// wxSoundBackend: 
 // ----------------------------------------------------------------------------

 // This is interface to sound playing implementation. There are multiple
@@ -121,7 +121,7 @@ class WXDLLIMPEXP_ADV wxSoundBackend
 {
 public:
    virtual ~wxSoundBackend() {}
-
+    
    // Returns the name of the backend (e.g. "Open Sound System")
    virtual wxString GetName() const = 0;

@@ -137,7 +137,7 @@ public:
    // playback, otherwise it is left up to the backend (will usually be more
    // effective).
    virtual bool HasNativeAsyncPlayback() const = 0;
-
+    
    // Plays the sound. flags are same flags as those passed to wxSound::Play.
    // The function should periodically check the value of
    // status->m_stopRequested and terminate if it is set to true (it may
@@ -158,4 +158,3 @@ public:
 #endif // wxUSE_SOUND

 #endif
-    // _WX_SOUND_H_
--- a/include/wx/version.h
+++ b/include/wx/version.h
@@ -29,7 +29,7 @@
 #define wxMAJOR_VERSION      2
 #define wxMINOR_VERSION      7
 #define wxRELEASE_NUMBER     1
-#define wxSUBRELEASE_NUMBER  1
+#define wxSUBRELEASE_NUMBER  0
 #define wxVERSION_STRING   _T("wxWidgets 2.7.1")

 /*  nothing to update below this line when updating the version */
--- a/include/wx/x11/cursor.h
+++ b/include/wx/x11/cursor.h
@@ -1,12 +1,12 @@
 /////////////////////////////////////////////////////////////////////////////
-// Name:        wx/x11/cursor.h
+// Name:        cursor.h
 // Purpose:     wxCursor class
 // Author:      Julian Smart
 // Modified by:
 // Created:     17/09/98
 // RCS-ID:      $Id$
 // Copyright:   (c) Julian Smart
-// Licence:     wxWindows licence
+// Licence:   	wxWindows licence
 /////////////////////////////////////////////////////////////////////////////

 #ifndef _WX_CURSOR_H_
@@ -50,4 +50,4 @@ private:


 #endif
-    // _WX_CURSOR_H_
+// _WX_CURSOR_H_
--- a/include/wx/x11/dcmemory.h
+++ b/include/wx/x11/dcmemory.h
@@ -17,7 +17,7 @@
 class WXDLLIMPEXP_CORE wxMemoryDC : public wxWindowDC
 {
 public:
-    wxMemoryDC( const wxBitmap& bitmap = wxNullBitmap );
+    wxMemoryDC();
    wxMemoryDC( wxDC *dc ); // Create compatible DC
    virtual ~wxMemoryDC();
    virtual void SelectObject( const wxBitmap& bitmap );
--- a/Show More
+++ b/Show More