reSWIGged

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

wxPython/src/gtk/_gdi.py

@@ -406,6 +406,18 @@ class Brush(GDIObject):
     A brush is a drawing tool for filling in areas. It is used for
     painting the background of rectangles, ellipses, etc. when drawing on
     a `wx.DC`.  It has a colour and a style.
+
+    :warning: Do not create instances of wx.Brush before the `wx.App`
+        object has been created because, depending on the platform,
+        required internal data structures may not have been initialized
+        yet.  Instead create your brushes in the app's OnInit or as they
+        are needed for drawing.
+
+    :note: On monochrome displays all brushes are white, unless the colour
+        really is black.
+
+    :see: `wx.BrushList`, `wx.DC`, `wx.DC.SetBrush`
+
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
@@ -413,7 +425,24 @@ class Brush(GDIObject):
         """
         __init__(self, Colour colour, int style=SOLID) -> Brush
 
-        Constructs a brush from a `wx.Colour` object and a style.
+        Constructs a brush from a `wx.Colour` object and a style.The style parameter may be one of the following:
+
+            ===================   =============================
+            Style                 Meaning
+            ===================   =============================
+            wx.TRANSPARENT        Transparent (no fill).
+            wx.SOLID              Solid.
+            wx.STIPPLE            Uses a bitmap as a stipple.
+            wx.BDIAGONAL_HATCH    Backward diagonal hatch.
+            wx.CROSSDIAG_HATCH    Cross-diagonal hatch.
+            wx.FDIAGONAL_HATCH    Forward diagonal hatch.
+            wx.CROSS_HATCH        Cross hatch.
+            wx.HORIZONTAL_HATCH   Horizontal hatch.
+            wx.VERTICAL_HATCH     Vertical hatch.
+            ===================   =============================
+
+        :see: `wx.BrushFromBitmap`
+
         """
         _gdi_.Brush_swiginit(self,_gdi_.new_Brush(*args, **kwargs))
     __swig_destroy__ = _gdi_.delete_Brush
@@ -509,6 +538,23 @@ class Bitmap(GDIObject):
     device context (instance of `wx.MemoryDC`). This enables the bitmap to
     be copied to a window or memory device context using `wx.DC.Blit`, or
     to be used as a drawing surface.
+
+    The BMP and XMP image file formats are supported on all platforms by
+    wx.Bitmap.  Other formats are automatically loaded by `wx.Image` and
+    converted to a wx.Bitmap, so any image file format supported by
+    `wx.Image` can be used.
+
+    :todo: Add wrappers and support for raw bitmap data access.  Can this
+           be be put into Python without losing the speed benefits of the
+           teplates and iterators in rawbmp.h?
+
+    :todo: Find a way to do very efficient PIL Image <--> wx.Bitmap
+           converstions.
+
+    :see: `wx.EmptyBitmap`, `wx.BitmapFromIcon`, `wx.BitmapFromImage`,
+          `wx.BitmapFromXPMData`, `wx.BitmapFromBits`, `wx.BitmapFromBuffer`,
+          `wx.BitmapFromBufferRGBA`, `wx.Image`
+
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
@@ -517,6 +563,32 @@ class Bitmap(GDIObject):
         __init__(self, String name, int type=BITMAP_TYPE_ANY) -> Bitmap
 
         Loads a bitmap from a file.
+            :param name:  Name of the file to load the bitmap from.
+            :param type: The type of image to expect.  Can be one of the following
+                constants (assuming that the neccessary `wx.Image` handlers are
+                loaded):
+
+                * wx.BITMAP_TYPE_ANY
+                * wx.BITMAP_TYPE_BMP
+                * wx.BITMAP_TYPE_ICO
+                * wx.BITMAP_TYPE_CUR
+                * wx.BITMAP_TYPE_XBM
+                * wx.BITMAP_TYPE_XPM
+                * wx.BITMAP_TYPE_TIF
+                * wx.BITMAP_TYPE_GIF
+                * wx.BITMAP_TYPE_PNG
+                * wx.BITMAP_TYPE_JPEG
+                * wx.BITMAP_TYPE_PNM
+                * wx.BITMAP_TYPE_PCX
+                * wx.BITMAP_TYPE_PICT
+                * wx.BITMAP_TYPE_ICON
+                * wx.BITMAP_TYPE_ANI
+                * wx.BITMAP_TYPE_IFF
+
+        :see: Alternate constructors `wx.EmptyBitmap`, `wx.BitmapFromIcon`,
+              `wx.BitmapFromImage`, `wx.BitmapFromXPMData`, `wx.BitmapFromBits`,
+              `wx.BitmapFromBuffer`, `wx.BitmapFromBufferRGBA`,
+
         """
         _gdi_.Bitmap_swiginit(self,_gdi_.new_Bitmap(*args, **kwargs))
     __swig_destroy__ = _gdi_.delete_Bitmap
@@ -1248,6 +1320,40 @@ class Cursor(GDIObject):
     in X, rather than to set it globally as in MS Windows, although a
     global `wx.SetCursor` function is also available for use on MS Windows.
 
+
+    Stock Cursor IDs
+    -----------------
+        ========================    ======================================
+        wx.CURSOR_ARROW             A standard arrow cursor.
+        wx.CURSOR_RIGHT_ARROW       A standard arrow cursor pointing to the right.
+        wx.CURSOR_BLANK             Transparent cursor.
+        wx.CURSOR_BULLSEYE          Bullseye cursor.
+        wx.CURSOR_CHAR              Rectangular character cursor.
+        wx.CURSOR_CROSS             A cross cursor.
+        wx.CURSOR_HAND              A hand cursor.
+        wx.CURSOR_IBEAM             An I-beam cursor (vertical line).
+        wx.CURSOR_LEFT_BUTTON       Represents a mouse with the left button depressed.
+        wx.CURSOR_MAGNIFIER         A magnifier icon.
+        wx.CURSOR_MIDDLE_BUTTON     Represents a mouse with the middle button depressed.
+        wx.CURSOR_NO_ENTRY          A no-entry sign cursor.
+        wx.CURSOR_PAINT_BRUSH       A paintbrush cursor.
+        wx.CURSOR_PENCIL            A pencil cursor.
+        wx.CURSOR_POINT_LEFT        A cursor that points left.
+        wx.CURSOR_POINT_RIGHT       A cursor that points right.
+        wx.CURSOR_QUESTION_ARROW    An arrow and question mark.
+        wx.CURSOR_RIGHT_BUTTON      Represents a mouse with the right button depressed.
+        wx.CURSOR_SIZENESW          A sizing cursor pointing NE-SW.
+        wx.CURSOR_SIZENS            A sizing cursor pointing N-S.
+        wx.CURSOR_SIZENWSE          A sizing cursor pointing NW-SE.
+        wx.CURSOR_SIZEWE            A sizing cursor pointing W-E.
+        wx.CURSOR_SIZING            A general sizing cursor.
+        wx.CURSOR_SPRAYCAN          A spraycan cursor.
+        wx.CURSOR_WAIT              A wait cursor.
+        wx.CURSOR_WATCH             A watch cursor.
+        wx.CURSOR_ARROWWAIT         A cursor with both an arrow and an hourglass, (windows.)
+        ========================    ======================================
+
+
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
@@ -1258,6 +1364,7 @@ class Cursor(GDIObject):
         Construct a Cursor from a file.  Specify the type of file using
         wx.BITAMP_TYPE* constants, and specify the hotspot if not using a .cur
         file.
+        :see: Alternate constructors `wx.StockCursor`,`wx.CursorFromImage`
         """
         _gdi_.Cursor_swiginit(self,_gdi_.new_Cursor(*args, **kwargs))
     __swig_destroy__ = _gdi_.delete_Cursor
@@ -1286,6 +1393,11 @@ def CursorFromImage(*args, **kwargs):
 
     Constructs a cursor from a `wx.Image`. The mask (if any) will be used
     for setting the transparent portions of the cursor.
