Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

reSWIGged

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@42557 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robin Dunn
2006-10-28 03:01:58 +00:00
parent 027aef71af
commit 70d7cb34a6
33 changed files with 24717 additions and 3173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

254
wxPython/src/gtk/_core.py
View File

@@ -1649,6 +1649,260 @@ def Point2DFromPoint(*args, **kwargs):
#---------------------------------------------------------------------------
Inside = _core_.Inside
OutLeft = _core_.OutLeft
OutRight = _core_.OutRight
OutTop = _core_.OutTop
OutBottom = _core_.OutBottom
class Rect2D(object):
"""
wx.Rect2D is a rectangle, with position and size, in a 2D coordinate system
with floating point component values.
"""
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, wxDouble x=0.0, wxDouble y=0.0, wxDouble w=0.0, wxDouble h=0.0) -> Rect2D
wx.Rect2D is a rectangle, with position and size, in a 2D coordinate system
with floating point component values.
"""
_core_.Rect2D_swiginit(self,_core_.new_Rect2D(*args, **kwargs))
__swig_destroy__ = _core_.delete_Rect2D
__del__ = lambda self : None;
def GetPosition(*args, **kwargs):
"""GetPosition(self) -> Point2D"""
return _core_.Rect2D_GetPosition(*args, **kwargs)
def GetSize(*args, **kwargs):
"""GetSize(self) -> Size"""
return _core_.Rect2D_GetSize(*args, **kwargs)
def GetLeft(*args, **kwargs):
"""GetLeft(self) -> wxDouble"""
return _core_.Rect2D_GetLeft(*args, **kwargs)
def SetLeft(*args, **kwargs):
"""SetLeft(self, wxDouble n)"""
return _core_.Rect2D_SetLeft(*args, **kwargs)
def MoveLeftTo(*args, **kwargs):
"""MoveLeftTo(self, wxDouble n)"""
return _core_.Rect2D_MoveLeftTo(*args, **kwargs)
def GetTop(*args, **kwargs):
"""GetTop(self) -> wxDouble"""
return _core_.Rect2D_GetTop(*args, **kwargs)
def SetTop(*args, **kwargs):
"""SetTop(self, wxDouble n)"""
return _core_.Rect2D_SetTop(*args, **kwargs)
def MoveTopTo(*args, **kwargs):
"""MoveTopTo(self, wxDouble n)"""
return _core_.Rect2D_MoveTopTo(*args, **kwargs)
def GetBottom(*args, **kwargs):
"""GetBottom(self) -> wxDouble"""
return _core_.Rect2D_GetBottom(*args, **kwargs)
def SetBottom(*args, **kwargs):
"""SetBottom(self, wxDouble n)"""
return _core_.Rect2D_SetBottom(*args, **kwargs)
def MoveBottomTo(*args, **kwargs):
"""MoveBottomTo(self, wxDouble n)"""
return _core_.Rect2D_MoveBottomTo(*args, **kwargs)
def GetRight(*args, **kwargs):
"""GetRight(self) -> wxDouble"""
return _core_.Rect2D_GetRight(*args, **kwargs)
def SetRight(*args, **kwargs):
"""SetRight(self, wxDouble n)"""
return _core_.Rect2D_SetRight(*args, **kwargs)
def MoveRightTo(*args, **kwargs):
"""MoveRightTo(self, wxDouble n)"""
return _core_.Rect2D_MoveRightTo(*args, **kwargs)
def GetLeftTop(*args, **kwargs):
"""GetLeftTop(self) -> Point2D"""
return _core_.Rect2D_GetLeftTop(*args, **kwargs)
def SetLeftTop(*args, **kwargs):
"""SetLeftTop(self, Point2D pt)"""
return _core_.Rect2D_SetLeftTop(*args, **kwargs)
def MoveLeftTopTo(*args, **kwargs):
"""MoveLeftTopTo(self, Point2D pt)"""
return _core_.Rect2D_MoveLeftTopTo(*args, **kwargs)
def GetLeftBottom(*args, **kwargs):
"""GetLeftBottom(self) -> Point2D"""
return _core_.Rect2D_GetLeftBottom(*args, **kwargs)
def SetLeftBottom(*args, **kwargs):
"""SetLeftBottom(self, Point2D pt)"""
return _core_.Rect2D_SetLeftBottom(*args, **kwargs)
def MoveLeftBottomTo(*args, **kwargs):
"""MoveLeftBottomTo(self, Point2D pt)"""
return _core_.Rect2D_MoveLeftBottomTo(*args, **kwargs)
def GetRightTop(*args, **kwargs):
"""GetRightTop(self) -> Point2D"""
return _core_.Rect2D_GetRightTop(*args, **kwargs)
def SetRightTop(*args, **kwargs):
"""SetRightTop(self, Point2D pt)"""
return _core_.Rect2D_SetRightTop(*args, **kwargs)
def MoveRightTopTo(*args, **kwargs):
"""MoveRightTopTo(self, Point2D pt)"""
return _core_.Rect2D_MoveRightTopTo(*args, **kwargs)
def GetRightBottom(*args, **kwargs):
"""GetRightBottom(self) -> Point2D"""
return _core_.Rect2D_GetRightBottom(*args, **kwargs)
def SetRightBottom(*args, **kwargs):
"""SetRightBottom(self, Point2D pt)"""
return _core_.Rect2D_SetRightBottom(*args, **kwargs)
def MoveRightBottomTo(*args, **kwargs):
"""MoveRightBottomTo(self, Point2D pt)"""
return _core_.Rect2D_MoveRightBottomTo(*args, **kwargs)
def GetCentre(*args, **kwargs):
"""GetCentre(self) -> Point2D"""
return _core_.Rect2D_GetCentre(*args, **kwargs)
def SetCentre(*args, **kwargs):
"""SetCentre(self, Point2D pt)"""
return _core_.Rect2D_SetCentre(*args, **kwargs)
def MoveCentreTo(*args, **kwargs):
"""MoveCentreTo(self, Point2D pt)"""
return _core_.Rect2D_MoveCentreTo(*args, **kwargs)
def GetOutcode(*args, **kwargs):
"""GetOutcode(self, Point2D pt) -> int"""
return _core_.Rect2D_GetOutcode(*args, **kwargs)
def Contains(*args, **kwargs):
"""Contains(self, Point2D pt) -> bool"""
return _core_.Rect2D_Contains(*args, **kwargs)
def ContainsRect(*args, **kwargs):
"""ContainsRect(self, Rect2D rect) -> bool"""
return _core_.Rect2D_ContainsRect(*args, **kwargs)
def IsEmpty(*args, **kwargs):
"""IsEmpty(self) -> bool"""
return _core_.Rect2D_IsEmpty(*args, **kwargs)
def HaveEqualSize(*args, **kwargs):
"""HaveEqualSize(self, Rect2D rect) -> bool"""
return _core_.Rect2D_HaveEqualSize(*args, **kwargs)
def Inset(*args):
"""
Inset(self, wxDouble x, wxDouble y)
Inset(self, wxDouble left, wxDouble top, wxDouble right, wxDouble bottom)
"""
return _core_.Rect2D_Inset(*args)
def Offset(*args, **kwargs):
"""Offset(self, Point2D pt)"""
return _core_.Rect2D_Offset(*args, **kwargs)
def ConstrainTo(*args, **kwargs):
"""ConstrainTo(self, Rect2D rect)"""
return _core_.Rect2D_ConstrainTo(*args, **kwargs)
def Interpolate(*args, **kwargs):
"""Interpolate(self, int widthfactor, int heightfactor) -> Point2D"""
return _core_.Rect2D_Interpolate(*args, **kwargs)
def Intersect(*args, **kwargs):
"""Intersect(self, Rect2D otherRect)"""
return _core_.Rect2D_Intersect(*args, **kwargs)
def CreateIntersection(*args, **kwargs):
"""CreateIntersection(self, Rect2D otherRect) -> Rect2D"""
return _core_.Rect2D_CreateIntersection(*args, **kwargs)
def Intersects(*args, **kwargs):
"""Intersects(self, Rect2D rect) -> bool"""
return _core_.Rect2D_Intersects(*args, **kwargs)
def Union(*args, **kwargs):
"""Union(self, Rect2D otherRect)"""
return _core_.Rect2D_Union(*args, **kwargs)
def CreateUnion(*args, **kwargs):
"""CreateUnion(self, Rect2D otherRect) -> Rect2D"""
return _core_.Rect2D_CreateUnion(*args, **kwargs)
def Scale(*args):
"""
Scale(self, wxDouble f)
Scale(self, int num, int denum)
"""
return _core_.Rect2D_Scale(*args)
def __eq__(*args, **kwargs):
"""
__eq__(self, PyObject other) -> bool
Test for equality of wx.Rect2D objects.
"""
return _core_.Rect2D___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
"""
__ne__(self, PyObject other) -> bool
Test for inequality of wx.Rect2D objects.
"""
return _core_.Rect2D___ne__(*args, **kwargs)
x = property(_core_.Rect2D_x_get, _core_.Rect2D_x_set)
y = property(_core_.Rect2D_y_get, _core_.Rect2D_y_set)
width = property(_core_.Rect2D_width_get, _core_.Rect2D_width_set)
height = property(_core_.Rect2D_height_get, _core_.Rect2D_height_set)
def Set(*args, **kwargs):
"""Set(self, wxDouble x=0, wxDouble y=0, wxDouble width=0, wxDouble height=0)"""
return _core_.Rect2D_Set(*args, **kwargs)
def Get(*args, **kwargs):
"""
Get() -> (x,y, width, height)
Return x, y, width and height y properties as a tuple.
"""
return _core_.Rect2D_Get(*args, **kwargs)
def __str__(self): return str(self.Get())
def __repr__(self): return 'wx.Rect2D'+str(self.Get())
def __len__(self): return len(self.Get())
def __getitem__(self, index): return self.Get()[index]
def __setitem__(self, index, val):
if index == 0: self.x = val
elif index == 1: self.y = val
elif index == 2: self.width = val
elif index == 3: self.height = val
else: raise IndexError
def __nonzero__(self): return self.Get() != (0.0, 0.0, 0.0, 0.0)
__safe_for_unpickling__ = True
def __reduce__(self): return (wx.Rect2D, self.Get())
_core_.Rect2D_swigregister(Rect2D)
#---------------------------------------------------------------------------
FromStart = _core_.FromStart
FromCurrent = _core_.FromCurrent
FromEnd = _core_.FromEnd

2811
wxPython/src/gtk/_core_wrap.cpp
View File

File diff suppressed because it is too large Load Diff

641
wxPython/src/gtk/_gdi.py
View File

@@ -4383,6 +4383,88 @@ _gdi_.DC_swigregister(DC)
#---------------------------------------------------------------------------
class DCTextColourChanger(object):
"""
wx.DCTextColourChanger can be used to temporarily change the DC text
colour and restore it automatically when the object goes out of scope
"""
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, DC dc, Colour col) -> DCTextColourChanger
wx.DCTextColourChanger can be used to temporarily change the DC text
colour and restore it automatically when the object goes out of scope
"""
_gdi_.DCTextColourChanger_swiginit(self,_gdi_.new_DCTextColourChanger(*args, **kwargs))
__swig_destroy__ = _gdi_.delete_DCTextColourChanger
__del__ = lambda self : None;
_gdi_.DCTextColourChanger_swigregister(DCTextColourChanger)
class DCPenChanger(object):
"""
wx.DCPenChanger can be used to temporarily change the DC pen and
restore it automatically when the object goes out of scope
"""
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, DC dc, Pen pen) -> DCPenChanger
wx.DCPenChanger can be used to temporarily change the DC pen and
restore it automatically when the object goes out of scope
"""
_gdi_.DCPenChanger_swiginit(self,_gdi_.new_DCPenChanger(*args, **kwargs))
__swig_destroy__ = _gdi_.delete_DCPenChanger
__del__ = lambda self : None;
_gdi_.DCPenChanger_swigregister(DCPenChanger)
class DCBrushChanger(object):
"""
wx.DCBrushChanger can be used to temporarily change the DC brush and
restore it automatically when the object goes out of scope
"""
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, DC dc, Brush brush) -> DCBrushChanger
wx.DCBrushChanger can be used to temporarily change the DC brush and
restore it automatically when the object goes out of scope
"""
_gdi_.DCBrushChanger_swiginit(self,_gdi_.new_DCBrushChanger(*args, **kwargs))
__swig_destroy__ = _gdi_.delete_DCBrushChanger
__del__ = lambda self : None;
_gdi_.DCBrushChanger_swigregister(DCBrushChanger)
class DCClipper(object):
"""
wx.wxDCClipper sets the DC's clipping region when it is constructed,
and then automatically destroys the clipping region when the clipper
goes out of scope.
"""
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, Region r) -> DCClipper
__init__(self, DC dc, Rect r) -> DCClipper
__init__(self, DC dc, int x, int y, int w, int h) -> DCClipper
wx.wxDCClipper sets the DC's clipping region when it is constructed,
and then automatically destroys the clipping region when the clipper
goes out of scope.
"""
_gdi_.DCClipper_swiginit(self,_gdi_.new_DCClipper(*args))
__swig_destroy__ = _gdi_.delete_DCClipper
__del__ = lambda self : None;
_gdi_.DCClipper_swigregister(DCClipper)
#---------------------------------------------------------------------------
class MemoryDC(DC):
"""
A memory device context provides a means to draw graphics onto a
@@ -4829,38 +4911,105 @@ _gdi_.PrinterDC_swigregister(PrinterDC)
#---------------------------------------------------------------------------
class GraphicsPath(object):
class GraphicsObject(_core.Object):
"""Proxy of C++ GraphicsObject class"""
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, GraphicsRenderer renderer=None) -> GraphicsObject"""
_gdi_.GraphicsObject_swiginit(self,_gdi_.new_GraphicsObject(*args, **kwargs))
__swig_destroy__ = _gdi_.delete_GraphicsObject
__del__ = lambda self : None;
def IsNull(*args, **kwargs):
"""IsNull(self) -> bool"""
return _gdi_.GraphicsObject_IsNull(*args, **kwargs)
def GetRenderer(*args, **kwargs):
"""GetRenderer(self) -> GraphicsRenderer"""
return _gdi_.GraphicsObject_GetRenderer(*args, **kwargs)
_gdi_.GraphicsObject_swigregister(GraphicsObject)
class GraphicsPen(GraphicsObject):
"""Proxy of C++ GraphicsPen class"""
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) -> GraphicsPen"""
_gdi_.GraphicsPen_swiginit(self,_gdi_.new_GraphicsPen(*args, **kwargs))
__swig_destroy__ = _gdi_.delete_GraphicsPen
__del__ = lambda self : None;
_gdi_.GraphicsPen_swigregister(GraphicsPen)
class GraphicsBrush(GraphicsObject):
"""Proxy of C++ GraphicsBrush class"""
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) -> GraphicsBrush"""
_gdi_.GraphicsBrush_swiginit(self,_gdi_.new_GraphicsBrush(*args, **kwargs))
__swig_destroy__ = _gdi_.delete_GraphicsBrush
__del__ = lambda self : None;
_gdi_.GraphicsBrush_swigregister(GraphicsBrush)
class GraphicsFont(GraphicsObject):
"""Proxy of C++ GraphicsFont class"""
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) -> GraphicsFont"""
_gdi_.GraphicsFont_swiginit(self,_gdi_.new_GraphicsFont(*args, **kwargs))
__swig_destroy__ = _gdi_.delete_GraphicsFont
__del__ = lambda self : None;
_gdi_.GraphicsFont_swigregister(GraphicsFont)
class GraphicsPath(GraphicsObject):
"""Proxy of C++ GraphicsPath class"""
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"
__repr__ = _swig_repr
__swig_destroy__ = _gdi_.delete_GraphicsPath
__del__ = lambda self : None;
def MoveToPoint(*args, **kwargs):
def Clone(*args, **kwargs):
"""Clone(self) -> GraphicsPath"""
return _gdi_.GraphicsPath_Clone(*args, **kwargs)
def MoveToPoint(*args):
"""
MoveToPoint(self, Double x, Double y)
MoveToPoint(self, Point2D p)
Begins a new subpath at (x,y)
"""
return _gdi_.GraphicsPath_MoveToPoint(*args, **kwargs)
return _gdi_.GraphicsPath_MoveToPoint(*args)
def AddLineToPoint(*args, **kwargs):
def AddLineToPoint(*args):
"""
AddLineToPoint(self, Double x, Double y)
AddLineToPoint(self, Point2D p)
Adds a straight line from the current point to (x,y)
"""
return _gdi_.GraphicsPath_AddLineToPoint(*args, **kwargs)
return _gdi_.GraphicsPath_AddLineToPoint(*args)
def AddCurveToPoint(*args, **kwargs):
def AddCurveToPoint(*args):
"""
AddCurveToPoint(self, Double cx1, Double cy1, Double cx2, Double cy2, Double x,
Double y)
AddCurveToPoint(self, Point2D c1, Point2D c2, Point2D e)
Adds a cubic Bezier curve from the current point, using two control
points and an end point
"""
return _gdi_.GraphicsPath_AddCurveToPoint(*args, **kwargs)
return _gdi_.GraphicsPath_AddCurveToPoint(*args)
def AddPath(*args, **kwargs):
"""
AddPath(self, GraphicsPath path)
adds another path
"""
return _gdi_.GraphicsPath_AddPath(*args, **kwargs)
def CloseSubpath(*args, **kwargs):
"""
@@ -4878,15 +5027,17 @@ class GraphicsPath(object):
"""
return _gdi_.GraphicsPath_GetCurrentPoint(*args, **kwargs)
def AddArc(*args, **kwargs):
def AddArc(*args):
"""
AddArc(self, Double x, Double y, Double r, Double startAngle, Double endAngle,
bool clockwise)
AddArc(self, Point2D c, Double r, Double startAngle, Double endAngle,
bool clockwise)
Adds an arc of a circle centering at (x,y) with radius (r) from
startAngle to endAngle
"""
return _gdi_.GraphicsPath_AddArc(*args, **kwargs)
return _gdi_.GraphicsPath_AddArc(*args)
def AddQuadCurveToPoint(*args, **kwargs):
"""
@@ -4922,9 +5073,179 @@ class GraphicsPath(object):
"""
return _gdi_.GraphicsPath_AddArcToPoint(*args, **kwargs)
_gdi_.GraphicsPath_swigregister(GraphicsPath)
def AddEllipse(*args, **kwargs):
"""
AddEllipse(self, Double x, Double y, Double w, Double h)
class GraphicsContext(object):
appends an ellipse
"""
return _gdi_.GraphicsPath_AddEllipse(*args, **kwargs)
def AddRoundedRectangle(*args, **kwargs):
"""
AddRoundedRectangle(self, Double x, Double y, Double w, Double h, Double radius)
appends a rounded rectangle
"""
return _gdi_.GraphicsPath_AddRoundedRectangle(*args, **kwargs)
def GetNativePath(*args, **kwargs):
"""
GetNativePath(self) -> void
returns the native path
"""
return _gdi_.GraphicsPath_GetNativePath(*args, **kwargs)
def UnGetNativePath(*args, **kwargs):
"""
UnGetNativePath(self, void p)
give the native path returned by GetNativePath() back (there might be some
deallocations necessary)
"""
return _gdi_.GraphicsPath_UnGetNativePath(*args, **kwargs)
def Transform(*args, **kwargs):
"""
Transform(self, GraphicsMatrix matrix)
transforms each point of this path by the matrix
"""
return _gdi_.GraphicsPath_Transform(*args, **kwargs)
def GetBox(*args, **kwargs):
"""
GetBox(self) -> wxRect2DDouble
gets the bounding box enclosing all points (possibly including control points)
"""
return _gdi_.GraphicsPath_GetBox(*args, **kwargs)
def Contains(*args):
"""
Contains(self, Double x, Double y, int fillStyle=WINDING_RULE) -> bool
Contains(self, wxPoint2DDouble c, int fillStyle=WINDING_RULE) -> bool
"""
return _gdi_.GraphicsPath_Contains(*args)
_gdi_.GraphicsPath_swigregister(GraphicsPath)
cvar = _gdi_.cvar
NullGraphicsPen = cvar.NullGraphicsPen
NullGraphicsBrush = cvar.NullGraphicsBrush
NullGraphicsFont = cvar.NullGraphicsFont
class GraphicsMatrix(GraphicsObject):
"""Proxy of C++ GraphicsMatrix class"""
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"
__repr__ = _swig_repr
__swig_destroy__ = _gdi_.delete_GraphicsMatrix
__del__ = lambda self : None;
def Clone(*args, **kwargs):
"""Clone(self) -> GraphicsMatrix"""
return _gdi_.GraphicsMatrix_Clone(*args, **kwargs)
def Concat(*args, **kwargs):
"""
Concat(self, GraphicsMatrix t)
concatenates the matrix
"""
return _gdi_.GraphicsMatrix_Concat(*args, **kwargs)
def Copy(*args, **kwargs):
"""
Copy(self, GraphicsMatrix t)
copies the passed in matrix
"""
return _gdi_.GraphicsMatrix_Copy(*args, **kwargs)
def Set(*args, **kwargs):
"""
Set(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0,
Double tx=0.0, Double ty=0.0)
sets the matrix to the respective values
"""
return _gdi_.GraphicsMatrix_Set(*args, **kwargs)
def Invert(*args, **kwargs):
"""
Invert(self)
makes this the inverse matrix
"""
return _gdi_.GraphicsMatrix_Invert(*args, **kwargs)
def IsEqual(*args, **kwargs):
"""
IsEqual(self, GraphicsMatrix t) -> bool
returns true if the elements of the transformation matrix are equal
"""
return _gdi_.GraphicsMatrix_IsEqual(*args, **kwargs)
def IsIdentity(*args, **kwargs):
"""
IsIdentity(self) -> bool
return true if this is the identity matrix
"""
return _gdi_.GraphicsMatrix_IsIdentity(*args, **kwargs)
def Translate(*args, **kwargs):
"""
Translate(self, Double dx, Double dy)
add the translation to this matrix
"""
return _gdi_.GraphicsMatrix_Translate(*args, **kwargs)
def Scale(*args, **kwargs):
"""
Scale(self, Double xScale, Double yScale)
add the scale to this matrix
"""
return _gdi_.GraphicsMatrix_Scale(*args, **kwargs)
def Rotate(*args, **kwargs):
"""
Rotate(self, Double angle)
add the rotation to this matrix (radians)
"""
return _gdi_.GraphicsMatrix_Rotate(*args, **kwargs)
def TransformPoint(*args, **kwargs):
"""
TransformPoint(self, x, y) --> (x, y)
applies that matrix to the point
"""
return _gdi_.GraphicsMatrix_TransformPoint(*args, **kwargs)
def TransformDistance(*args, **kwargs):
"""
TransformDistance(self, dx, dy) --> (dx, dy)
applies the matrix except for translations
"""
return _gdi_.GraphicsMatrix_TransformDistance(*args, **kwargs)
def GetNativeMatrix(*args, **kwargs):
"""
GetNativeMatrix(self) -> void
returns the native representation
"""
return _gdi_.GraphicsMatrix_GetNativeMatrix(*args, **kwargs)
_gdi_.GraphicsMatrix_swigregister(GraphicsMatrix)
class GraphicsContext(GraphicsObject):
"""Proxy of C++ GraphicsContext class"""
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"
@@ -4946,86 +5267,187 @@ class GraphicsContext(object):
return _gdi_.GraphicsContext_CreateFromNative(*args, **kwargs)
CreateFromNative = staticmethod(CreateFromNative)
def CreateFromNativeWindow(*args, **kwargs):
"""CreateFromNativeWindow(void window) -> GraphicsContext"""
return _gdi_.GraphicsContext_CreateFromNativeWindow(*args, **kwargs)
CreateFromNativeWindow = staticmethod(CreateFromNativeWindow)
def CreatePath(*args, **kwargs):
"""CreatePath(self) -> GraphicsPath"""
"""
CreatePath(self) -> GraphicsPath
creates a path instance that corresponds to the type of graphics context, ie GDIPlus, Cairo, CoreGraphics ...
"""
return _gdi_.GraphicsContext_CreatePath(*args, **kwargs)
def CreatePen(*args, **kwargs):
"""CreatePen(self, Pen pen) -> GraphicsPen"""
return _gdi_.GraphicsContext_CreatePen(*args, **kwargs)
def CreateBrush(*args, **kwargs):
"""CreateBrush(self, Brush brush) -> GraphicsBrush"""
return _gdi_.GraphicsContext_CreateBrush(*args, **kwargs)
def CreateLinearGradientBrush(*args, **kwargs):
"""
CreateLinearGradientBrush(self, Double x1, Double y1, Double x2, Double y2, Colour c1,
Colour c2) -> GraphicsBrush
sets the brush to a linear gradient, starting at (x1,y1) with color c1
to (x2,y2) with color c2
"""
return _gdi_.GraphicsContext_CreateLinearGradientBrush(*args, **kwargs)
def CreateRadialGradientBrush(*args, **kwargs):
"""
CreateRadialGradientBrush(self, Double xo, Double yo, Double xc, Double yc, Double radius,
Colour oColor, Colour cColor) -> GraphicsBrush
sets the brush to a radial gradient originating at (xo,yc) with color
oColor and ends on a circle around (xc,yc) with radius r and color
cColor
"""
return _gdi_.GraphicsContext_CreateRadialGradientBrush(*args, **kwargs)
def CreateFont(*args, **kwargs):
"""
CreateFont(self, Font font, Colour col=*wxBLACK) -> GraphicsFont
sets the font
"""
return _gdi_.GraphicsContext_CreateFont(*args, **kwargs)
def CreateMatrix(*args, **kwargs):
"""
CreateMatrix(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0,
Double tx=0.0, Double ty=0.0) -> GraphicsMatrix
create a 'native' matrix corresponding to these values
"""
return _gdi_.GraphicsContext_CreateMatrix(*args, **kwargs)
def PushState(*args, **kwargs):
"""PushState(self)"""
"""
PushState(self)
push the current state of the context, ie the transformation matrix on a stack
"""
return _gdi_.GraphicsContext_PushState(*args, **kwargs)
def PopState(*args, **kwargs):
"""PopState(self)"""
"""
PopState(self)
pops a stored state from the stack
"""
return _gdi_.GraphicsContext_PopState(*args, **kwargs)
def ClipRegion(*args, **kwargs):
"""ClipRegion(self, Region region)"""
"""
ClipRegion(self, Region region)
clips drawings to the region
"""
return _gdi_.GraphicsContext_ClipRegion(*args, **kwargs)
def Clip(*args, **kwargs):
"""Clip(self, Double x, Double y, Double w, Double h)"""
"""
Clip(self, Double x, Double y, Double w, Double h)
clips drawings to the rect
"""
return _gdi_.GraphicsContext_Clip(*args, **kwargs)
def ResetClip(*args, **kwargs):
"""ResetClip(self)"""
"""
ResetClip(self)
resets the clipping to original extent
"""
return _gdi_.GraphicsContext_ResetClip(*args, **kwargs)
def GetNativeContext(*args, **kwargs):
"""GetNativeContext(self) -> void"""
"""
GetNativeContext(self) -> void
returns the native context
"""
return _gdi_.GraphicsContext_GetNativeContext(*args, **kwargs)
def Translate(*args, **kwargs):
"""Translate(self, Double dx, Double dy)"""
"""
Translate(self, Double dx, Double dy)
translate the current transformation matrix CTM of the context
"""
return _gdi_.GraphicsContext_Translate(*args, **kwargs)
def Scale(*args, **kwargs):
"""Scale(self, Double xScale, Double yScale)"""
"""
Scale(self, Double xScale, Double yScale)
scale the current transformation matrix CTM of the context
"""
return _gdi_.GraphicsContext_Scale(*args, **kwargs)
def Rotate(*args, **kwargs):
"""Rotate(self, Double angle)"""
"""
Rotate(self, Double angle)
rotate (radians) the current transformation matrix CTM of the context
"""
return _gdi_.GraphicsContext_Rotate(*args, **kwargs)
def SetPen(*args, **kwargs):
"""SetPen(self, Pen pen)"""
return _gdi_.GraphicsContext_SetPen(*args, **kwargs)
def SetBrush(*args, **kwargs):
"""SetBrush(self, Brush brush)"""
return _gdi_.GraphicsContext_SetBrush(*args, **kwargs)
def SetLinearGradientBrush(*args, **kwargs):
def SetPen(*args):
"""
SetLinearGradientBrush(self, Double x1, Double y1, Double x2, Double y2, Colour c1,
Colour c2)
"""
return _gdi_.GraphicsContext_SetLinearGradientBrush(*args, **kwargs)
SetPen(self, GraphicsPen pen)
SetPen(self, Pen pen)
def SetRadialGradientBrush(*args, **kwargs):
sets the stroke pen
"""
SetRadialGradientBrush(self, Double xo, Double yo, Double xc, Double yc, Double radius,
Colour oColour, Colour cColour)
return _gdi_.GraphicsContext_SetPen(*args)
def SetBrush(*args):
"""
return _gdi_.GraphicsContext_SetRadialGradientBrush(*args, **kwargs)
SetBrush(self, GraphicsBrush brush)
SetBrush(self, Brush brush)
def SetFont(*args, **kwargs):
"""SetFont(self, Font font)"""
return _gdi_.GraphicsContext_SetFont(*args, **kwargs)
sets the brush for filling
"""
return _gdi_.GraphicsContext_SetBrush(*args)
def SetTextColour(*args, **kwargs):
"""SetTextColour(self, Colour col)"""
return _gdi_.GraphicsContext_SetTextColour(*args, **kwargs)
def SetFont(*args):
"""
SetFont(self, GraphicsFont font)
SetFont(self, Font font, Colour colour=*wxBLACK)
sets the font
"""
return _gdi_.GraphicsContext_SetFont(*args)
def StrokePath(*args, **kwargs):
"""StrokePath(self, GraphicsPath path)"""
"""
StrokePath(self, GraphicsPath path)
strokes along a path with the current pen
"""
return _gdi_.GraphicsContext_StrokePath(*args, **kwargs)
def FillPath(*args, **kwargs):
"""FillPath(self, GraphicsPath path, int fillStyle=WINDING_RULE)"""
"""
FillPath(self, GraphicsPath path, int fillStyle=WINDING_RULE)
fills a path with the current brush
"""
return _gdi_.GraphicsContext_FillPath(*args, **kwargs)
def DrawPath(*args, **kwargs):
"""DrawPath(self, GraphicsPath path, int fillStyle=WINDING_RULE)"""
"""
DrawPath(self, GraphicsPath path, int fillStyle=WINDING_RULE)
draws a path by first filling and then stroking
"""
return _gdi_.GraphicsContext_DrawPath(*args, **kwargs)
def DrawText(*args, **kwargs):
@@ -5057,33 +5479,69 @@ class GraphicsContext(object):
return _gdi_.GraphicsContext_DrawIcon(*args, **kwargs)
def StrokeLine(*args, **kwargs):
"""StrokeLine(self, Double x1, Double y1, Double x2, Double y2)"""
"""
StrokeLine(self, Double x1, Double y1, Double x2, Double y2)
strokes a single line
"""
return _gdi_.GraphicsContext_StrokeLine(*args, **kwargs)
def StrokeLines(*args, **kwargs):
"""StrokeLines(self, List points)"""
"""
StrokeLines(self, List points)
stroke lines connecting each of the points
"""
return _gdi_.GraphicsContext_StrokeLines(*args, **kwargs)
def StrokeLineSegements(*args, **kwargs):
"""StrokeLineSegements(self, PyObject beginPoints, PyObject endPoints)"""
"""
StrokeLineSegements(self, PyObject beginPoints, PyObject endPoints)
stroke disconnected lines from begin to end points
"""
return _gdi_.GraphicsContext_StrokeLineSegements(*args, **kwargs)
def DrawLines(*args, **kwargs):
"""DrawLines(self, size_t points, int fillStyle=WINDING_RULE)"""
"""
DrawLines(self, size_t points, int fillStyle=WINDING_RULE)
draws a polygon
"""
return _gdi_.GraphicsContext_DrawLines(*args, **kwargs)
def DrawRectangle(*args, **kwargs):
"""DrawRectangle(self, Double x, Double y, Double w, Double h)"""
"""
DrawRectangle(self, Double x, Double y, Double w, Double h)
draws a rectangle
"""
return _gdi_.GraphicsContext_DrawRectangle(*args, **kwargs)
def DrawEllipse(*args, **kwargs):
"""DrawEllipse(self, Double x, Double y, Double w, Double h)"""
"""
DrawEllipse(self, Double x, Double y, Double w, Double h)
draws an ellipse
"""
return _gdi_.GraphicsContext_DrawEllipse(*args, **kwargs)
def DrawRoundedRectangle(*args, **kwargs):
"""DrawRoundedRectangle(self, Double x, Double y, Double w, Double h, Double radius)"""
"""
DrawRoundedRectangle(self, Double x, Double y, Double w, Double h, Double radius)
draws a rounded rectangle
"""
return _gdi_.GraphicsContext_DrawRoundedRectangle(*args, **kwargs)
def ShouldOffset(*args, **kwargs):
"""
ShouldOffset(self) -> bool
helper to determine if a 0.5 offset should be applied for the drawing operation
"""
return _gdi_.GraphicsContext_ShouldOffset(*args, **kwargs)
_gdi_.GraphicsContext_swigregister(GraphicsContext)
def GraphicsContext_Create(*args):
@@ -5099,6 +5557,80 @@ def GraphicsContext_CreateFromNative(*args, **kwargs):
"""GraphicsContext_CreateFromNative(void context) -> GraphicsContext"""
return _gdi_.GraphicsContext_CreateFromNative(*args, **kwargs)
def GraphicsContext_CreateFromNativeWindow(*args, **kwargs):
"""GraphicsContext_CreateFromNativeWindow(void window) -> GraphicsContext"""
return _gdi_.GraphicsContext_CreateFromNativeWindow(*args, **kwargs)
class GraphicsRenderer(_core.Object):
"""Proxy of C++ GraphicsRenderer class"""
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"
__repr__ = _swig_repr
__swig_destroy__ = _gdi_.delete_GraphicsRenderer
__del__ = lambda self : None;
def GetDefaultRenderer(*args, **kwargs):
"""GetDefaultRenderer() -> GraphicsRenderer"""
return _gdi_.GraphicsRenderer_GetDefaultRenderer(*args, **kwargs)
GetDefaultRenderer = staticmethod(GetDefaultRenderer)
def CreateContext(*args):
"""
CreateContext(self, WindowDC dc) -> GraphicsContext
CreateContext(self, Window window) -> GraphicsContext
"""
return _gdi_.GraphicsRenderer_CreateContext(*args)
def CreateContextFromNativeContext(*args, **kwargs):
"""CreateContextFromNativeContext(self, void context) -> GraphicsContext"""
return _gdi_.GraphicsRenderer_CreateContextFromNativeContext(*args, **kwargs)
def CreateContextFromNativeWindow(*args, **kwargs):
"""CreateContextFromNativeWindow(self, void window) -> GraphicsContext"""
return _gdi_.GraphicsRenderer_CreateContextFromNativeWindow(*args, **kwargs)
def CreatePath(*args, **kwargs):
"""CreatePath(self) -> GraphicsPath"""
return _gdi_.GraphicsRenderer_CreatePath(*args, **kwargs)
def CreateMatrix(*args, **kwargs):
"""
CreateMatrix(self, Double a=1.0, Double b=0.0, Double c=0.0, Double d=1.0,
Double tx=0.0, Double ty=0.0) -> GraphicsMatrix
"""
return _gdi_.GraphicsRenderer_CreateMatrix(*args, **kwargs)
def CreatePen(*args, **kwargs):
"""CreatePen(self, Pen pen) -> GraphicsPen"""
return _gdi_.GraphicsRenderer_CreatePen(*args, **kwargs)
def CreateBrush(*args, **kwargs):
"""CreateBrush(self, Brush brush) -> GraphicsBrush"""
return _gdi_.GraphicsRenderer_CreateBrush(*args, **kwargs)
def CreateLinearGradientBrush(*args, **kwargs):
"""
CreateLinearGradientBrush(self, Double x1, Double y1, Double x2, Double y2, Colour c1,
Colour c2) -> GraphicsBrush
"""
return _gdi_.GraphicsRenderer_CreateLinearGradientBrush(*args, **kwargs)
def CreateRadialGradientBrush(*args, **kwargs):
"""
CreateRadialGradientBrush(self, Double xo, Double yo, Double xc, Double yc, Double radius,
Colour oColor, Colour cColor) -> GraphicsBrush
"""
return _gdi_.GraphicsRenderer_CreateRadialGradientBrush(*args, **kwargs)
def CreateFont(*args, **kwargs):
"""CreateFont(self, Font font, Colour col=*wxBLACK) -> GraphicsFont"""
return _gdi_.GraphicsRenderer_CreateFont(*args, **kwargs)
_gdi_.GraphicsRenderer_swigregister(GraphicsRenderer)
def GraphicsRenderer_GetDefaultRenderer(*args):
"""GraphicsRenderer_GetDefaultRenderer() -> GraphicsRenderer"""
return _gdi_.GraphicsRenderer_GetDefaultRenderer(*args)
class GCDC(DC):
"""Proxy of C++ GCDC class"""
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
@@ -5430,7 +5962,6 @@ class GDIObjListBase(object):
__swig_destroy__ = _gdi_.delete_GDIObjListBase
__del__ = lambda self : None;
_gdi_.GDIObjListBase_swigregister(GDIObjListBase)
cvar = _gdi_.cvar
NullBitmap = cvar.NullBitmap
NullIcon = cvar.NullIcon
NullCursor = cvar.NullCursor

4383
wxPython/src/gtk/_gdi_wrap.cpp
View File

File diff suppressed because one or more lines are too long

64
wxPython/src/gtk/_windows.py
View File

@@ -397,6 +397,10 @@ class TopLevelWindow(_core.Window):
"""GetTitle(self) -> String"""
return _windows_.TopLevelWindow_GetTitle(*args, **kwargs)
def EnableCloseButton(*args, **kwargs):
"""EnableCloseButton(self, bool enable) -> bool"""
return _windows_.TopLevelWindow_EnableCloseButton(*args, **kwargs)
def SetShape(*args, **kwargs):
"""SetShape(self, Region region) -> bool"""
return _windows_.TopLevelWindow_SetShape(*args, **kwargs)
@@ -426,10 +430,6 @@ class TopLevelWindow(_core.Window):
return _windows_.TopLevelWindow_CenterOnScreen(*args, **kwargs)
CentreOnScreen = CenterOnScreen
def EnableCloseButton(*args, **kwargs):
"""EnableCloseButton(self, bool enable=True) -> bool"""
return _windows_.TopLevelWindow_EnableCloseButton(*args, **kwargs)
def GetDefaultItem(*args, **kwargs):
"""
GetDefaultItem(self) -> Window
@@ -4403,6 +4403,54 @@ class Printout(_core.Object):
"""SetDC(self, DC dc)"""
return _windows_.Printout_SetDC(*args, **kwargs)
def FitThisSizeToPaper(*args, **kwargs):
"""FitThisSizeToPaper(self, Size imageSize)"""
return _windows_.Printout_FitThisSizeToPaper(*args, **kwargs)
def FitThisSizeToPage(*args, **kwargs):
"""FitThisSizeToPage(self, Size imageSize)"""
return _windows_.Printout_FitThisSizeToPage(*args, **kwargs)
def FitThisSizeToPageMargins(*args, **kwargs):
"""FitThisSizeToPageMargins(self, Size imageSize, PageSetupDialogData pageSetupData)"""
return _windows_.Printout_FitThisSizeToPageMargins(*args, **kwargs)
def MapScreenSizeToPaper(*args, **kwargs):
"""MapScreenSizeToPaper(self)"""
return _windows_.Printout_MapScreenSizeToPaper(*args, **kwargs)
def MapScreenSizeToPage(*args, **kwargs):
"""MapScreenSizeToPage(self)"""
return _windows_.Printout_MapScreenSizeToPage(*args, **kwargs)
def MapScreenSizeToPageMargins(*args, **kwargs):
"""MapScreenSizeToPageMargins(self, PageSetupDialogData pageSetupData)"""
return _windows_.Printout_MapScreenSizeToPageMargins(*args, **kwargs)
def MapScreenSizeToDevice(*args, **kwargs):
"""MapScreenSizeToDevice(self)"""
return _windows_.Printout_MapScreenSizeToDevice(*args, **kwargs)
def GetLogicalPaperRect(*args, **kwargs):
"""GetLogicalPaperRect(self) -> Rect"""
return _windows_.Printout_GetLogicalPaperRect(*args, **kwargs)
def GetLogicalPageRect(*args, **kwargs):
"""GetLogicalPageRect(self) -> Rect"""
return _windows_.Printout_GetLogicalPageRect(*args, **kwargs)
def GetLogicalPageMarginsRect(*args, **kwargs):
"""GetLogicalPageMarginsRect(self, PageSetupDialogData pageSetupData) -> Rect"""
return _windows_.Printout_GetLogicalPageMarginsRect(*args, **kwargs)
def SetLogicalOrigin(*args, **kwargs):
"""SetLogicalOrigin(self, int x, int y)"""
return _windows_.Printout_SetLogicalOrigin(*args, **kwargs)
def OffsetLogicalOrigin(*args, **kwargs):
"""OffsetLogicalOrigin(self, int xoff, int yoff)"""
return _windows_.Printout_OffsetLogicalOrigin(*args, **kwargs)
def SetPageSizePixels(*args, **kwargs):
"""SetPageSizePixels(self, int w, int h)"""
return _windows_.Printout_SetPageSizePixels(*args, **kwargs)
@@ -4435,6 +4483,14 @@ class Printout(_core.Object):
"""GetPPIPrinter() -> (x,y)"""
return _windows_.Printout_GetPPIPrinter(*args, **kwargs)
def SetPaperRectPixels(*args, **kwargs):
"""SetPaperRectPixels(self, Rect paperRectPixels)"""
return _windows_.Printout_SetPaperRectPixels(*args, **kwargs)
def GetPaperRectPixels(*args, **kwargs):
"""GetPaperRectPixels(self) -> Rect"""
return _windows_.Printout_GetPaperRectPixels(*args, **kwargs)
def IsPreview(*args, **kwargs):
"""IsPreview(self) -> bool"""
return _windows_.Printout_IsPreview(*args, **kwargs)