+    In MSW the cursor is resized to 32x32 if it was larger.
+
+    In GTK the cursor will be displayed at the size of the image.
+
+    On MacOS the cursor is resized to 16x16 if it was larger.
     """
     val = _gdi_.new_CursorFromImage(*args, **kwargs)
     return val
@@ -1858,6 +1970,71 @@ class Font(GDIObject):
     of a window's text.
 
     You can retrieve the current system font settings with `wx.SystemSettings`.
+
+    The possible values for the family parameter of wx.Font constructor are:
+
+        ========================  =============================
+        wx.FONTFAMILY_DEFAULT     Chooses a default font.
+        wx.FONTFAMILY_DECORATIVE  A decorative font. 
+        wx.FONTFAMILY_ROMAN       A formal, serif font.
+        wx.FONTFAMILY_SCRIPT      A handwriting font. 
+        wx.FONTFAMILY_SWISS       A sans-serif font. 
+        wx.FONTFAMILY_MODERN      Usually a fixed pitch font.    
+        wx.FONTFAMILY_TELETYPE    A teletype font. 
+        ========================  =============================
+
+    The possible values for the weight parameter are:
+
+        ====================  ==
+        wx.FONTWEIGHT_NORMAL
+        wx.FONTWEIGHT_LIGHT
+        wx.FONTWEIGHT_BOLD
+        ====================  ==
+
+    The known font encodings are:
+
+        ===========================       ====================================
+        wx.FONTENCODING_SYSTEM            system default
+        wx.FONTENCODING_DEFAULT           current default encoding
+        wx.FONTENCODING_ISO8859_1         West European (Latin1)
+        wx.FONTENCODING_ISO8859_2         Central and East European (Latin2)
+        wx.FONTENCODING_ISO8859_3         Esperanto (Latin3)
+        wx.FONTENCODING_ISO8859_4         Baltic (old) (Latin4)
+        wx.FONTENCODING_ISO8859_5         Cyrillic
+        wx.FONTENCODING_ISO8859_6         Arabic
+        wx.FONTENCODING_ISO8859_7         Greek
+        wx.FONTENCODING_ISO8859_8         Hebrew
+        wx.FONTENCODING_ISO8859_9         Turkish (Latin5)
+        wx.FONTENCODING_ISO8859_10        Variation of Latin4 (Latin6)
+        wx.FONTENCODING_ISO8859_11        Thai
+        wx.FONTENCODING_ISO8859_12        doesn't exist currently, but put it
+                                          here anyhow to make all ISO8859
+                                          consecutive numbers
+        wx.FONTENCODING_ISO8859_13        Baltic (Latin7)
+        wx.FONTENCODING_ISO8859_14        Latin8
+        wx.FONTENCODING_ISO8859_15        Latin9 (a.k.a. Latin0, includes euro)
+        wx.FONTENCODING_KOI8              Cyrillic charset
+        wx.FONTENCODING_ALTERNATIVE       same as MS-DOS CP866
+        wx.FONTENCODING_BULGARIAN         used under Linux in Bulgaria
+        wx.FONTENCODING_CP437             original MS-DOS codepage
+        wx.FONTENCODING_CP850             CP437 merged with Latin1
+        wx.FONTENCODING_CP852             CP437 merged with Latin2
+        wx.FONTENCODING_CP855             another cyrillic encoding
+        wx.FONTENCODING_CP866             and another one
+        wx.FONTENCODING_CP874             WinThai
+        wx.FONTENCODING_CP1250            WinLatin2
+        wx.FONTENCODING_CP1251            WinCyrillic
+        wx.FONTENCODING_CP1252            WinLatin1
+        wx.FONTENCODING_CP1253            WinGreek (8859-7)
+        wx.FONTENCODING_CP1254            WinTurkish
+        wx.FONTENCODING_CP1255            WinHebrew
+        wx.FONTENCODING_CP1256            WinArabic
+        wx.FONTENCODING_CP1257            WinBaltic (same as Latin 7)
+        wx.FONTENCODING_UTF7              UTF-7 Unicode encoding
+        wx.FONTENCODING_UTF8              UTF-8 Unicode encoding
+        ===========================       ====================================
+
+
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
@@ -3200,6 +3377,8 @@ class DC(_core.Object):
         Draws a circle with the given center point and radius.  The current
         pen is used for the outline and the current brush for filling the
         shape.
+
+        :see: `DrawEllipse`
         """
         return _gdi_.DC_DrawCircle(*args, **kwargs)
 
@@ -3210,6 +3389,8 @@ class DC(_core.Object):
         Draws a circle with the given center point and radius.  The current
         pen is used for the outline and the current brush for filling the
         shape.
+
+        :see: `DrawEllipse`
         """
         return _gdi_.DC_DrawCirclePoint(*args, **kwargs)
 
@@ -3219,6 +3400,8 @@ class DC(_core.Object):
 
         Draws an ellipse contained in the specified rectangle. The current pen
         is used for the outline and the current brush for filling the shape.
+
+        :see: `DrawCircle`
         """
         return _gdi_.DC_DrawEllipse(*args, **kwargs)
 
@@ -3228,6 +3411,8 @@ class DC(_core.Object):
 
         Draws an ellipse contained in the specified rectangle. The current pen
         is used for the outline and the current brush for filling the shape.
+
+        :see: `DrawCircle`
         """
         return _gdi_.DC_DrawEllipseRect(*args, **kwargs)
 
@@ -3237,6 +3422,8 @@ class DC(_core.Object):
 
         Draws an ellipse contained in the specified rectangle. The current pen
         is used for the outline and the current brush for filling the shape.
+
+        :see: `DrawCircle`
         """
         return _gdi_.DC_DrawEllipsePointSize(*args, **kwargs)
 
@@ -3268,6 +3455,13 @@ class DC(_core.Object):
         *transparent* is true and the bitmap has a transparency mask, (or
         alpha channel on the platforms that support it) then the bitmap will
         be drawn transparently.
+
+        When drawing a mono-bitmap, the current text foreground colour will be
+        used to draw the foreground of the bitmap (all bits set to 1), and the
+        current text background colour to draw the background (all bits set to
+        0).
+
+        :see: `SetTextForeground`, `SetTextBackground` and `wx.MemoryDC`
         """
         return _gdi_.DC_DrawBitmap(*args, **kwargs)
 
@@ -3279,6 +3473,13 @@ class DC(_core.Object):
         *transparent* is true and the bitmap has a transparency mask, (or
         alpha channel on the platforms that support it) then the bitmap will
         be drawn transparently.
+
+        When drawing a mono-bitmap, the current text foreground colour will be
+        used to draw the foreground of the bitmap (all bits set to 1), and the
+        current text background colour to draw the background (all bits set to
+        0).
+
+        :see: `SetTextForeground`, `SetTextBackground` and `wx.MemoryDC`
         """
         return _gdi_.DC_DrawBitmapPoint(*args, **kwargs)
 
@@ -3296,6 +3497,8 @@ class DC(_core.Object):
         **NOTE**: under wxGTK the current logical function is used by this
         function but it is ignored by wxMSW. Thus, you should avoid using
         logical functions with this function in portable programs.
+
+        :see: `DrawRotatedText`
         """
         return _gdi_.DC_DrawText(*args, **kwargs)
 
@@ -3313,6 +3516,8 @@ class DC(_core.Object):
         **NOTE**: under wxGTK the current logical function is used by this
         function but it is ignored by wxMSW. Thus, you should avoid using
         logical functions with this function in portable programs.
+
+        :see: `DrawRotatedText`
         """
         return _gdi_.DC_DrawTextPoint(*args, **kwargs)
 
@@ -3326,6 +3531,8 @@ class DC(_core.Object):
         function. In particular, a font different from ``wx.NORMAL_FONT``
         should be used as the it is not normally a TrueType
         font. ``wx.SWISS_FONT`` is an example of a font which is.
+
+        :see: `DrawText`
         """
         return _gdi_.DC_DrawRotatedText(*args, **kwargs)
 
@@ -3339,6 +3546,8 @@ class DC(_core.Object):
         function. In particular, a font different from ``wx.NORMAL_FONT``
         should be used as the it is not normally a TrueType
         font. ``wx.SWISS_FONT`` is an example of a font which is.
+
+        :see: `DrawText`
         """
         return _gdi_.DC_DrawRotatedTextPoint(*args, **kwargs)
 
@@ -3352,6 +3561,23 @@ class DC(_core.Object):
         coordinates, size of area to copy, source DC, source coordinates,
         logical function, whether to use a bitmap mask, and mask source
         position.
+
+            :param xdest:       Destination device context x position.
+            :param ydest:       Destination device context y position.
+            :param width:       Width of source area to be copied.
+            :param height:      Height of source area to be copied.
+            :param source:      Source device context.
+            :param xsrc:        Source device context x position.
+            :param ysrc:        Source device context y position.
+            :param rop:         Logical function to use: see `SetLogicalFunction`.
+            :param useMask:     If true, Blit does a transparent blit using the mask
+                                that is associated with the bitmap selected into the
+                                source device context.
+            :param xsrcMask:    Source x position on the mask. If both xsrcMask and
+                                ysrcMask are -1, xsrc and ysrc will be assumed for
+                                the mask source position.
+            :param ysrcMask:    Source y position on the mask. 
+
         """
         return _gdi_.DC_Blit(*args, **kwargs)
 
@@ -3364,6 +3590,17 @@ class DC(_core.Object):
         coordinates, size of area to copy, source DC, source coordinates,
         logical function, whether to use a bitmap mask, and mask source
         position.
+
+            :param destPt:      Destination device context position.
+            :param sz:          Size of source area to be copied.
+            :param source:      Source device context.
+            :param srcPt:       Source device context position.
+            :param rop:         Logical function to use: see `SetLogicalFunction`.
+            :param useMask:     If true, Blit does a transparent blit using the mask
+                                that is associated with the bitmap selected into the
+                                source device context.
+            :param srcPtMask:   Source position on the mask. 
+
         """
         return _gdi_.DC_BlitPointSize(*args, **kwargs)
 
@@ -3381,6 +3618,8 @@ class DC(_core.Object):
         restricted. Possible uses for the clipping region are for clipping
         text or for speeding up window redraws when only a known area of the
         screen is damaged.
+
+        :see: `DestroyClippingRegion`, `wx.Region`
         """
         return _gdi_.DC_SetClippingRegion(*args, **kwargs)
 
@@ -3398,6 +3637,8 @@ class DC(_core.Object):
         restricted. Possible uses for the clipping region are for clipping
         text or for speeding up window redraws when only a known area of the
         screen is damaged.
+
+        :see: `DestroyClippingRegion`, `wx.Region`
         """
         return _gdi_.DC_SetClippingRegionPointSize(*args, **kwargs)
 
@@ -3415,6 +3656,8 @@ class DC(_core.Object):
         restricted. Possible uses for the clipping region are for clipping
         text or for speeding up window redraws when only a known area of the
         screen is damaged.
+
+        :see: `DestroyClippingRegion`, `wx.Region`
         """
         return _gdi_.DC_SetClippingRegionAsRegion(*args, **kwargs)
 
@@ -3432,6 +3675,8 @@ class DC(_core.Object):
         restricted. Possible uses for the clipping region are for clipping
         text or for speeding up window redraws when only a known area of the
         screen is damaged.
+
+        :see: `DestroyClippingRegion`, `wx.Region`
         """
         return _gdi_.DC_SetClippingRect(*args, **kwargs)
 
@@ -3469,6 +3714,8 @@ class DC(_core.Object):
         Draw *text* within the specified rectangle, abiding by the alignment
         flags.  Will additionally emphasize the character at *indexAccel* if
         it is not -1.
+
+        :see: `DrawImageLabel`
         """
         return _gdi_.DC_DrawLabel(*args, **kwargs)
 
@@ -3541,6 +3788,8 @@ class DC(_core.Object):
 
         Sets the current font for the DC. It must be a valid font, in
         particular you should not pass ``wx.NullFont`` to this method.
+
+        :see: `wx.Font`
         """
         return _gdi_.DC_SetFont(*args, **kwargs)
 
@@ -3552,6 +3801,8 @@ class DC(_core.Object):
 
         If the argument is ``wx.NullPen``, the current pen is selected out of the
         device context, and the original pen restored.
+
+        :see: `wx.Pen`
         """
         return _gdi_.DC_SetPen(*args, **kwargs)
 
@@ -3564,6 +3815,8 @@ class DC(_core.Object):
         If the argument is ``wx.NullBrush``, the current brush is selected out
         of the device context, and the original brush restored, allowing the
         current brush to be destroyed safely.
+
+        :see: `wx.Brush`
         """
         return _gdi_.DC_SetBrush(*args, **kwargs)
 
@@ -3593,6 +3846,8 @@ class DC(_core.Object):
         window or bitmap associated with the DC. If the argument is
         ``wx.NullPalette``, the current palette is selected out of the device
         context, and the original palette restored.
+
+        :see: `wx.Palette`
         """
         return _gdi_.DC_SetPalette(*args, **kwargs)
 
@@ -3602,6 +3857,8 @@ class DC(_core.Object):
 
         Destroys the current clipping region so that none of the DC is
         clipped.
+
+        :see: `SetClippingRegion`
         """
         return _gdi_.DC_DestroyClippingRegion(*args, **kwargs)
 
@@ -3847,6 +4104,8 @@ class DC(_core.Object):
 
         Returns the current background mode, either ``wx.SOLID`` or
         ``wx.TRANSPARENT``.
+
+        :see: `SetBackgroundMode`
         """
         return _gdi_.DC_GetBackgroundMode(*args, **kwargs)
 
@@ -3855,6 +4114,8 @@ class DC(_core.Object):
         GetBackground(self) -> Brush
 
         Gets the brush used for painting the background.
+
+        :see: `SetBackground`
         """
         return _gdi_.DC_GetBackground(*args, **kwargs)
 
@@ -3939,6 +4200,18 @@ class DC(_core.Object):
             wx.MM_TEXT          Each logical unit is 1 pixel.
             ================    =============================================
 
+        Note that in X, text drawing isn't handled consistently with the
+        mapping mode; a font is always specified in point size. However,
+        setting the user scale (see `SetUserScale`) scales the text
+        appropriately. In Windows, scalable TrueType fonts are always used; in
+        X, results depend on availability of fonts, but usually a reasonable
+        match is found.
+
+        The coordinate origin is always at the top left of the screen/printer.
+
+        Drawing to a Windows printer device context uses the current mapping
+        mode, but mapping mode is currently ignored for PostScript output.
+
         """
         return _gdi_.DC_SetMapMode(*args, **kwargs)
 
@@ -4411,6 +4684,8 @@ class MemoryDC(DC):
         creating a usable device context. If a bitmap is not given to this
         constructor then don't forget to select a bitmap into the DC before
         drawing on it.
+
+        :see: `MemoryDCFromDC`
         """
         _gdi_.MemoryDC_swiginit(self,_gdi_.new_MemoryDC(*args, **kwargs))
     def SelectObject(*args, **kwargs):
@@ -4442,88 +4717,6 @@ def MemoryDCFromDC(*args, **kwargs):
 
 #---------------------------------------------------------------------------
 
-BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
-BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
-class BufferedDC(MemoryDC):
-    """
-    This simple class provides a simple way to avoid flicker: when drawing
-    on it, everything is in fact first drawn on an in-memory buffer (a
-    `wx.Bitmap`) and then copied to the screen only once, when this object
-    is destroyed.
-
-    It can be used in the same way as any other device context.
-    wx.BufferedDC itself typically replaces `wx.ClientDC`, if you want to
-    use it in your EVT_PAINT handler, you should look at
-    `wx.BufferedPaintDC`.
-
-    Please note that GTK+ 2.0 and OS X provide double buffering themselves
-    natively. wxBufferedDC is aware of this however, and will bypass the buffering
-    unless an explicit buffer bitmap is given.
-
-    """
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    __repr__ = _swig_repr
-    def __init__(self, *args): 
-        """
-        __init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
-        __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
-
-        Constructs a buffered DC.
-        """
-        _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
-        self.__dc = args[0] # save a ref so the other dc will not be deleted before self
-
-    __swig_destroy__ = _gdi_.delete_BufferedDC
-    __del__ = lambda self : None;
-    def UnMask(*args, **kwargs):
-        """
-        UnMask(self)
-
-        Blits the buffer to the dc, and detaches the dc from the buffer (so it
-        can be effectively used once only).  This is usually only called in
-        the destructor.
-        """
-        return _gdi_.BufferedDC_UnMask(*args, **kwargs)
-
-_gdi_.BufferedDC_swigregister(BufferedDC)
-
-class BufferedPaintDC(BufferedDC):
-    """
-    This is a subclass of `wx.BufferedDC` which can be used inside of an
-    EVT_PAINT event handler. Just create an object of this class instead
-    of `wx.PaintDC` and that's all you have to do to (mostly) avoid
-    flicker. The only thing to watch out for is that if you are using this
-    class together with `wx.ScrolledWindow`, you probably do **not** want
-    to call `wx.Window.PrepareDC` on it as it already does this internally
-    for the real underlying `wx.PaintDC`.
-
-    If your window is already fully buffered in a `wx.Bitmap` then your
-    EVT_PAINT handler can be as simple as just creating a
-    ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
-    automatically when it is destroyed.  For example::
-
-        def OnPaint(self, event):
-            dc = wx.BufferedPaintDC(self, self.buffer)
-
-
-
-    """
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    __repr__ = _swig_repr
-    def __init__(self, *args, **kwargs): 
-        """
-        __init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
-
-        Create a buffered paint DC.  As with `wx.BufferedDC`, you may either
-        provide the bitmap to be used for buffering or let this object create
-        one internally (in the latter case, the size of the client part of the
-        window is automatically used).
-        """
-        _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
-_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
-
-#---------------------------------------------------------------------------
-
 class ScreenDC(DC):
     """
     A wxScreenDC can be used to paint anywhere on the screen. This should
@@ -4665,20 +4858,133 @@ _gdi_.PaintDC_swigregister(PaintDC)
 
 #---------------------------------------------------------------------------
 
-if 'wxMac' in wx.PlatformInfo or 'gtk2' in wx.PlatformInfo:
+BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
-    _AutoBufferedPaintDCBase = PaintDC
+BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
-else:
+class BufferedDC(MemoryDC):
-    _AutoBufferedPaintDCBase = BufferedPaintDC
+    """
-        
+    This simple class provides a simple way to avoid flicker: when drawing
-class AutoBufferedPaintDC(_AutoBufferedPaintDCBase):
+    on it, everything is in fact first drawn on an in-memory buffer (a
+    `wx.Bitmap`) and then copied to the screen only once, when this object
+    is destroyed.
+
+    It can be used in the same way as any other device context.
+    wx.BufferedDC itself typically replaces `wx.ClientDC`, if you want to
+    use it in your EVT_PAINT handler, you should look at
+    `wx.BufferedPaintDC`.
+
+    Please note that GTK+ 2.0 and OS X provide double buffering themselves
+    natively. wxBufferedDC is aware of this however, and will bypass the buffering
+    unless an explicit buffer bitmap is given.
+
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        """
+        __init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
+        __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
+
+        Constructs a buffered DC.
+
+            :param dc: The underlying DC: everything drawn to this object will
+                be flushed to this DC when this object is destroyed. You may
+                pass ``None`` in order to just initialize the buffer, and not
+                flush it.
+
+            :param buffer: If a `wx.Size` object is passed as the 2nd arg then
+                it is the size of the bitmap that will be created internally
+                and used for an implicit buffer. If the 2nd arg is a
+                `wx.Bitmap` then it is the explicit buffer that will be
+                used. Using an explicit buffer is the most efficient solution
+                as the bitmap doesn't have to be recreated each time but it
+                also requires more memory as the bitmap is never freed. The
+                bitmap should have appropriate size, anything drawn outside of
+                its bounds is clipped.  If wx.NullBitmap is used then a new
+                buffer will be allocated that is the same size as the dc.
+
+            :param style: The style parameter indicates whether the supplied buffer is
+                intended to cover the entire virtual size of a `wx.ScrolledWindow` or
+                if it only covers the client area.  Acceptable values are
+                ``wx.BUFFER_VIRTUAL_AREA`` and ``wx.BUFFER_CLIENT_AREA``.
+
+
+        """
+        _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
+        self.__dc = args[0] # save a ref so the other dc will not be deleted before self
+
+    __swig_destroy__ = _gdi_.delete_BufferedDC
+    __del__ = lambda self : None;
+    def UnMask(*args, **kwargs):
+        """
+        UnMask(self)
+
+        Blits the buffer to the dc, and detaches the dc from the buffer (so it
+        can be effectively used once only).  This is usually only called in
+        the destructor.
+        """
+        return _gdi_.BufferedDC_UnMask(*args, **kwargs)
+
+_gdi_.BufferedDC_swigregister(BufferedDC)
+
+class BufferedPaintDC(BufferedDC):
+    """
+    This is a subclass of `wx.BufferedDC` which can be used inside of an
+    EVT_PAINT event handler. Just create an object of this class instead
+    of `wx.PaintDC` and that's all you have to do to (mostly) avoid
+    flicker. The only thing to watch out for is that if you are using this
+    class together with `wx.ScrolledWindow`, you probably do **not** want
+    to call `wx.Window.PrepareDC` on it as it already does this internally
+    for the real underlying `wx.PaintDC`.
+
+    If your window is already fully buffered in a `wx.Bitmap` then your
+    EVT_PAINT handler can be as simple as just creating a
+    ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
+    automatically when it is destroyed.  For example::
+
+        def OnPaint(self, event):
+            dc = wx.BufferedPaintDC(self, self.buffer)
+
+
+
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
+
+        Create a buffered paint DC.  As with `wx.BufferedDC`, you may either
+        provide the bitmap to be used for buffering or let this object create
+        one internally (in the latter case, the size of the client part of the
+        window is automatically used).
+        """
+        _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
+_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
+
+#---------------------------------------------------------------------------
+
+class AutoBufferedPaintDC(DC):
     """
     If the current platform double buffers by default then this DC is the
     same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
 
     :see: `wx.AutoBufferedPaintDCFactory`
+
     """
-    def __init__(self, window):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-        _AutoBufferedPaintDCBase.__init__(self, window)
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, Window win) -> AutoBufferedPaintDC
+
+        If the current platform double buffers by default then this DC is the
+        same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
+
+        :see: `wx.AutoBufferedPaintDCFactory`
+
+        """
+        _gdi_.AutoBufferedPaintDC_swiginit(self,_gdi_.new_AutoBufferedPaintDC(*args, **kwargs))
+_gdi_.AutoBufferedPaintDC_swigregister(AutoBufferedPaintDC)
 
 
 def AutoBufferedPaintDCFactory(*args, **kwargs):
@@ -4686,10 +4992,10 @@ def AutoBufferedPaintDCFactory(*args, **kwargs):
     AutoBufferedPaintDCFactory(Window window) -> DC
 
     Checks if the window is natively double buffered and will return a
-    `wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise.  The
+    `wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise.  The advantage of
-    advantage of this function over `wx.AutoBufferedPaintDC` is that this
+    this function over `wx.AutoBufferedPaintDC` is that this function will check
-    function will check if the the specified window supports has
+    if the the specified window has double-buffering enabled rather than just
-    double-buffering enabled rather than just going by platform defaults.
+    going by platform defaults.
     """
   return _gdi_.AutoBufferedPaintDCFactory(*args, **kwargs)
 #---------------------------------------------------------------------------
@@ -6386,6 +6692,8 @@ class PseudoDC(_core.Object):
         Draws a circle with the given center point and radius.  The current
         pen is used for the outline and the current brush for filling the
         shape.
+
+        :see: `DrawEllipse`
         """
         return _gdi_.PseudoDC_DrawCircle(*args, **kwargs)
 
@@ -6396,6 +6704,8 @@ class PseudoDC(_core.Object):
         Draws a circle with the given center point and radius.  The current
         pen is used for the outline and the current brush for filling the
         shape.
+
+        :see: `DrawEllipse`
         """
         return _gdi_.PseudoDC_DrawCirclePoint(*args, **kwargs)
 
@@ -6405,6 +6715,8 @@ class PseudoDC(_core.Object):
 
         Draws an ellipse contained in the specified rectangle. The current pen
         is used for the outline and the current brush for filling the shape.
+
+        :see: `DrawCircle`
         """
         return _gdi_.PseudoDC_DrawEllipse(*args, **kwargs)
 
@@ -6414,6 +6726,8 @@ class PseudoDC(_core.Object):
 
         Draws an ellipse contained in the specified rectangle. The current pen
         is used for the outline and the current brush for filling the shape.
+
+        :see: `DrawCircle`
         """
         return _gdi_.PseudoDC_DrawEllipseRect(*args, **kwargs)
 
@@ -6423,6 +6737,8 @@ class PseudoDC(_core.Object):
 
         Draws an ellipse contained in the specified rectangle. The current pen
         is used for the outline and the current brush for filling the shape.
+
+        :see: `DrawCircle`
         """
         return _gdi_.PseudoDC_DrawEllipsePointSize(*args, **kwargs)
 
@@ -6454,6 +6770,13 @@ class PseudoDC(_core.Object):
         *transparent* is true and the bitmap has a transparency mask, (or
         alpha channel on the platforms that support it) then the bitmap will
         be drawn transparently.
+
+        When drawing a mono-bitmap, the current text foreground colour will be
+        used to draw the foreground of the bitmap (all bits set to 1), and the
+        current text background colour to draw the background (all bits set to
+        0).
+
+        :see: `SetTextForeground`, `SetTextBackground` and `wx.MemoryDC`
         """
         return _gdi_.PseudoDC_DrawBitmap(*args, **kwargs)
 
@@ -6465,6 +6788,13 @@ class PseudoDC(_core.Object):
         *transparent* is true and the bitmap has a transparency mask, (or
         alpha channel on the platforms that support it) then the bitmap will
         be drawn transparently.
+
+        When drawing a mono-bitmap, the current text foreground colour will be
+        used to draw the foreground of the bitmap (all bits set to 1), and the
+        current text background colour to draw the background (all bits set to
+        0).
+
+        :see: `SetTextForeground`, `SetTextBackground` and `wx.MemoryDC`
         """
         return _gdi_.PseudoDC_DrawBitmapPoint(*args, **kwargs)
 
@@ -6484,6 +6814,8 @@ class PseudoDC(_core.Object):
         **NOTE**: under wxGTK the current logical function is used by this
         function but it is ignored by wxMSW. Thus, you should avoid using
         logical functions with this function in portable programs.
+
+        :see: `DrawRotatedText`
         """
         return _gdi_.PseudoDC_DrawText(*args, **kwargs)
 