599
wxPython/src/gtk/_windows_wrap.cpp
View File

@@ -2822,7 +2822,6 @@ SWIG_AsVal_double (PyObject *obj, double* val)
static const wxString wxPyToolBarNameStr(wxToolBarNameStr);
SWIGINTERN void wxTopLevelWindow_MacSetMetalAppearance(wxTopLevelWindow *self,bool on){ /*wxPyRaiseNotImplemented();*/ }
SWIGINTERN bool wxTopLevelWindow_MacGetMetalAppearance(wxTopLevelWindow const *self){ /*wxPyRaiseNotImplemented();*/ return false; }
SWIGINTERN bool wxTopLevelWindow_EnableCloseButton(wxTopLevelWindow *self,bool enable=true){ return false; }
SWIGINTERN wxRect wxStatusBar_GetFieldRect(wxStatusBar *self,int i){
@@ -5761,6 +5760,47 @@ fail:
}
SWIGINTERN PyObject *_wrap_TopLevelWindow_EnableCloseButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
bool arg2 ;
bool result;
void *argp1 = 0 ;
int res1 = 0 ;
bool val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "enable", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:TopLevelWindow_EnableCloseButton",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTopLevelWindow, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TopLevelWindow_EnableCloseButton" "', expected argument " "1"" of type '" "wxTopLevelWindow *""'");
}
arg1 = reinterpret_cast< wxTopLevelWindow * >(argp1);
ecode2 = SWIG_AsVal_bool(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TopLevelWindow_EnableCloseButton" "', expected argument " "2"" of type '" "bool""'");
}
arg2 = static_cast< bool >(val2);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = (bool)(arg1)->EnableCloseButton(arg2);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
{
resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_TopLevelWindow_SetShape(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
@@ -5983,49 +6023,6 @@ fail:
}
SWIGINTERN PyObject *_wrap_TopLevelWindow_EnableCloseButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
bool arg2 = (bool) true ;
bool result;
void *argp1 = 0 ;
int res1 = 0 ;
bool val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "enable", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:TopLevelWindow_EnableCloseButton",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxTopLevelWindow, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "TopLevelWindow_EnableCloseButton" "', expected argument " "1"" of type '" "wxTopLevelWindow *""'");
}
arg1 = reinterpret_cast< wxTopLevelWindow * >(argp1);
if (obj1) {
ecode2 = SWIG_AsVal_bool(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "TopLevelWindow_EnableCloseButton" "', expected argument " "2"" of type '" "bool""'");
}
arg2 = static_cast< bool >(val2);
}
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = (bool)wxTopLevelWindow_EnableCloseButton(arg1,arg2);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
{
resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_TopLevelWindow_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
@@ -27918,6 +27915,440 @@ fail:
}
SWIGINTERN PyObject *_wrap_Printout_FitThisSizeToPaper(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
wxSize *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
wxSize temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "imageSize", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_FitThisSizeToPaper",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_FitThisSizeToPaper" "', expected argument " "1"" of type '" "wxPyPrintout *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
{
arg2 = &temp2;
if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
}
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
(arg1)->FitThisSizeToPaper((wxSize const &)*arg2);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_FitThisSizeToPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
wxSize *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
wxSize temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "imageSize", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_FitThisSizeToPage",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_FitThisSizeToPage" "', expected argument " "1"" of type '" "wxPyPrintout *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
{
arg2 = &temp2;
if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
}
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
(arg1)->FitThisSizeToPage((wxSize const &)*arg2);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_FitThisSizeToPageMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
wxSize *arg2 = 0 ;
wxPageSetupDialogData *arg3 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
wxSize temp2 ;
void *argp3 = 0 ;
int res3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "imageSize",(char *) "pageSetupData", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_FitThisSizeToPageMargins",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_FitThisSizeToPageMargins" "', expected argument " "1"" of type '" "wxPyPrintout *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
{
arg2 = &temp2;
if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
}
res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxPageSetupDialogData, 0 | 0);
if (!SWIG_IsOK(res3)) {
SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Printout_FitThisSizeToPageMargins" "', expected argument " "3"" of type '" "wxPageSetupDialogData const &""'");
}
if (!argp3) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Printout_FitThisSizeToPageMargins" "', expected argument " "3"" of type '" "wxPageSetupDialogData const &""'");
}
arg3 = reinterpret_cast< wxPageSetupDialogData * >(argp3);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
(arg1)->FitThisSizeToPageMargins((wxSize const &)*arg2,(wxPageSetupDialogData const &)*arg3);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_MapScreenSizeToPaper(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
if (!args) SWIG_fail;
swig_obj[0] = args;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_MapScreenSizeToPaper" "', expected argument " "1"" of type '" "wxPyPrintout *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
(arg1)->MapScreenSizeToPaper();
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_MapScreenSizeToPage(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
if (!args) SWIG_fail;
swig_obj[0] = args;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_MapScreenSizeToPage" "', expected argument " "1"" of type '" "wxPyPrintout *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
(arg1)->MapScreenSizeToPage();
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_MapScreenSizeToPageMargins(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
wxPageSetupDialogData *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "pageSetupData", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_MapScreenSizeToPageMargins",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_MapScreenSizeToPageMargins" "', expected argument " "1"" of type '" "wxPyPrintout *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPageSetupDialogData, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Printout_MapScreenSizeToPageMargins" "', expected argument " "2"" of type '" "wxPageSetupDialogData const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Printout_MapScreenSizeToPageMargins" "', expected argument " "2"" of type '" "wxPageSetupDialogData const &""'");
}
arg2 = reinterpret_cast< wxPageSetupDialogData * >(argp2);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
(arg1)->MapScreenSizeToPageMargins((wxPageSetupDialogData const &)*arg2);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_MapScreenSizeToDevice(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
if (!args) SWIG_fail;
swig_obj[0] = args;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_MapScreenSizeToDevice" "', expected argument " "1"" of type '" "wxPyPrintout *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
(arg1)->MapScreenSizeToDevice();
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_GetLogicalPaperRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
wxRect result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
if (!args) SWIG_fail;
swig_obj[0] = args;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_GetLogicalPaperRect" "', expected argument " "1"" of type '" "wxPyPrintout const *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = ((wxPyPrintout const *)arg1)->GetLogicalPaperRect();
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_GetLogicalPageRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
wxRect result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
if (!args) SWIG_fail;
swig_obj[0] = args;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_GetLogicalPageRect" "', expected argument " "1"" of type '" "wxPyPrintout const *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = ((wxPyPrintout const *)arg1)->GetLogicalPageRect();
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_GetLogicalPageMarginsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
wxPageSetupDialogData *arg2 = 0 ;
wxRect result;
void *argp1 = 0 ;
int res1 = 0 ;
void *argp2 = 0 ;
int res2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "pageSetupData", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_GetLogicalPageMarginsRect",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_GetLogicalPageMarginsRect" "', expected argument " "1"" of type '" "wxPyPrintout const *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPageSetupDialogData, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Printout_GetLogicalPageMarginsRect" "', expected argument " "2"" of type '" "wxPageSetupDialogData const &""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Printout_GetLogicalPageMarginsRect" "', expected argument " "2"" of type '" "wxPageSetupDialogData const &""'");
}
arg2 = reinterpret_cast< wxPageSetupDialogData * >(argp2);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = ((wxPyPrintout const *)arg1)->GetLogicalPageMarginsRect((wxPageSetupDialogData const &)*arg2);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_SetLogicalOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
int arg2 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "x",(char *) "y", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_SetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_SetLogicalOrigin" "', expected argument " "1"" of type '" "wxPyPrintout *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Printout_SetLogicalOrigin" "', expected argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Printout_SetLogicalOrigin" "', expected argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
(arg1)->SetLogicalOrigin(arg2,arg3);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_OffsetLogicalOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
int arg2 ;
int arg3 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
int val3 ;
int ecode3 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "xoff",(char *) "yoff", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Printout_OffsetLogicalOrigin",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_OffsetLogicalOrigin" "', expected argument " "1"" of type '" "wxPyPrintout *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Printout_OffsetLogicalOrigin" "', expected argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Printout_OffsetLogicalOrigin" "', expected argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
(arg1)->OffsetLogicalOrigin(arg2,arg3);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_SetPageSizePixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
@@ -28294,6 +28725,70 @@ fail:
}
SWIGINTERN PyObject *_wrap_Printout_SetPaperRectPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
wxRect *arg2 = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
wxRect temp2 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "paperRectPixels", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Printout_SetPaperRectPixels",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_SetPaperRectPixels" "', expected argument " "1"" of type '" "wxPyPrintout *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
{
arg2 = &temp2;
if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
}
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
(arg1)->SetPaperRectPixels((wxRect const &)*arg2);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_GetPaperRectPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
wxRect result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
if (!args) SWIG_fail;
swig_obj[0] = args;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyPrintout, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Printout_GetPaperRectPixels" "', expected argument " "1"" of type '" "wxPyPrintout const *""'");
}
arg1 = reinterpret_cast< wxPyPrintout * >(argp1);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = ((wxPyPrintout const *)arg1)->GetPaperRectPixels();
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_Printout_IsPreview(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxPyPrintout *arg1 = (wxPyPrintout *) 0 ;
@@ -30983,13 +31478,13 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"TopLevelWindow_IsFullScreen", (PyCFunction)_wrap_TopLevelWindow_IsFullScreen, METH_O, NULL},
{ (char *)"TopLevelWindow_SetTitle", (PyCFunction) _wrap_TopLevelWindow_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"TopLevelWindow_GetTitle", (PyCFunction)_wrap_TopLevelWindow_GetTitle, METH_O, NULL},
{ (char *)"TopLevelWindow_EnableCloseButton", (PyCFunction) _wrap_TopLevelWindow_EnableCloseButton, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"TopLevelWindow_SetShape", (PyCFunction) _wrap_TopLevelWindow_SetShape, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"TopLevelWindow_RequestUserAttention", (PyCFunction) _wrap_TopLevelWindow_RequestUserAttention, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"TopLevelWindow_IsActive", (PyCFunction)_wrap_TopLevelWindow_IsActive, METH_O, NULL},
{ (char *)"TopLevelWindow_MacSetMetalAppearance", (PyCFunction) _wrap_TopLevelWindow_MacSetMetalAppearance, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"TopLevelWindow_MacGetMetalAppearance", (PyCFunction)_wrap_TopLevelWindow_MacGetMetalAppearance, METH_O, NULL},
{ (char *)"TopLevelWindow_CenterOnScreen", (PyCFunction) _wrap_TopLevelWindow_CenterOnScreen, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"TopLevelWindow_EnableCloseButton", (PyCFunction) _wrap_TopLevelWindow_EnableCloseButton, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"TopLevelWindow_GetDefaultItem", (PyCFunction)_wrap_TopLevelWindow_GetDefaultItem, METH_O, NULL},
{ (char *)"TopLevelWindow_SetDefaultItem", (PyCFunction) _wrap_TopLevelWindow_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"TopLevelWindow_SetTmpDefaultItem", (PyCFunction) _wrap_TopLevelWindow_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
@@ -31601,6 +32096,18 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"Printout_GetTitle", (PyCFunction)_wrap_Printout_GetTitle, METH_O, NULL},
{ (char *)"Printout_GetDC", (PyCFunction)_wrap_Printout_GetDC, METH_O, NULL},
{ (char *)"Printout_SetDC", (PyCFunction) _wrap_Printout_SetDC, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"Printout_FitThisSizeToPaper", (PyCFunction) _wrap_Printout_FitThisSizeToPaper, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"Printout_FitThisSizeToPage", (PyCFunction) _wrap_Printout_FitThisSizeToPage, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"Printout_FitThisSizeToPageMargins", (PyCFunction) _wrap_Printout_FitThisSizeToPageMargins, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"Printout_MapScreenSizeToPaper", (PyCFunction)_wrap_Printout_MapScreenSizeToPaper, METH_O, NULL},
{ (char *)"Printout_MapScreenSizeToPage", (PyCFunction)_wrap_Printout_MapScreenSizeToPage, METH_O, NULL},
{ (char *)"Printout_MapScreenSizeToPageMargins", (PyCFunction) _wrap_Printout_MapScreenSizeToPageMargins, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"Printout_MapScreenSizeToDevice", (PyCFunction)_wrap_Printout_MapScreenSizeToDevice, METH_O, NULL},
{ (char *)"Printout_GetLogicalPaperRect", (PyCFunction)_wrap_Printout_GetLogicalPaperRect, METH_O, NULL},
{ (char *)"Printout_GetLogicalPageRect", (PyCFunction)_wrap_Printout_GetLogicalPageRect, METH_O, NULL},
{ (char *)"Printout_GetLogicalPageMarginsRect", (PyCFunction) _wrap_Printout_GetLogicalPageMarginsRect, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"Printout_SetLogicalOrigin", (PyCFunction) _wrap_Printout_SetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"Printout_OffsetLogicalOrigin", (PyCFunction) _wrap_Printout_OffsetLogicalOrigin, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"Printout_SetPageSizePixels", (PyCFunction) _wrap_Printout_SetPageSizePixels, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"Printout_GetPageSizePixels", (PyCFunction)_wrap_Printout_GetPageSizePixels, METH_O, NULL},
{ (char *)"Printout_SetPageSizeMM", (PyCFunction) _wrap_Printout_SetPageSizeMM, METH_VARARGS | METH_KEYWORDS, NULL},
@@ -31609,6 +32116,8 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"Printout_GetPPIScreen", (PyCFunction)_wrap_Printout_GetPPIScreen, METH_O, NULL},
{ (char *)"Printout_SetPPIPrinter", (PyCFunction) _wrap_Printout_SetPPIPrinter, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"Printout_GetPPIPrinter", (PyCFunction)_wrap_Printout_GetPPIPrinter, METH_O, NULL},
{ (char *)"Printout_SetPaperRectPixels", (PyCFunction) _wrap_Printout_SetPaperRectPixels, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"Printout_GetPaperRectPixels", (PyCFunction)_wrap_Printout_GetPaperRectPixels, METH_O, NULL},
{ (char *)"Printout_IsPreview", (PyCFunction)_wrap_Printout_IsPreview, METH_O, NULL},
{ (char *)"Printout_SetIsPreview", (PyCFunction) _wrap_Printout_SetIsPreview, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"Printout_OnBeginDocument", (PyCFunction) _wrap_Printout_OnBeginDocument, METH_VARARGS | METH_KEYWORDS, NULL},