@@ -6503,6 +6835,8 @@ class PseudoDC(_core.Object):
         **NOTE**: under wxGTK the current logical function is used by this
         function but it is ignored by wxMSW. Thus, you should avoid using
         logical functions with this function in portable programs.
+
+        :see: `DrawRotatedText`
         """
         return _gdi_.PseudoDC_DrawTextPoint(*args, **kwargs)
 
@@ -6516,6 +6850,8 @@ class PseudoDC(_core.Object):
         function. In particular, a font different from ``wx.NORMAL_FONT``
         should be used as the it is not normally a TrueType
         font. ``wx.SWISS_FONT`` is an example of a font which is.
+
+        :see: `DrawText`
         """
         return _gdi_.PseudoDC_DrawRotatedText(*args, **kwargs)
 
@@ -6529,6 +6865,8 @@ class PseudoDC(_core.Object):
         function. In particular, a font different from ``wx.NORMAL_FONT``
         should be used as the it is not normally a TrueType
         font. ``wx.SWISS_FONT`` is an example of a font which is.
+
+        :see: `DrawText`
         """
         return _gdi_.PseudoDC_DrawRotatedTextPoint(*args, **kwargs)
 
@@ -6566,6 +6904,8 @@ class PseudoDC(_core.Object):
         Draw *text* within the specified rectangle, abiding by the alignment
         flags.  Will additionally emphasize the character at *indexAccel* if
         it is not -1.
+
+        :see: `DrawImageLabel`
         """
         return _gdi_.PseudoDC_DrawLabel(*args, **kwargs)
 
@@ -6605,6 +6945,8 @@ class PseudoDC(_core.Object):
 
         Sets the current font for the DC. It must be a valid font, in
         particular you should not pass ``wx.NullFont`` to this method.
+
+        :see: `wx.Font`
         """
         return _gdi_.PseudoDC_SetFont(*args, **kwargs)
 
@@ -6616,6 +6958,8 @@ class PseudoDC(_core.Object):
 
         If the argument is ``wx.NullPen``, the current pen is selected out of the
         device context, and the original pen restored.
+
+        :see: `wx.Pen`
         """
         return _gdi_.PseudoDC_SetPen(*args, **kwargs)
 
@@ -6628,6 +6972,8 @@ class PseudoDC(_core.Object):
         If the argument is ``wx.NullBrush``, the current brush is selected out
         of the device context, and the original brush restored, allowing the
         current brush to be destroyed safely.
+
+        :see: `wx.Brush`
         """
         return _gdi_.PseudoDC_SetBrush(*args, **kwargs)
 
@@ -6657,6 +7003,8 @@ class PseudoDC(_core.Object):
         window or bitmap associated with the DC. If the argument is
         ``wx.NullPalette``, the current palette is selected out of the device
         context, and the original palette restored.
+
+        :see: `wx.Palette`
         """
         return _gdi_.PseudoDC_SetPalette(*args, **kwargs)
 

wxPython/src/gtk/_misc.py

@@ -2615,6 +2615,98 @@ class ArtProvider(object):
                 ...
                 return bmp
 
+
+    Identifying art resources
+    -------------------------
+
+    Every bitmap is known to wx.ArtProvider under an unique ID that is
+    used when requesting a resource from it. The IDs can have one of the
+    following predefined values.  Additionally, any string recognized by
+    custom art providers registered using `Push` may be used.
+
+    GTK+ Note
+    ---------
+
+    When running under GTK+ 2, GTK+ stock item IDs (e.g. 'gtk-cdrom') may be used
+    as well.  Additionally, if wxGTK was compiled against GTK+ >= 2.4, then it is
+    also possible to load icons from current icon theme by specifying their name
+    without the extension and directory components. Icon themes recognized by GTK+
+    follow the freedesktop.org Icon Themes specification.  Note that themes are
+    not guaranteed to contain all icons, so wx.ArtProvider may return wx.NullBitmap
+    or wx.NullIcon.  The default theme is typically installed in /usr/share/icons/hicolor.
+
+        * wx.ART_ADD_BOOKMARK
+        * wx.ART_DEL_BOOKMARK
+        * wx.ART_HELP_SIDE_PANEL
+        * wx.ART_HELP_SETTINGS
+        * wx.ART_HELP_BOOK
+        * wx.ART_HELP_FOLDER
+        * wx.ART_HELP_PAGE
+        * wx.ART_GO_BACK
+        * wx.ART_GO_FORWARD
+        * wx.ART_GO_UP
+        * wx.ART_GO_DOWN
+        * wx.ART_GO_TO_PARENT
+        * wx.ART_GO_HOME
+        * wx.ART_FILE_OPEN
+        * wx.ART_FILE_SAVE
+        * wx.ART_FILE_SAVE_AS
+        * wx.ART_PRINT
+        * wx.ART_HELP
+        * wx.ART_TIP
+        * wx.ART_REPORT_VIEW
+        * wx.ART_LIST_VIEW
+        * wx.ART_NEW_DIR
+        * wx.ART_HARDDISK
+        * wx.ART_FLOPPY
+        * wx.ART_CDROM
+        * wx.ART_REMOVABLE
+        * wx.ART_FOLDER
+        * wx.ART_FOLDER_OPEN
+        * wx.ART_GO_DIR_UP
+        * wx.ART_EXECUTABLE_FILE
+        * wx.ART_NORMAL_FILE
+        * wx.ART_TICK_MARK
+        * wx.ART_CROSS_MARK
+        * wx.ART_ERROR
+        * wx.ART_QUESTION
+        * wx.ART_WARNING
+        * wx.ART_INFORMATION
+        * wx.ART_MISSING_IMAGE
+        * wx.ART_COPY
+        * wx.ART_CUT
+        * wx.ART_PASTE
+        * wx.ART_DELETE
+        * wx.ART_NEW
+        * wx.ART_UNDO
+        * wx.ART_REDO
+        * wx.ART_QUIT
+        * wx.ART_FIND
+        * wx.ART_FIND_AND_REPLACE
+
+
+    Clients
+    -------
+
+    The Client is the entity that calls wx.ArtProvider's `GetBitmap` or
+    `GetIcon` function.  Client IDs serve as a hint to wx.ArtProvider
+    that is supposed to help it to choose the best looking bitmap. For
+    example it is often desirable to use slightly different icons in menus
+    and toolbars even though they represent the same action (e.g.
+    wx.ART_FILE_OPEN). Remember that this is really only a hint for
+    wx.ArtProvider -- it is common that `wx.ArtProvider.GetBitmap` returns
+    identical bitmap for different client values!
+
+        * wx.ART_TOOLBAR
+        * wx.ART_MENU
+        * wx.ART_FRAME_ICON
+        * wx.ART_CMN_DIALOG
+        * wx.ART_HELP_BROWSER
+        * wx.ART_MESSAGE_BOX
+        * wx.ART_BUTTON
+        * wx.ART_OTHER (used for all requests that don't fit into any
+          of the categories above)
+
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
@@ -2639,6 +2731,98 @@ class ArtProvider(object):
                     ...
                     return bmp
 
+
+        Identifying art resources
+        -------------------------
+
+        Every bitmap is known to wx.ArtProvider under an unique ID that is
+        used when requesting a resource from it. The IDs can have one of the
+        following predefined values.  Additionally, any string recognized by
+        custom art providers registered using `Push` may be used.
+
+        GTK+ Note
+        ---------
+
+        When running under GTK+ 2, GTK+ stock item IDs (e.g. 'gtk-cdrom') may be used
+        as well.  Additionally, if wxGTK was compiled against GTK+ >= 2.4, then it is
+        also possible to load icons from current icon theme by specifying their name
+        without the extension and directory components. Icon themes recognized by GTK+
+        follow the freedesktop.org Icon Themes specification.  Note that themes are
+        not guaranteed to contain all icons, so wx.ArtProvider may return wx.NullBitmap
+        or wx.NullIcon.  The default theme is typically installed in /usr/share/icons/hicolor.
+
+            * wx.ART_ADD_BOOKMARK
+            * wx.ART_DEL_BOOKMARK
+            * wx.ART_HELP_SIDE_PANEL
+            * wx.ART_HELP_SETTINGS
+            * wx.ART_HELP_BOOK
+            * wx.ART_HELP_FOLDER
+            * wx.ART_HELP_PAGE
+            * wx.ART_GO_BACK
+            * wx.ART_GO_FORWARD
+            * wx.ART_GO_UP
+            * wx.ART_GO_DOWN
+            * wx.ART_GO_TO_PARENT
+            * wx.ART_GO_HOME
+            * wx.ART_FILE_OPEN
+            * wx.ART_FILE_SAVE
+            * wx.ART_FILE_SAVE_AS
+            * wx.ART_PRINT
+            * wx.ART_HELP
+            * wx.ART_TIP
+            * wx.ART_REPORT_VIEW
+            * wx.ART_LIST_VIEW
+            * wx.ART_NEW_DIR
+            * wx.ART_HARDDISK
+            * wx.ART_FLOPPY
+            * wx.ART_CDROM
+            * wx.ART_REMOVABLE
+            * wx.ART_FOLDER
+            * wx.ART_FOLDER_OPEN
+            * wx.ART_GO_DIR_UP
+            * wx.ART_EXECUTABLE_FILE
+            * wx.ART_NORMAL_FILE
+            * wx.ART_TICK_MARK
+            * wx.ART_CROSS_MARK
+            * wx.ART_ERROR
+            * wx.ART_QUESTION
+            * wx.ART_WARNING
+            * wx.ART_INFORMATION
+            * wx.ART_MISSING_IMAGE
+            * wx.ART_COPY
+            * wx.ART_CUT
+            * wx.ART_PASTE
+            * wx.ART_DELETE
+            * wx.ART_NEW
+            * wx.ART_UNDO
+            * wx.ART_REDO
+            * wx.ART_QUIT
+            * wx.ART_FIND
+            * wx.ART_FIND_AND_REPLACE
+
+
+        Clients
+        -------
+
+        The Client is the entity that calls wx.ArtProvider's `GetBitmap` or
+        `GetIcon` function.  Client IDs serve as a hint to wx.ArtProvider
+        that is supposed to help it to choose the best looking bitmap. For
+        example it is often desirable to use slightly different icons in menus
+        and toolbars even though they represent the same action (e.g.
+        wx.ART_FILE_OPEN). Remember that this is really only a hint for
+        wx.ArtProvider -- it is common that `wx.ArtProvider.GetBitmap` returns
+        identical bitmap for different client values!
+
+            * wx.ART_TOOLBAR
+            * wx.ART_MENU
+            * wx.ART_FRAME_ICON
+            * wx.ART_CMN_DIALOG
+            * wx.ART_HELP_BROWSER
+            * wx.ART_MESSAGE_BOX
+            * wx.ART_BUTTON
+            * wx.ART_OTHER (used for all requests that don't fit into any
+              of the categories above)
+
         """
         _misc_.ArtProvider_swiginit(self,_misc_.new_ArtProvider(*args, **kwargs))
         self._setCallbackInfo(self, ArtProvider)
@@ -4628,6 +4812,29 @@ class DataFormat(object):
     example, pasting data from the clipboard only if the data is in a
     format the program understands.  A data format is is used to uniquely
     identify this format.
+    On the system level, a data format is usually just a number, (which
+    may be the CLIPFORMAT under Windows or Atom under X11, for example.)
+
+    The standard format IDs are:
+
+        ================    =====================================
+        wx.DF_INVALID       An invalid format
+        wx.DF_TEXT          Text format 
+        wx.DF_BITMAP        A bitmap (wx.Bitmap)
+        wx.DF_METAFILE      A metafile (wx.Metafile, Windows only)
+        wx.DF_FILENAME      A list of filenames
+        wx.DF_HTML          An HTML string. This is only valid on
+                            Windows and non-unicode builds
+        ================    =====================================
+
+    Besies the standard formats, the application may also use custom
+    formats which are identified by their names (strings) and not numeric
+    identifiers. Although internally custom format must be created (or
+    registered) first, you shouldn't care about it because it is done
+    automatically the first time the wxDataFormat object corresponding to
+    a given format name is created.
+
+
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
@@ -4718,6 +4925,39 @@ class DataObject(object):
     you should instead derive from `wx.PyDataObjectSimple` or use
     `wx.CustomDataObject`.
 
+    Not surprisingly, being 'smart' comes at a price of added
+    complexity. This is reasonable for the situations when you really need
+    to support multiple formats, but may be annoying if you only want to
+    do something simple like cut and paste text.
+
+    To provide a solution for both cases, wxWidgets has two predefined
+    classes which derive from wx.DataObject: `wx.DataObjectSimple` and
+    `wx.DataObjectComposite`.  `wx.DataObjectSimple` is the simplest
+    wx.DataObject possible and only holds data in a single format (such as
+    text or bitmap) and `wx.DataObjectComposite` is the simplest way to
+    implement a wx.DataObject which supports multiple simultaneous formats
+    because it achievs this by simply holding several
+    `wx.DataObjectSimple` objects.
+
+    Please note that the easiest way to use drag and drop and the
+    clipboard with multiple formats is by using `wx.DataObjectComposite`,
+    but it is not the most efficient one as each `wx.DataObjectSimple`
+    would contain the whole data in its respective formats. Now imagine
+    that you want to paste 200 pages of text in your proprietary format,
+    as well as Word, RTF, HTML, Unicode and plain text to the clipboard
+    and even today's computers are in trouble. For this case, you will
+    have to derive from wx.DataObject directly and make it enumerate its
+    formats and provide the data in the requested format on
+    demand. (**TODO**: This is currently not possible from Python.  Make
+    it so.)
+
+    Note that the platform transfer mechanisms for the clipboard and drag
+    and drop, do not copy any data out of the source application until
+    another application actually requests the data. This is in contrast to
+    the 'feel' offered to the user of a program who would normally think
+    that the data resides in the clipboard after having pressed 'Copy' -
+    in reality it is only declared to be available.
+
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     def __init__(self): raise AttributeError, "No constructor defined"
@@ -4776,6 +5016,7 @@ class DataObject(object):
         GetDataHere(self, DataFormat format) -> String
 
         Get the data bytes in the specified format, returns None on failure.
+        :todo: This should use the python buffer interface isntead...
         """
         return _misc_.DataObject_GetDataHere(*args, **kwargs)
 
@@ -4785,6 +5026,7 @@ class DataObject(object):
 
         Set the data in the specified format from the bytes in the the data string.
 
+        :todo: This should use the python buffer interface isntead...
         """
         return _misc_.DataObject_SetData(*args, **kwargs)
 
@@ -4872,6 +5114,29 @@ class PyDataObjectSimple(DataObjectSimple):
     class and overload `GetDataSize`, `GetDataHere` and `SetData` when you
     need to create your own simple single-format type of `wx.DataObject`.
 
+    Here is a simple example::
+
+        class MyDataObject(wx.PyDataObjectSimple):
+            def __init__(self):
+                wx.PyDataObjectSimple.__init__(
+                    self, wx.CustomDataFormat('MyDOFormat'))
+                self.data = ''
+
+            def GetDataSize(self):
+                return len(self.data)
+            def GetDataHere(self):
+                return self.data  # returns a string  
+            def SetData(self, data):
+                self.data = data
+                return True
+
+    Note that there is already a `wx.CustomDataObject` class that behaves
+    very similarly to this example.  The value of creating your own
+    derived class like this is to be able to do additional things when the
+    data is requested or given via the clipboard or drag and drop
+    operation, such as generate the data value or decode it into needed
+    data structures.
+
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
@@ -4885,6 +5150,29 @@ class PyDataObjectSimple(DataObjectSimple):
         class and overload `GetDataSize`, `GetDataHere` and `SetData` when you
         need to create your own simple single-format type of `wx.DataObject`.
 
+        Here is a simple example::
+
+            class MyDataObject(wx.PyDataObjectSimple):
+                def __init__(self):
+                    wx.PyDataObjectSimple.__init__(
+                        self, wx.CustomDataFormat('MyDOFormat'))
+                    self.data = ''
+
+                def GetDataSize(self):
+                    return len(self.data)
+                def GetDataHere(self):
+                    return self.data  # returns a string  
+                def SetData(self, data):
+                    self.data = data
+                    return True
+
+        Note that there is already a `wx.CustomDataObject` class that behaves
+        very similarly to this example.  The value of creating your own
+        derived class like this is to be able to do additional things when the
+        data is requested or given via the clipboard or drag and drop
+        operation, such as generate the data value or decode it into needed
+        data structures.
+
         """
         _misc_.PyDataObjectSimple_swiginit(self,_misc_.new_PyDataObjectSimple(*args, **kwargs))
         self._setCallbackInfo(self, PyDataObjectSimple)
@@ -5050,6 +5338,7 @@ class BitmapDataObject(DataObjectSimple):
     data. It can be used without change to paste data into the `wx.Clipboard`
     or a `wx.DropSource`.
 
+    :see: `wx.PyBitmapDataObject` if you wish to override `GetBitmap` to increase efficiency.
     """
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
     __repr__ = _swig_repr
@@ -6623,8 +6912,8 @@ def AboutBox(*args, **kwargs):
     This function shows the standard about dialog containing the
     information specified in ``info``. If the current platform has a
     native about dialog which is capable of showing all the fields in
-    ``info``, the native dialog is used, otherwise the function falls back
+    `wx.AboutDialogInfo`, the native dialog is used, otherwise the
-    to the generic wxWidgets version of the dialog.
+    function falls back to the generic wxWidgets version of the dialog.
     """
   return _misc_.AboutBox(*args, **kwargs)
 