7
wxPython/src/gtk/aui.py
View File

@@ -166,9 +166,10 @@ AUI_MGR_ALLOW_FLOATING = _aui.AUI_MGR_ALLOW_FLOATING
AUI_MGR_ALLOW_ACTIVE_PANE = _aui.AUI_MGR_ALLOW_ACTIVE_PANE
AUI_MGR_TRANSPARENT_DRAG = _aui.AUI_MGR_TRANSPARENT_DRAG
AUI_MGR_TRANSPARENT_HINT = _aui.AUI_MGR_TRANSPARENT_HINT
AUI_MGR_TRANSPARENT_HINT_FADE = _aui.AUI_MGR_TRANSPARENT_HINT_FADE
AUI_MGR_DISABLE_VENETIAN_BLINDS = _aui.AUI_MGR_DISABLE_VENETIAN_BLINDS
AUI_MGR_DISABLE_VENETIAN_BLINDS_FADE = _aui.AUI_MGR_DISABLE_VENETIAN_BLINDS_FADE
AUI_MGR_VENETIAN_BLINDS_HINT = _aui.AUI_MGR_VENETIAN_BLINDS_HINT
AUI_MGR_RECTANGLE_HINT = _aui.AUI_MGR_RECTANGLE_HINT
AUI_MGR_HINT_FADE = _aui.AUI_MGR_HINT_FADE
AUI_MGR_NO_VENETIAN_BLINDS_FADE = _aui.AUI_MGR_NO_VENETIAN_BLINDS_FADE
AUI_MGR_DEFAULT = _aui.AUI_MGR_DEFAULT
AUI_ART_SASH_SIZE = _aui.AUI_ART_SASH_SIZE
AUI_ART_CAPTION_SIZE = _aui.AUI_ART_CAPTION_SIZE

7
wxPython/src/gtk/aui_wrap.cpp
View File

@@ -16262,9 +16262,10 @@ SWIGEXPORT void SWIG_init(void) {
SWIG_Python_SetConstant(d, "AUI_MGR_ALLOW_ACTIVE_PANE",SWIG_From_int(static_cast< int >(wxAUI_MGR_ALLOW_ACTIVE_PANE)));
SWIG_Python_SetConstant(d, "AUI_MGR_TRANSPARENT_DRAG",SWIG_From_int(static_cast< int >(wxAUI_MGR_TRANSPARENT_DRAG)));
SWIG_Python_SetConstant(d, "AUI_MGR_TRANSPARENT_HINT",SWIG_From_int(static_cast< int >(wxAUI_MGR_TRANSPARENT_HINT)));
SWIG_Python_SetConstant(d, "AUI_MGR_TRANSPARENT_HINT_FADE",SWIG_From_int(static_cast< int >(wxAUI_MGR_TRANSPARENT_HINT_FADE)));
SWIG_Python_SetConstant(d, "AUI_MGR_DISABLE_VENETIAN_BLINDS",SWIG_From_int(static_cast< int >(wxAUI_MGR_DISABLE_VENETIAN_BLINDS)));
SWIG_Python_SetConstant(d, "AUI_MGR_DISABLE_VENETIAN_BLINDS_FADE",SWIG_From_int(static_cast< int >(wxAUI_MGR_DISABLE_VENETIAN_BLINDS_FADE)));
SWIG_Python_SetConstant(d, "AUI_MGR_VENETIAN_BLINDS_HINT",SWIG_From_int(static_cast< int >(wxAUI_MGR_VENETIAN_BLINDS_HINT)));
SWIG_Python_SetConstant(d, "AUI_MGR_RECTANGLE_HINT",SWIG_From_int(static_cast< int >(wxAUI_MGR_RECTANGLE_HINT)));
SWIG_Python_SetConstant(d, "AUI_MGR_HINT_FADE",SWIG_From_int(static_cast< int >(wxAUI_MGR_HINT_FADE)));
SWIG_Python_SetConstant(d, "AUI_MGR_NO_VENETIAN_BLINDS_FADE",SWIG_From_int(static_cast< int >(wxAUI_MGR_NO_VENETIAN_BLINDS_FADE)));
SWIG_Python_SetConstant(d, "AUI_MGR_DEFAULT",SWIG_From_int(static_cast< int >(wxAUI_MGR_DEFAULT)));
SWIG_Python_SetConstant(d, "AUI_ART_SASH_SIZE",SWIG_From_int(static_cast< int >(wxAUI_ART_SASH_SIZE)));
SWIG_Python_SetConstant(d, "AUI_ART_CAPTION_SIZE",SWIG_From_int(static_cast< int >(wxAUI_ART_CAPTION_SIZE)));

79
wxPython/src/gtk/richtext.py
View File

@@ -107,7 +107,6 @@ TEXT_ATTR_CHARACTER_STYLE_NAME = _richtext.TEXT_ATTR_CHARACTER_STYLE_NAME
TEXT_ATTR_PARAGRAPH_STYLE_NAME = _richtext.TEXT_ATTR_PARAGRAPH_STYLE_NAME
TEXT_ATTR_BULLET_STYLE = _richtext.TEXT_ATTR_BULLET_STYLE
TEXT_ATTR_BULLET_NUMBER = _richtext.TEXT_ATTR_BULLET_NUMBER
TEXT_ATTR_BULLET_SYMBOL = _richtext.TEXT_ATTR_BULLET_SYMBOL
TEXT_ATTR_BULLET_STYLE_NONE = _richtext.TEXT_ATTR_BULLET_STYLE_NONE
TEXT_ATTR_BULLET_STYLE_ARABIC = _richtext.TEXT_ATTR_BULLET_STYLE_ARABIC
TEXT_ATTR_BULLET_STYLE_LETTERS_UPPER = _richtext.TEXT_ATTR_BULLET_STYLE_LETTERS_UPPER
@@ -368,9 +367,9 @@ class RichTextAttr(object):
"""SetBulletNumber(self, int n)"""
return _richtext.RichTextAttr_SetBulletNumber(*args, **kwargs)
def SetBulletSymbol(*args, **kwargs):
"""SetBulletSymbol(self, wxChar symbol)"""
return _richtext.RichTextAttr_SetBulletSymbol(*args, **kwargs)
def SetBulletText(*args, **kwargs):
"""SetBulletText(self, wxChar symbol)"""
return _richtext.RichTextAttr_SetBulletText(*args, **kwargs)
def SetBulletFont(*args, **kwargs):
"""SetBulletFont(self, String bulletFont)"""
@@ -456,9 +455,9 @@ class RichTextAttr(object):
"""GetBulletNumber(self) -> int"""
return _richtext.RichTextAttr_GetBulletNumber(*args, **kwargs)
def GetBulletSymbol(*args, **kwargs):
"""GetBulletSymbol(self) -> wxChar"""
return _richtext.RichTextAttr_GetBulletSymbol(*args, **kwargs)
def GetBulletText(*args, **kwargs):
"""GetBulletText(self) -> String"""
return _richtext.RichTextAttr_GetBulletText(*args, **kwargs)
def GetBulletFont(*args, **kwargs):
"""GetBulletFont(self) -> String"""
@@ -540,9 +539,9 @@ class RichTextAttr(object):
"""HasBulletNumber(self) -> bool"""
return _richtext.RichTextAttr_HasBulletNumber(*args, **kwargs)
def HasBulletSymbol(*args, **kwargs):
"""HasBulletSymbol(self) -> bool"""
return _richtext.RichTextAttr_HasBulletSymbol(*args, **kwargs)
def HasBulletText(*args, **kwargs):
"""HasBulletText(self) -> bool"""
return _richtext.RichTextAttr_HasBulletText(*args, **kwargs)
def HasFlag(*args, **kwargs):
"""HasFlag(self, long flag) -> bool"""
@@ -565,7 +564,7 @@ class RichTextAttr(object):
BulletFont = property(GetBulletFont,SetBulletFont,doc="See `GetBulletFont` and `SetBulletFont`")
BulletNumber = property(GetBulletNumber,SetBulletNumber,doc="See `GetBulletNumber` and `SetBulletNumber`")
BulletStyle = property(GetBulletStyle,SetBulletStyle,doc="See `GetBulletStyle` and `SetBulletStyle`")
BulletSymbol = property(GetBulletSymbol,SetBulletSymbol,doc="See `GetBulletSymbol` and `SetBulletSymbol`")
BulletText = property(GetBulletText,SetBulletText,doc="See `GetBulletText` and `SetBulletText`")
CharacterStyleName = property(GetCharacterStyleName,SetCharacterStyleName,doc="See `GetCharacterStyleName` and `SetCharacterStyleName`")
Flags = property(GetFlags,SetFlags,doc="See `GetFlags` and `SetFlags`")
Font = property(GetFont,SetFont,doc="See `GetFont` and `SetFont`")
@@ -721,6 +720,22 @@ class RichTextCtrl(_windows.ScrolledWindow):
"""
return _richtext.RichTextCtrl_SaveFile(*args, **kwargs)
def SetHandlerFlags(*args, **kwargs):
"""
SetHandlerFlags(self, int flags)
Set the handler flags, controlling loading and saving.
"""
return _richtext.RichTextCtrl_SetHandlerFlags(*args, **kwargs)
def GetHandlerFlags(*args, **kwargs):
"""
GetHandlerFlags(self) -> int
Get the handler flags, controlling loading and saving.
"""
return _richtext.RichTextCtrl_GetHandlerFlags(*args, **kwargs)
def MarkDirty(*args, **kwargs):
"""
MarkDirty(self)
@@ -1158,7 +1173,7 @@ class RichTextCtrl(_windows.ScrolledWindow):
return _richtext.RichTextCtrl_EndNumberedBullet(*args, **kwargs)
def BeginSymbolBullet(*args, **kwargs):
"""BeginSymbolBullet(self, char symbol, int leftIndent, int leftSubIndent, int bulletStyle=TEXT_ATTR_BULLET_STYLE_SYMBOL) -> bool"""
"""BeginSymbolBullet(self, String symbol, int leftIndent, int leftSubIndent, int bulletStyle=TEXT_ATTR_BULLET_STYLE_SYMBOL) -> bool"""
return _richtext.RichTextCtrl_BeginSymbolBullet(*args, **kwargs)
def EndSymbolBullet(*args, **kwargs):
@@ -1181,6 +1196,38 @@ class RichTextCtrl(_windows.ScrolledWindow):
"""EndParagraphStyle(self) -> bool"""
return _richtext.RichTextCtrl_EndParagraphStyle(*args, **kwargs)
def BeginListStyle(*args, **kwargs):
"""
BeginListStyle(self, String listStyle, int level=1, int number=1) -> bool
Begin named list style.
"""
return _richtext.RichTextCtrl_BeginListStyle(*args, **kwargs)
def EndListStyle(*args, **kwargs):
"""
EndListStyle(self) -> bool
End named list style.
"""
return _richtext.RichTextCtrl_EndListStyle(*args, **kwargs)
def BeginURL(*args, **kwargs):
"""
BeginURL(self, String url, String characterStyle=wxEmptyString) -> bool
Begin URL.
"""
return _richtext.RichTextCtrl_BeginURL(*args, **kwargs)
def EndURL(*args, **kwargs):
"""
EndURL(self) -> bool
End URL.
"""
return _richtext.RichTextCtrl_EndURL(*args, **kwargs)
def SetDefaultStyleToCursorStyle(*args, **kwargs):
"""SetDefaultStyleToCursorStyle(self) -> bool"""
return _richtext.RichTextCtrl_SetDefaultStyleToCursorStyle(*args, **kwargs)
@@ -1388,6 +1435,10 @@ wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK = _richtext.wxEVT_COMMAND_RICHTEXT_RIGHT_CLIC
wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK = _richtext.wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK
wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK = _richtext.wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK
wxEVT_COMMAND_RICHTEXT_RETURN = _richtext.wxEVT_COMMAND_RICHTEXT_RETURN
wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING = _richtext.wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING
wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED = _richtext.wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED
wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING = _richtext.wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING
wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED = _richtext.wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED
EVT_RICHTEXT_ITEM_SELECTED = wx.PyEventBinder(wxEVT_COMMAND_RICHTEXT_ITEM_SELECTED, 1)
EVT_RICHTEXT_ITEM_DESELECTED = wx.PyEventBinder(wxEVT_COMMAND_RICHTEXT_ITEM_DESELECTED, 1)
EVT_RICHTEXT_LEFT_CLICK = wx.PyEventBinder(wxEVT_COMMAND_RICHTEXT_LEFT_CLICK, 1)
@@ -1395,6 +1446,10 @@ EVT_RICHTEXT_RIGHT_CLICK = wx.PyEventBinder(wxEVT_COMMAND_RICHTEXT_RIGHT_CLICK,
EVT_RICHTEXT_MIDDLE_CLICK = wx.PyEventBinder(wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK, 1)
EVT_RICHTEXT_LEFT_DCLICK = wx.PyEventBinder(wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK, 1)
EVT_RICHTEXT_RETURN = wx.PyEventBinder( wxEVT_COMMAND_RICHTEXT_RETURN, 1)
EVT_RICHTEXT_STYLESHEET_CHANGING = wx.PyEventBinder( wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING, 1)
EVT_RICHTEXT_STYLESHEET_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED, 1)
EVT_RICHTEXT_STYLESHEET_REPLACING = wx.PyEventBinder( wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING, 1)
EVT_RICHTEXT_STYLESHEET_REPLACED = wx.PyEventBinder( wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED, 1)
class RichTextEvent(_core.NotifyEvent):
"""Proxy of C++ RichTextEvent class"""

450
wxPython/src/gtk/richtext_wrap.cpp
View File

@@ -2854,114 +2854,6 @@ SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
return SWIG_OK;
}
SWIGINTERN swig_type_info*
SWIG_pchar_descriptor()
{
static int init = 0;
static swig_type_info* info = 0;
if (!init) {
info = SWIG_TypeQuery("_p_char");
init = 1;
}
return info;
}
SWIGINTERN int
SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
{
if (PyString_Check(obj)) {
char *cstr; Py_ssize_t len;
PyString_AsStringAndSize(obj, &cstr, &len);
if (cptr) {
if (alloc) {
/*
In python the user should not be able to modify the inner
string representation. To warranty that, if you define
SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
buffer is always returned.
The default behavior is just to return the pointer value,
so, be careful.
*/
#if defined(SWIG_PYTHON_SAFE_CSTRINGS)
if (*alloc != SWIG_OLDOBJ)
#else
if (*alloc == SWIG_NEWOBJ)
#endif
{
*cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
*alloc = SWIG_NEWOBJ;
}
else {
*cptr = cstr;
*alloc = SWIG_OLDOBJ;
}
} else {
*cptr = PyString_AsString(obj);
}
}
if (psize) *psize = len + 1;
return SWIG_OK;
} else {
swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
if (pchar_descriptor) {
void* vptr = 0;
if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
if (cptr) *cptr = (char *) vptr;
if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
if (alloc) *alloc = SWIG_OLDOBJ;
return SWIG_OK;
}
}
}
return SWIG_TypeError;
}
SWIGINTERN int
SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
{
char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
if (SWIG_IsOK(res)) {
if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
if (csize <= size) {
if (val) {
if (csize) memcpy(val, cptr, csize*sizeof(char));
if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
}
if (alloc == SWIG_NEWOBJ) {
delete[] cptr;
res = SWIG_DelNewMask(res);
}
return res;
}
if (alloc == SWIG_NEWOBJ) delete[] cptr;
}
return SWIG_TypeError;
}
SWIGINTERN int
SWIG_AsVal_char (PyObject * obj, char *val)
{
int res = SWIG_AsCharArray(obj, val, 1);
if (!SWIG_IsOK(res)) {
long v;
res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
if (SWIG_IsOK(res)) {
if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
if (val) *val = static_cast< char >(v);
} else {
res = SWIG_OverflowError;
}
}
}
return res;
}
#ifdef __cplusplus
extern "C" {
#endif
@@ -4520,7 +4412,7 @@ fail:
}
SWIGINTERN PyObject *_wrap_RichTextAttr_SetBulletSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
SWIGINTERN PyObject *_wrap_RichTextAttr_SetBulletText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxRichTextAttr *arg1 = (wxRichTextAttr *) 0 ;
wxChar arg2 ;
@@ -4534,19 +4426,19 @@ SWIGINTERN PyObject *_wrap_RichTextAttr_SetBulletSymbol(PyObject *SWIGUNUSEDPARM
(char *) "self",(char *) "symbol", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextAttr_SetBulletSymbol",kwnames,&obj0,&obj1)) SWIG_fail;
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextAttr_SetBulletText",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextAttr, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextAttr_SetBulletSymbol" "', expected argument " "1"" of type '" "wxRichTextAttr *""'");
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextAttr_SetBulletText" "', expected argument " "1"" of type '" "wxRichTextAttr *""'");
}
arg1 = reinterpret_cast< wxRichTextAttr * >(argp1);
{
res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxChar, 0 | 0);
if (!SWIG_IsOK(res2)) {
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextAttr_SetBulletSymbol" "', expected argument " "2"" of type '" "wxChar""'");
SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "RichTextAttr_SetBulletText" "', expected argument " "2"" of type '" "wxChar""'");
}
if (!argp2) {
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextAttr_SetBulletSymbol" "', expected argument " "2"" of type '" "wxChar""'");
SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "RichTextAttr_SetBulletText" "', expected argument " "2"" of type '" "wxChar""'");
} else {
wxChar * temp = reinterpret_cast< wxChar * >(argp2);
arg2 = *temp;
@@ -4555,7 +4447,7 @@ SWIGINTERN PyObject *_wrap_RichTextAttr_SetBulletSymbol(PyObject *SWIGUNUSEDPARM
}
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
(arg1)->SetBulletSymbol(arg2);
(arg1)->SetBulletText(arg2);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
@@ -5211,10 +5103,10 @@ fail:
}
SWIGINTERN PyObject *_wrap_RichTextAttr_GetBulletSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
SWIGINTERN PyObject *_wrap_RichTextAttr_GetBulletText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxRichTextAttr *arg1 = (wxRichTextAttr *) 0 ;
wxChar result;
wxString *result = 0 ;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
@@ -5223,16 +5115,25 @@ SWIGINTERN PyObject *_wrap_RichTextAttr_GetBulletSymbol(PyObject *SWIGUNUSEDPARM
swig_obj[0] = args;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextAttr, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextAttr_GetBulletSymbol" "', expected argument " "1"" of type '" "wxRichTextAttr const *""'");
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextAttr_GetBulletText" "', expected argument " "1"" of type '" "wxRichTextAttr const *""'");
}
arg1 = reinterpret_cast< wxRichTextAttr * >(argp1);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = ((wxRichTextAttr const *)arg1)->GetBulletSymbol();
{
wxString const &_result_ref = ((wxRichTextAttr const *)arg1)->GetBulletText();
result = (wxString *) &_result_ref;
}
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_NewPointerObj((new wxChar(static_cast< const wxChar& >(result))), SWIGTYPE_p_wxChar, SWIG_POINTER_OWN | 0 );
{
#if wxUSE_UNICODE
resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
#else
resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
#endif
}
return resultobj;
fail:
return NULL;
@@ -5846,7 +5747,7 @@ fail:
}
SWIGINTERN PyObject *_wrap_RichTextAttr_HasBulletSymbol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
SWIGINTERN PyObject *_wrap_RichTextAttr_HasBulletText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxRichTextAttr *arg1 = (wxRichTextAttr *) 0 ;
bool result;
@@ -5858,12 +5759,12 @@ SWIGINTERN PyObject *_wrap_RichTextAttr_HasBulletSymbol(PyObject *SWIGUNUSEDPARM
swig_obj[0] = args;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextAttr, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextAttr_HasBulletSymbol" "', expected argument " "1"" of type '" "wxRichTextAttr const *""'");
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextAttr_HasBulletText" "', expected argument " "1"" of type '" "wxRichTextAttr const *""'");
}
arg1 = reinterpret_cast< wxRichTextAttr * >(argp1);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = (bool)((wxRichTextAttr const *)arg1)->HasBulletSymbol();
result = (bool)((wxRichTextAttr const *)arg1)->HasBulletText();
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
@@ -7080,6 +6981,72 @@ fail:
}
SWIGINTERN PyObject *_wrap_RichTextCtrl_SetHandlerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;
int arg2 ;
void *argp1 = 0 ;
int res1 = 0 ;
int val2 ;
int ecode2 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "flags", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RichTextCtrl_SetHandlerFlags",kwnames,&obj0,&obj1)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_SetHandlerFlags" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");
}
arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);
ecode2 = SWIG_AsVal_int(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_SetHandlerFlags" "', expected argument " "2"" of type '" "int""'");
}
arg2 = static_cast< int >(val2);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
(arg1)->SetHandlerFlags(arg2);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_Py_Void();
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_RichTextCtrl_GetHandlerFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;
int result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
if (!args) SWIG_fail;
swig_obj[0] = args;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_GetHandlerFlags" "', expected argument " "1"" of type '" "wxRichTextCtrl const *""'");
}
arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = (int)((wxRichTextCtrl const *)arg1)->GetHandlerFlags();
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
resultobj = SWIG_From_int(static_cast< int >(result));
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_RichTextCtrl_MarkDirty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;
@@ -9618,15 +9585,14 @@ fail:
SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginSymbolBullet(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;
char arg2 ;
wxString *arg2 = 0 ;
int arg3 ;
int arg4 ;
int arg5 = (int) wxTEXT_ATTR_BULLET_STYLE_SYMBOL ;
bool result;
void *argp1 = 0 ;
int res1 = 0 ;
char val2 ;
int ecode2 = 0 ;
bool temp2 = false ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
@@ -9648,11 +9614,11 @@ SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginSymbolBullet(PyObject *SWIGUNUSEDPA
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginSymbolBullet" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");
}
arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);
ecode2 = SWIG_AsVal_char(obj1, &val2);
if (!SWIG_IsOK(ecode2)) {
SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RichTextCtrl_BeginSymbolBullet" "', expected argument " "2"" of type '" "char""'");
}
arg2 = static_cast< char >(val2);
{
arg2 = wxString_in_helper(obj1);
if (arg2 == NULL) SWIG_fail;
temp2 = true;
}
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_BeginSymbolBullet" "', expected argument " "3"" of type '" "int""'");
@@ -9672,15 +9638,23 @@ SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginSymbolBullet(PyObject *SWIGUNUSEDPA
}
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = (bool)(arg1)->BeginSymbolBullet(arg2,arg3,arg4,arg5);
result = (bool)(arg1)->BeginSymbolBullet((wxString const &)*arg2,arg3,arg4,arg5);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
{
resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
}
{
if (temp2)
delete arg2;
}
return resultobj;
fail:
{
if (temp2)
delete arg2;
}
return NULL;
}
@@ -9871,6 +9845,203 @@ fail:
}
SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginListStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;
wxString *arg2 = 0 ;
int arg3 = (int) 1 ;
int arg4 = (int) 1 ;
bool result;
void *argp1 = 0 ;
int res1 = 0 ;
bool temp2 = false ;
int val3 ;
int ecode3 = 0 ;
int val4 ;
int ecode4 = 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
PyObject * obj3 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "listStyle",(char *) "level",(char *) "number", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:RichTextCtrl_BeginListStyle",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginListStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");
}
arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);
{
arg2 = wxString_in_helper(obj1);
if (arg2 == NULL) SWIG_fail;
temp2 = true;
}
if (obj2) {
ecode3 = SWIG_AsVal_int(obj2, &val3);
if (!SWIG_IsOK(ecode3)) {
SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RichTextCtrl_BeginListStyle" "', expected argument " "3"" of type '" "int""'");
}
arg3 = static_cast< int >(val3);
}
if (obj3) {
ecode4 = SWIG_AsVal_int(obj3, &val4);
if (!SWIG_IsOK(ecode4)) {
SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "RichTextCtrl_BeginListStyle" "', expected argument " "4"" of type '" "int""'");
}
arg4 = static_cast< int >(val4);
}
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = (bool)(arg1)->BeginListStyle((wxString const &)*arg2,arg3,arg4);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
{
resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
}
{
if (temp2)
delete arg2;
}
return resultobj;
fail:
{
if (temp2)
delete arg2;
}
return NULL;
}
SWIGINTERN PyObject *_wrap_RichTextCtrl_EndListStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;
bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
if (!args) SWIG_fail;
swig_obj[0] = args;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndListStyle" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");
}
arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = (bool)(arg1)->EndListStyle();
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
{
resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_RichTextCtrl_BeginURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
PyObject *resultobj = 0;
wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;
wxString *arg2 = 0 ;
wxString const &arg3_defvalue = wxEmptyString ;
wxString *arg3 = (wxString *) &arg3_defvalue ;
bool result;
void *argp1 = 0 ;
int res1 = 0 ;
bool temp2 = false ;
bool temp3 = false ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
PyObject * obj2 = 0 ;
char * kwnames[] = {
(char *) "self",(char *) "url",(char *) "characterStyle", NULL
};
if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:RichTextCtrl_BeginURL",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_BeginURL" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");
}
arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);
{
arg2 = wxString_in_helper(obj1);
if (arg2 == NULL) SWIG_fail;
temp2 = true;
}
if (obj2) {
{
arg3 = wxString_in_helper(obj2);
if (arg3 == NULL) SWIG_fail;
temp3 = true;
}
}
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = (bool)(arg1)->BeginURL((wxString const &)*arg2,(wxString const &)*arg3);
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
{
resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
}
{
if (temp2)
delete arg2;
}
{
if (temp3)
delete arg3;
}
return resultobj;
fail:
{
if (temp2)
delete arg2;
}
{
if (temp3)
delete arg3;
}
return NULL;
}
SWIGINTERN PyObject *_wrap_RichTextCtrl_EndURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;
bool result;
void *argp1 = 0 ;
int res1 = 0 ;
PyObject *swig_obj[1] ;
if (!args) SWIG_fail;
swig_obj[0] = args;
res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRichTextCtrl, 0 | 0 );
if (!SWIG_IsOK(res1)) {
SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RichTextCtrl_EndURL" "', expected argument " "1"" of type '" "wxRichTextCtrl *""'");
}
arg1 = reinterpret_cast< wxRichTextCtrl * >(argp1);
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
result = (bool)(arg1)->EndURL();
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
{
resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
}
return resultobj;
fail:
return NULL;
}
SWIGINTERN PyObject *_wrap_RichTextCtrl_SetDefaultStyleToCursorStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
PyObject *resultobj = 0;
wxRichTextCtrl *arg1 = (wxRichTextCtrl *) 0 ;
@@ -11915,7 +12086,7 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"RichTextAttr_SetLineSpacing", (PyCFunction) _wrap_RichTextAttr_SetLineSpacing, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextAttr_SetBulletStyle", (PyCFunction) _wrap_RichTextAttr_SetBulletStyle, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextAttr_SetBulletNumber", (PyCFunction) _wrap_RichTextAttr_SetBulletNumber, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextAttr_SetBulletSymbol", (PyCFunction) _wrap_RichTextAttr_SetBulletSymbol, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextAttr_SetBulletText", (PyCFunction) _wrap_RichTextAttr_SetBulletText, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextAttr_SetBulletFont", (PyCFunction) _wrap_RichTextAttr_SetBulletFont, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextAttr_GetTextColour", (PyCFunction)_wrap_RichTextAttr_GetTextColour, METH_O, NULL},
{ (char *)"RichTextAttr_GetBackgroundColour", (PyCFunction)_wrap_RichTextAttr_GetBackgroundColour, METH_O, NULL},
@@ -11937,7 +12108,7 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"RichTextAttr_GetLineSpacing", (PyCFunction)_wrap_RichTextAttr_GetLineSpacing, METH_O, NULL},
{ (char *)"RichTextAttr_GetBulletStyle", (PyCFunction)_wrap_RichTextAttr_GetBulletStyle, METH_O, NULL},
{ (char *)"RichTextAttr_GetBulletNumber", (PyCFunction)_wrap_RichTextAttr_GetBulletNumber, METH_O, NULL},
{ (char *)"RichTextAttr_GetBulletSymbol", (PyCFunction)_wrap_RichTextAttr_GetBulletSymbol, METH_O, NULL},
{ (char *)"RichTextAttr_GetBulletText", (PyCFunction)_wrap_RichTextAttr_GetBulletText, METH_O, NULL},
{ (char *)"RichTextAttr_GetBulletFont", (PyCFunction)_wrap_RichTextAttr_GetBulletFont, METH_O, NULL},
{ (char *)"RichTextAttr_HasTextColour", (PyCFunction)_wrap_RichTextAttr_HasTextColour, METH_O, NULL},
{ (char *)"RichTextAttr_HasBackgroundColour", (PyCFunction)_wrap_RichTextAttr_HasBackgroundColour, METH_O, NULL},
@@ -11958,7 +12129,7 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"RichTextAttr_HasParagraphStyleName", (PyCFunction)_wrap_RichTextAttr_HasParagraphStyleName, METH_O, NULL},
{ (char *)"RichTextAttr_HasBulletStyle", (PyCFunction)_wrap_RichTextAttr_HasBulletStyle, METH_O, NULL},
{ (char *)"RichTextAttr_HasBulletNumber", (PyCFunction)_wrap_RichTextAttr_HasBulletNumber, METH_O, NULL},
{ (char *)"RichTextAttr_HasBulletSymbol", (PyCFunction)_wrap_RichTextAttr_HasBulletSymbol, METH_O, NULL},
{ (char *)"RichTextAttr_HasBulletText", (PyCFunction)_wrap_RichTextAttr_HasBulletText, METH_O, NULL},
{ (char *)"RichTextAttr_HasFlag", (PyCFunction) _wrap_RichTextAttr_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextAttr_IsCharacterStyle", (PyCFunction)_wrap_RichTextAttr_IsCharacterStyle, METH_O, NULL},
{ (char *)"RichTextAttr_IsParagraphStyle", (PyCFunction)_wrap_RichTextAttr_IsParagraphStyle, METH_O, NULL},
@@ -11989,6 +12160,8 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"RichTextCtrl_Remove", (PyCFunction) _wrap_RichTextCtrl_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextCtrl_LoadFile", (PyCFunction) _wrap_RichTextCtrl_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextCtrl_SaveFile", (PyCFunction) _wrap_RichTextCtrl_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextCtrl_SetHandlerFlags", (PyCFunction) _wrap_RichTextCtrl_SetHandlerFlags, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextCtrl_GetHandlerFlags", (PyCFunction)_wrap_RichTextCtrl_GetHandlerFlags, METH_O, NULL},
{ (char *)"RichTextCtrl_MarkDirty", (PyCFunction)_wrap_RichTextCtrl_MarkDirty, METH_O, NULL},
{ (char *)"RichTextCtrl_DiscardEdits", (PyCFunction)_wrap_RichTextCtrl_DiscardEdits, METH_O, NULL},
{ (char *)"RichTextCtrl_SetMaxLength", (PyCFunction) _wrap_RichTextCtrl_SetMaxLength, METH_VARARGS | METH_KEYWORDS, NULL},
@@ -12063,6 +12236,10 @@ static PyMethodDef SwigMethods[] = {
{ (char *)"RichTextCtrl_EndCharacterStyle", (PyCFunction)_wrap_RichTextCtrl_EndCharacterStyle, METH_O, NULL},
{ (char *)"RichTextCtrl_BeginParagraphStyle", (PyCFunction) _wrap_RichTextCtrl_BeginParagraphStyle, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextCtrl_EndParagraphStyle", (PyCFunction)_wrap_RichTextCtrl_EndParagraphStyle, METH_O, NULL},
{ (char *)"RichTextCtrl_BeginListStyle", (PyCFunction) _wrap_RichTextCtrl_BeginListStyle, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextCtrl_EndListStyle", (PyCFunction)_wrap_RichTextCtrl_EndListStyle, METH_O, NULL},
{ (char *)"RichTextCtrl_BeginURL", (PyCFunction) _wrap_RichTextCtrl_BeginURL, METH_VARARGS | METH_KEYWORDS, NULL},
{ (char *)"RichTextCtrl_EndURL", (PyCFunction)_wrap_RichTextCtrl_EndURL, METH_O, NULL},
{ (char *)"RichTextCtrl_SetDefaultStyleToCursorStyle", (PyCFunction)_wrap_RichTextCtrl_SetDefaultStyleToCursorStyle, METH_O, NULL},
{ (char *)"RichTextCtrl_SelectNone", (PyCFunction)_wrap_RichTextCtrl_SelectNone, METH_O, NULL},
{ (char *)"RichTextCtrl_SelectWord", (PyCFunction) _wrap_RichTextCtrl_SelectWord, METH_VARARGS | METH_KEYWORDS, NULL},
@@ -14269,7 +14446,6 @@ SWIGEXPORT void SWIG_init(void) {
SWIG_Python_SetConstant(d, "TEXT_ATTR_PARAGRAPH_STYLE_NAME",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_PARAGRAPH_STYLE_NAME)));
SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE)));
SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_NUMBER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_NUMBER)));
SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_SYMBOL",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_SYMBOL)));
SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_NONE",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_NONE)));
SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_ARABIC",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_ARABIC)));
SWIG_Python_SetConstant(d, "TEXT_ATTR_BULLET_STYLE_LETTERS_UPPER",SWIG_From_int(static_cast< int >(wxTEXT_ATTR_BULLET_STYLE_LETTERS_UPPER)));
@@ -14302,6 +14478,10 @@ SWIGEXPORT void SWIG_init(void) {
PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_MIDDLE_CLICK));
PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_LEFT_DCLICK));
PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_RETURN", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_RETURN));
PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGING));
PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_STYLESHEET_CHANGED));
PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACING));
PyDict_SetItemString(d, "wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED", PyInt_FromLong(wxEVT_COMMAND_RICHTEXT_STYLESHEET_REPLACED));
wxRichTextModuleInit();

2
wxPython/src/gtk/xrc_wrap.cpp
View File

@@ -2775,7 +2775,7 @@ IMP_PYCALLBACK_OBJECT_STRING_pure(wxPyXmlSubclassFactory, wxXmlSubclassFactory,
class wxPyXmlResourceHandler : public wxXmlResourceHandler {
public:
wxPyXmlResourceHandler() : wxXmlResourceHandler() {}
//~wxPyXmlResourceHandler();
~wxPyXmlResourceHandler() {}
// Base class virtuals