wxPython/src/mac/_gdi.py

@@ -4441,88 +4441,6 @@ def MemoryDCFromDC(*args, **kwargs):
 
 #---------------------------------------------------------------------------
 
-BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
-BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
-class BufferedDC(MemoryDC):
-    """
-    This simple class provides a simple way to avoid flicker: when drawing
-    on it, everything is in fact first drawn on an in-memory buffer (a
-    `wx.Bitmap`) and then copied to the screen only once, when this object
-    is destroyed.
-
-    It can be used in the same way as any other device context.
-    wx.BufferedDC itself typically replaces `wx.ClientDC`, if you want to
-    use it in your EVT_PAINT handler, you should look at
-    `wx.BufferedPaintDC`.
-
-    Please note that GTK+ 2.0 and OS X provide double buffering themselves
-    natively. wxBufferedDC is aware of this however, and will bypass the buffering
-    unless an explicit buffer bitmap is given.
-
-    """
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    __repr__ = _swig_repr
-    def __init__(self, *args): 
-        """
-        __init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
-        __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
-
-        Constructs a buffered DC.
-        """
-        _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
-        self.__dc = args[0] # save a ref so the other dc will not be deleted before self
-
-    __swig_destroy__ = _gdi_.delete_BufferedDC
-    __del__ = lambda self : None;
-    def UnMask(*args, **kwargs):
-        """
-        UnMask(self)
-
-        Blits the buffer to the dc, and detaches the dc from the buffer (so it
-        can be effectively used once only).  This is usually only called in
-        the destructor.
-        """
-        return _gdi_.BufferedDC_UnMask(*args, **kwargs)
-
-_gdi_.BufferedDC_swigregister(BufferedDC)
-
-class BufferedPaintDC(BufferedDC):
-    """
-    This is a subclass of `wx.BufferedDC` which can be used inside of an
-    EVT_PAINT event handler. Just create an object of this class instead
-    of `wx.PaintDC` and that's all you have to do to (mostly) avoid
-    flicker. The only thing to watch out for is that if you are using this
-    class together with `wx.ScrolledWindow`, you probably do **not** want
-    to call `wx.Window.PrepareDC` on it as it already does this internally
-    for the real underlying `wx.PaintDC`.
-
-    If your window is already fully buffered in a `wx.Bitmap` then your
-    EVT_PAINT handler can be as simple as just creating a
-    ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
-    automatically when it is destroyed.  For example::
-
-        def OnPaint(self, event):
-            dc = wx.BufferedPaintDC(self, self.buffer)
-
-
-
-    """
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    __repr__ = _swig_repr
-    def __init__(self, *args, **kwargs): 
-        """
-        __init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
-
-        Create a buffered paint DC.  As with `wx.BufferedDC`, you may either
-        provide the bitmap to be used for buffering or let this object create
-        one internally (in the latter case, the size of the client part of the
-        window is automatically used).
-        """
-        _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
-_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
-
-#---------------------------------------------------------------------------
-
 class ScreenDC(DC):
     """
     A wxScreenDC can be used to paint anywhere on the screen. This should
@@ -4664,20 +4582,110 @@ _gdi_.PaintDC_swigregister(PaintDC)
 
 #---------------------------------------------------------------------------
 
-if 'wxMac' in wx.PlatformInfo or 'gtk2' in wx.PlatformInfo:
+BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
-    _AutoBufferedPaintDCBase = PaintDC
+BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
-else:
+class BufferedDC(MemoryDC):
-    _AutoBufferedPaintDCBase = BufferedPaintDC
+    """
-        
+    This simple class provides a simple way to avoid flicker: when drawing
-class AutoBufferedPaintDC(_AutoBufferedPaintDCBase):
+    on it, everything is in fact first drawn on an in-memory buffer (a
+    `wx.Bitmap`) and then copied to the screen only once, when this object
+    is destroyed.
+
+    It can be used in the same way as any other device context.
+    wx.BufferedDC itself typically replaces `wx.ClientDC`, if you want to
+    use it in your EVT_PAINT handler, you should look at
+    `wx.BufferedPaintDC`.
+
+    Please note that GTK+ 2.0 and OS X provide double buffering themselves
+    natively. wxBufferedDC is aware of this however, and will bypass the buffering
+    unless an explicit buffer bitmap is given.
+
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        """
+        __init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
+        __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
+
+        Constructs a buffered DC.
+        """
+        _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
+        self.__dc = args[0] # save a ref so the other dc will not be deleted before self
+
+    __swig_destroy__ = _gdi_.delete_BufferedDC
+    __del__ = lambda self : None;
+    def UnMask(*args, **kwargs):
+        """
+        UnMask(self)
+
+        Blits the buffer to the dc, and detaches the dc from the buffer (so it
+        can be effectively used once only).  This is usually only called in
+        the destructor.
+        """
+        return _gdi_.BufferedDC_UnMask(*args, **kwargs)
+
+_gdi_.BufferedDC_swigregister(BufferedDC)
+
+class BufferedPaintDC(BufferedDC):
+    """
+    This is a subclass of `wx.BufferedDC` which can be used inside of an
+    EVT_PAINT event handler. Just create an object of this class instead
+    of `wx.PaintDC` and that's all you have to do to (mostly) avoid
+    flicker. The only thing to watch out for is that if you are using this
+    class together with `wx.ScrolledWindow`, you probably do **not** want
+    to call `wx.Window.PrepareDC` on it as it already does this internally
+    for the real underlying `wx.PaintDC`.
+
+    If your window is already fully buffered in a `wx.Bitmap` then your
+    EVT_PAINT handler can be as simple as just creating a
+    ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
+    automatically when it is destroyed.  For example::
+
+        def OnPaint(self, event):
+            dc = wx.BufferedPaintDC(self, self.buffer)
+
+
+
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
+
+        Create a buffered paint DC.  As with `wx.BufferedDC`, you may either
+        provide the bitmap to be used for buffering or let this object create
+        one internally (in the latter case, the size of the client part of the
+        window is automatically used).
+        """
+        _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
+_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
+
+#---------------------------------------------------------------------------
+
+class AutoBufferedPaintDC(DC):
     """
     If the current platform double buffers by default then this DC is the
     same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
 
     :see: `wx.AutoBufferedPaintDCFactory`
+
     """
-    def __init__(self, window):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-        _AutoBufferedPaintDCBase.__init__(self, window)
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, Window win) -> AutoBufferedPaintDC
+
+        If the current platform double buffers by default then this DC is the
+        same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
+
+        :see: `wx.AutoBufferedPaintDCFactory`
+
+        """
+        _gdi_.AutoBufferedPaintDC_swiginit(self,_gdi_.new_AutoBufferedPaintDC(*args, **kwargs))
+_gdi_.AutoBufferedPaintDC_swigregister(AutoBufferedPaintDC)
 
 
 def AutoBufferedPaintDCFactory(*args, **kwargs):
@@ -4685,10 +4693,10 @@ def AutoBufferedPaintDCFactory(*args, **kwargs):
     AutoBufferedPaintDCFactory(Window window) -> DC
 
     Checks if the window is natively double buffered and will return a
-    `wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise.  The
+    `wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise.  The advantage of
-    advantage of this function over `wx.AutoBufferedPaintDC` is that this
+    this function over `wx.AutoBufferedPaintDC` is that this function will check
-    function will check if the the specified window supports has
+    if the the specified window has double-buffering enabled rather than just
-    double-buffering enabled rather than just going by platform defaults.
+    going by platform defaults.
     """
   return _gdi_.AutoBufferedPaintDCFactory(*args, **kwargs)
 #---------------------------------------------------------------------------

wxPython/src/mac/_misc.py

@@ -6631,8 +6631,8 @@ def AboutBox(*args, **kwargs):
     This function shows the standard about dialog containing the
     information specified in ``info``. If the current platform has a
     native about dialog which is capable of showing all the fields in
-    ``info``, the native dialog is used, otherwise the function falls back
+    `wx.AboutDialogInfo`, the native dialog is used, otherwise the
-    to the generic wxWidgets version of the dialog.
+    function falls back to the generic wxWidgets version of the dialog.
     """
   return _misc_.AboutBox(*args, **kwargs)
 

wxPython/src/msw/_gdi.py

@@ -4535,88 +4535,6 @@ def MemoryDCFromDC(*args, **kwargs):
 
 #---------------------------------------------------------------------------
 
-BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
-BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
-class BufferedDC(MemoryDC):
-    """
-    This simple class provides a simple way to avoid flicker: when drawing
-    on it, everything is in fact first drawn on an in-memory buffer (a
-    `wx.Bitmap`) and then copied to the screen only once, when this object
-    is destroyed.
-
-    It can be used in the same way as any other device context.
-    wx.BufferedDC itself typically replaces `wx.ClientDC`, if you want to
-    use it in your EVT_PAINT handler, you should look at
-    `wx.BufferedPaintDC`.
-
-    Please note that GTK+ 2.0 and OS X provide double buffering themselves
-    natively. wxBufferedDC is aware of this however, and will bypass the buffering
-    unless an explicit buffer bitmap is given.
-
-    """
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    __repr__ = _swig_repr
-    def __init__(self, *args): 
-        """
-        __init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
-        __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
-
-        Constructs a buffered DC.
-        """
-        _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
-        self.__dc = args[0] # save a ref so the other dc will not be deleted before self
-
-    __swig_destroy__ = _gdi_.delete_BufferedDC
-    __del__ = lambda self : None;
-    def UnMask(*args, **kwargs):
-        """
-        UnMask(self)
-
-        Blits the buffer to the dc, and detaches the dc from the buffer (so it
-        can be effectively used once only).  This is usually only called in
-        the destructor.
-        """
-        return _gdi_.BufferedDC_UnMask(*args, **kwargs)
-
-_gdi_.BufferedDC_swigregister(BufferedDC)
-
-class BufferedPaintDC(BufferedDC):
-    """
-    This is a subclass of `wx.BufferedDC` which can be used inside of an
-    EVT_PAINT event handler. Just create an object of this class instead
-    of `wx.PaintDC` and that's all you have to do to (mostly) avoid
-    flicker. The only thing to watch out for is that if you are using this
-    class together with `wx.ScrolledWindow`, you probably do **not** want
-    to call `wx.Window.PrepareDC` on it as it already does this internally
-    for the real underlying `wx.PaintDC`.
-
-    If your window is already fully buffered in a `wx.Bitmap` then your
-    EVT_PAINT handler can be as simple as just creating a
-    ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
-    automatically when it is destroyed.  For example::
-
-        def OnPaint(self, event):
-            dc = wx.BufferedPaintDC(self, self.buffer)
-
-
-
-    """
-    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-    __repr__ = _swig_repr
-    def __init__(self, *args, **kwargs): 
-        """
-        __init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
-
-        Create a buffered paint DC.  As with `wx.BufferedDC`, you may either
-        provide the bitmap to be used for buffering or let this object create
-        one internally (in the latter case, the size of the client part of the
-        window is automatically used).
-        """
-        _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
-_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
-
-#---------------------------------------------------------------------------
-
 class ScreenDC(DC):
     """
     A wxScreenDC can be used to paint anywhere on the screen. This should
@@ -4758,20 +4676,110 @@ _gdi_.PaintDC_swigregister(PaintDC)
 
 #---------------------------------------------------------------------------
 
-if 'wxMac' in wx.PlatformInfo or 'gtk2' in wx.PlatformInfo:
+BUFFER_VIRTUAL_AREA = _gdi_.BUFFER_VIRTUAL_AREA
-    _AutoBufferedPaintDCBase = PaintDC
+BUFFER_CLIENT_AREA = _gdi_.BUFFER_CLIENT_AREA
-else:
+class BufferedDC(MemoryDC):
-    _AutoBufferedPaintDCBase = BufferedPaintDC
+    """
-        
+    This simple class provides a simple way to avoid flicker: when drawing
-class AutoBufferedPaintDC(_AutoBufferedPaintDCBase):
+    on it, everything is in fact first drawn on an in-memory buffer (a
+    `wx.Bitmap`) and then copied to the screen only once, when this object
+    is destroyed.
+
+    It can be used in the same way as any other device context.
+    wx.BufferedDC itself typically replaces `wx.ClientDC`, if you want to
+    use it in your EVT_PAINT handler, you should look at
+    `wx.BufferedPaintDC`.
+
+    Please note that GTK+ 2.0 and OS X provide double buffering themselves
+    natively. wxBufferedDC is aware of this however, and will bypass the buffering
+    unless an explicit buffer bitmap is given.
+
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args): 
+        """
+        __init__(self, DC dc, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedDC
+        __init__(self, DC dc, Size area, int style=BUFFER_CLIENT_AREA) -> BufferedDC
+
+        Constructs a buffered DC.
+        """
+        _gdi_.BufferedDC_swiginit(self,_gdi_.new_BufferedDC(*args))
+        self.__dc = args[0] # save a ref so the other dc will not be deleted before self
+
+    __swig_destroy__ = _gdi_.delete_BufferedDC
+    __del__ = lambda self : None;
+    def UnMask(*args, **kwargs):
+        """
+        UnMask(self)
+
+        Blits the buffer to the dc, and detaches the dc from the buffer (so it
+        can be effectively used once only).  This is usually only called in
+        the destructor.
+        """
+        return _gdi_.BufferedDC_UnMask(*args, **kwargs)
+
+_gdi_.BufferedDC_swigregister(BufferedDC)
+
+class BufferedPaintDC(BufferedDC):
+    """
+    This is a subclass of `wx.BufferedDC` which can be used inside of an
+    EVT_PAINT event handler. Just create an object of this class instead
+    of `wx.PaintDC` and that's all you have to do to (mostly) avoid
+    flicker. The only thing to watch out for is that if you are using this
+    class together with `wx.ScrolledWindow`, you probably do **not** want
+    to call `wx.Window.PrepareDC` on it as it already does this internally
+    for the real underlying `wx.PaintDC`.
+
+    If your window is already fully buffered in a `wx.Bitmap` then your
+    EVT_PAINT handler can be as simple as just creating a
+    ``wx.BufferedPaintDC`` as it will `Blit` the buffer to the window
+    automatically when it is destroyed.  For example::
+
+        def OnPaint(self, event):
+            dc = wx.BufferedPaintDC(self, self.buffer)
+
+
+
+    """
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, Window window, Bitmap buffer=NullBitmap, int style=BUFFER_CLIENT_AREA) -> BufferedPaintDC
+
+        Create a buffered paint DC.  As with `wx.BufferedDC`, you may either
+        provide the bitmap to be used for buffering or let this object create
+        one internally (in the latter case, the size of the client part of the
+        window is automatically used).
+        """
+        _gdi_.BufferedPaintDC_swiginit(self,_gdi_.new_BufferedPaintDC(*args, **kwargs))
+_gdi_.BufferedPaintDC_swigregister(BufferedPaintDC)
+
+#---------------------------------------------------------------------------
+
+class AutoBufferedPaintDC(DC):
     """
     If the current platform double buffers by default then this DC is the
     same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
 
     :see: `wx.AutoBufferedPaintDCFactory`
+
     """
-    def __init__(self, window):
+    thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
-        _AutoBufferedPaintDCBase.__init__(self, window)
+    __repr__ = _swig_repr
+    def __init__(self, *args, **kwargs): 
+        """
+        __init__(self, Window win) -> AutoBufferedPaintDC
+
+        If the current platform double buffers by default then this DC is the
+        same as a plain `wx.PaintDC`, otherwise it is a `wx.BufferedPaintDC`.
+
+        :see: `wx.AutoBufferedPaintDCFactory`
+
+        """
+        _gdi_.AutoBufferedPaintDC_swiginit(self,_gdi_.new_AutoBufferedPaintDC(*args, **kwargs))
+_gdi_.AutoBufferedPaintDC_swigregister(AutoBufferedPaintDC)
 
 
 def AutoBufferedPaintDCFactory(*args, **kwargs):
@@ -4779,10 +4787,10 @@ def AutoBufferedPaintDCFactory(*args, **kwargs):
     AutoBufferedPaintDCFactory(Window window) -> DC
 
     Checks if the window is natively double buffered and will return a
-    `wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise.  The
+    `wx.PaintDC` if it is, a `wx.BufferedPaintDC` otherwise.  The advantage of
-    advantage of this function over `wx.AutoBufferedPaintDC` is that this
+    this function over `wx.AutoBufferedPaintDC` is that this function will check
-    function will check if the the specified window supports has
+    if the the specified window has double-buffering enabled rather than just
-    double-buffering enabled rather than just going by platform defaults.
+    going by platform defaults.
     """
   return _gdi_.AutoBufferedPaintDCFactory(*args, **kwargs)
 #---------------------------------------------------------------------------

wxPython/src/msw/_misc.py

@@ -6631,8 +6631,8 @@ def AboutBox(*args, **kwargs):
     This function shows the standard about dialog containing the
     information specified in ``info``. If the current platform has a
     native about dialog which is capable of showing all the fields in
-    ``info``, the native dialog is used, otherwise the function falls back
+    `wx.AboutDialogInfo`, the native dialog is used, otherwise the
-    to the generic wxWidgets version of the dialog.
+    function falls back to the generic wxWidgets version of the dialog.
     """
   return _misc_.AboutBox(*args, **kwargs)