-# This file was created automatically by SWIG.
+# This file was created automatically by SWIG 1.3.29.
# Don't modify this file, modify the SWIG interface instead.
import _core_
-
+import new
+new_instancemethod = new.instancemethod
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
+ if (name == "thisown"): return self.this.own(value)
if (name == "this"):
- if isinstance(value, class_type):
- self.__dict__[name] = value.this
- if hasattr(value,"thisown"): self.__dict__["thisown"] = value.thisown
- del value.thisown
+ if type(value).__name__ == 'PySwigObject':
+ self.__dict__[name] = value
return
method = class_type.__swig_setmethods__.get(name,None)
if method: return method(self,value)
- if (not static) or hasattr(self,name) or (name == "thisown"):
+ if (not static) or hasattr(self,name):
self.__dict__[name] = value
else:
raise AttributeError("You cannot add attributes to %s" % self)
return _swig_setattr_nondynamic(self,class_type,name,value,0)
def _swig_getattr(self,class_type,name):
+ if (name == "thisown"): return self.this.own()
method = class_type.__swig_getmethods__.get(name,None)
if method: return method(self)
raise AttributeError,name
+def _swig_repr(self):
+ try: strthis = "proxy of " + self.this.__repr__()
+ except: strthis = ""
+ return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
+
import types
try:
_object = types.ObjectType
def _swig_setattr_nondynamic_method(set):
def set_attr(self,name,value):
- if hasattr(self,name) or (name in ("this", "thisown")):
+ if (name == "thisown"): return self.this.own(value)
+ if hasattr(self,name) or (name == "this"):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
CENTER_ON_SCREEN = _core_.CENTER_ON_SCREEN
CLIP_CHILDREN = _core_.CLIP_CHILDREN
CLIP_SIBLINGS = _core_.CLIP_SIBLINGS
+WINDOW_STYLE_MASK = _core_.WINDOW_STYLE_MASK
ALWAYS_SHOW_SB = _core_.ALWAYS_SHOW_SB
RETAINED = _core_.RETAINED
BACKINGSTORE = _core_.BACKINGSTORE
RB_USE_CHECKBOX = _core_.RB_USE_CHECKBOX
ST_SIZEGRIP = _core_.ST_SIZEGRIP
ST_NO_AUTORESIZE = _core_.ST_NO_AUTORESIZE
+ST_DOTS_MIDDLE = _core_.ST_DOTS_MIDDLE
+ST_DOTS_END = _core_.ST_DOTS_END
FLOOD_SURFACE = _core_.FLOOD_SURFACE
FLOOD_BORDER = _core_.FLOOD_BORDER
ODDEVEN_RULE = _core_.ODDEVEN_RULE
SIZE_AUTO = _core_.SIZE_AUTO
SIZE_USE_EXISTING = _core_.SIZE_USE_EXISTING
SIZE_ALLOW_MINUS_ONE = _core_.SIZE_ALLOW_MINUS_ONE
+SIZE_FORCE = _core_.SIZE_FORCE
PORTRAIT = _core_.PORTRAIT
LANDSCAPE = _core_.LANDSCAPE
PRINT_QUALITY_HIGH = _core_.PRINT_QUALITY_HIGH
PRINT_QUALITY_DRAFT = _core_.PRINT_QUALITY_DRAFT
ID_ANY = _core_.ID_ANY
ID_SEPARATOR = _core_.ID_SEPARATOR
+ID_NONE = _core_.ID_NONE
ID_LOWEST = _core_.ID_LOWEST
ID_OPEN = _core_.ID_OPEN
ID_CLOSE = _core_.ID_CLOSE
ID_HELP = _core_.ID_HELP
ID_PRINT = _core_.ID_PRINT
ID_PRINT_SETUP = _core_.ID_PRINT_SETUP
+ID_PAGE_SETUP = _core_.ID_PAGE_SETUP
ID_PREVIEW = _core_.ID_PREVIEW
ID_ABOUT = _core_.ID_ABOUT
ID_HELP_CONTENTS = _core_.ID_HELP_CONTENTS
ID_HELP_COMMANDS = _core_.ID_HELP_COMMANDS
ID_HELP_PROCEDURES = _core_.ID_HELP_PROCEDURES
ID_HELP_CONTEXT = _core_.ID_HELP_CONTEXT
+ID_HELP_INDEX = _core_.ID_HELP_INDEX
+ID_HELP_SEARCH = _core_.ID_HELP_SEARCH
ID_CLOSE_ALL = _core_.ID_CLOSE_ALL
ID_PREFERENCES = _core_.ID_PREFERENCES
+ID_EDIT = _core_.ID_EDIT
ID_CUT = _core_.ID_CUT
ID_COPY = _core_.ID_COPY
ID_PASTE = _core_.ID_PASTE
ID_VIEW_SORTNAME = _core_.ID_VIEW_SORTNAME
ID_VIEW_SORTSIZE = _core_.ID_VIEW_SORTSIZE
ID_VIEW_SORTTYPE = _core_.ID_VIEW_SORTTYPE
+ID_FILE = _core_.ID_FILE
ID_FILE1 = _core_.ID_FILE1
ID_FILE2 = _core_.ID_FILE2
ID_FILE3 = _core_.ID_FILE3
ID_UNDELETE = _core_.ID_UNDELETE
ID_REVERT_TO_SAVED = _core_.ID_REVERT_TO_SAVED
ID_HIGHEST = _core_.ID_HIGHEST
-OPEN = _core_.OPEN
-SAVE = _core_.SAVE
-HIDE_READONLY = _core_.HIDE_READONLY
-OVERWRITE_PROMPT = _core_.OVERWRITE_PROMPT
-FILE_MUST_EXIST = _core_.FILE_MUST_EXIST
-MULTIPLE = _core_.MULTIPLE
-CHANGE_DIR = _core_.CHANGE_DIR
-ACCEL_ALT = _core_.ACCEL_ALT
-ACCEL_CTRL = _core_.ACCEL_CTRL
-ACCEL_SHIFT = _core_.ACCEL_SHIFT
-ACCEL_NORMAL = _core_.ACCEL_NORMAL
-PD_AUTO_HIDE = _core_.PD_AUTO_HIDE
-PD_APP_MODAL = _core_.PD_APP_MODAL
-PD_CAN_ABORT = _core_.PD_CAN_ABORT
-PD_ELAPSED_TIME = _core_.PD_ELAPSED_TIME
-PD_ESTIMATED_TIME = _core_.PD_ESTIMATED_TIME
-PD_REMAINING_TIME = _core_.PD_REMAINING_TIME
-PD_SMOOTH = _core_.PD_SMOOTH
-PD_CAN_SKIP = _core_.PD_CAN_SKIP
-DD_NEW_DIR_BUTTON = _core_.DD_NEW_DIR_BUTTON
-DD_DEFAULT_STYLE = _core_.DD_DEFAULT_STYLE
MENU_TEAROFF = _core_.MENU_TEAROFF
MB_DOCKABLE = _core_.MB_DOCKABLE
NO_FULL_REPAINT_ON_RESIZE = _core_.NO_FULL_REPAINT_ON_RESIZE
PAPER_A2 = _core_.PAPER_A2
PAPER_A3_TRANSVERSE = _core_.PAPER_A3_TRANSVERSE
PAPER_A3_EXTRA_TRANSVERSE = _core_.PAPER_A3_EXTRA_TRANSVERSE
+PAPER_DBL_JAPANESE_POSTCARD = _core_.PAPER_DBL_JAPANESE_POSTCARD
+PAPER_A6 = _core_.PAPER_A6
+PAPER_JENV_KAKU2 = _core_.PAPER_JENV_KAKU2
+PAPER_JENV_KAKU3 = _core_.PAPER_JENV_KAKU3
+PAPER_JENV_CHOU3 = _core_.PAPER_JENV_CHOU3
+PAPER_JENV_CHOU4 = _core_.PAPER_JENV_CHOU4
+PAPER_LETTER_ROTATED = _core_.PAPER_LETTER_ROTATED
+PAPER_A3_ROTATED = _core_.PAPER_A3_ROTATED
+PAPER_A4_ROTATED = _core_.PAPER_A4_ROTATED
+PAPER_A5_ROTATED = _core_.PAPER_A5_ROTATED
+PAPER_B4_JIS_ROTATED = _core_.PAPER_B4_JIS_ROTATED
+PAPER_B5_JIS_ROTATED = _core_.PAPER_B5_JIS_ROTATED
+PAPER_JAPANESE_POSTCARD_ROTATED = _core_.PAPER_JAPANESE_POSTCARD_ROTATED
+PAPER_DBL_JAPANESE_POSTCARD_ROTATED = _core_.PAPER_DBL_JAPANESE_POSTCARD_ROTATED
+PAPER_A6_ROTATED = _core_.PAPER_A6_ROTATED
+PAPER_JENV_KAKU2_ROTATED = _core_.PAPER_JENV_KAKU2_ROTATED
+PAPER_JENV_KAKU3_ROTATED = _core_.PAPER_JENV_KAKU3_ROTATED
+PAPER_JENV_CHOU3_ROTATED = _core_.PAPER_JENV_CHOU3_ROTATED
+PAPER_JENV_CHOU4_ROTATED = _core_.PAPER_JENV_CHOU4_ROTATED
+PAPER_B6_JIS = _core_.PAPER_B6_JIS
+PAPER_B6_JIS_ROTATED = _core_.PAPER_B6_JIS_ROTATED
+PAPER_12X11 = _core_.PAPER_12X11
+PAPER_JENV_YOU4 = _core_.PAPER_JENV_YOU4
+PAPER_JENV_YOU4_ROTATED = _core_.PAPER_JENV_YOU4_ROTATED
+PAPER_P16K = _core_.PAPER_P16K
+PAPER_P32K = _core_.PAPER_P32K
+PAPER_P32KBIG = _core_.PAPER_P32KBIG
+PAPER_PENV_1 = _core_.PAPER_PENV_1
+PAPER_PENV_2 = _core_.PAPER_PENV_2
+PAPER_PENV_3 = _core_.PAPER_PENV_3
+PAPER_PENV_4 = _core_.PAPER_PENV_4
+PAPER_PENV_5 = _core_.PAPER_PENV_5
+PAPER_PENV_6 = _core_.PAPER_PENV_6
+PAPER_PENV_7 = _core_.PAPER_PENV_7
+PAPER_PENV_8 = _core_.PAPER_PENV_8
+PAPER_PENV_9 = _core_.PAPER_PENV_9
+PAPER_PENV_10 = _core_.PAPER_PENV_10
+PAPER_P16K_ROTATED = _core_.PAPER_P16K_ROTATED
+PAPER_P32K_ROTATED = _core_.PAPER_P32K_ROTATED
+PAPER_P32KBIG_ROTATED = _core_.PAPER_P32KBIG_ROTATED
+PAPER_PENV_1_ROTATED = _core_.PAPER_PENV_1_ROTATED
+PAPER_PENV_2_ROTATED = _core_.PAPER_PENV_2_ROTATED
+PAPER_PENV_3_ROTATED = _core_.PAPER_PENV_3_ROTATED
+PAPER_PENV_4_ROTATED = _core_.PAPER_PENV_4_ROTATED
+PAPER_PENV_5_ROTATED = _core_.PAPER_PENV_5_ROTATED
+PAPER_PENV_6_ROTATED = _core_.PAPER_PENV_6_ROTATED
+PAPER_PENV_7_ROTATED = _core_.PAPER_PENV_7_ROTATED
+PAPER_PENV_8_ROTATED = _core_.PAPER_PENV_8_ROTATED
+PAPER_PENV_9_ROTATED = _core_.PAPER_PENV_9_ROTATED
+PAPER_PENV_10_ROTATED = _core_.PAPER_PENV_10_ROTATED
DUPLEX_SIMPLEX = _core_.DUPLEX_SIMPLEX
DUPLEX_HORIZONTAL = _core_.DUPLEX_HORIZONTAL
DUPLEX_VERTICAL = _core_.DUPLEX_VERTICAL
MOD_NONE = _core_.MOD_NONE
MOD_ALT = _core_.MOD_ALT
MOD_CONTROL = _core_.MOD_CONTROL
+MOD_ALTGR = _core_.MOD_ALTGR
MOD_SHIFT = _core_.MOD_SHIFT
+MOD_META = _core_.MOD_META
MOD_WIN = _core_.MOD_WIN
+MOD_CMD = _core_.MOD_CMD
+MOD_ALL = _core_.MOD_ALL
UPDATE_UI_NONE = _core_.UPDATE_UI_NONE
UPDATE_UI_RECURSE = _core_.UPDATE_UI_RECURSE
UPDATE_UI_FROMIDLE = _core_.UPDATE_UI_FROMIDLE
+Layout_Default = _core_.Layout_Default
+Layout_LeftToRight = _core_.Layout_LeftToRight
+Layout_RightToLeft = _core_.Layout_RightToLeft
#---------------------------------------------------------------------------
class Object(object):
The base class for most wx objects, although in wxPython not
much functionality is needed nor exposed.
"""
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ 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
def GetClassName(*args, **kwargs):
"""
GetClassName(self) -> String
Deletes the C++ object this Python object is a proxy for.
"""
+ args[0].this.own(False)
return _core_.Object_Destroy(*args, **kwargs)
+ def IsSameAs(*args, **kwargs):
+ """
+ IsSameAs(self, Object p) -> bool
-class ObjectPtr(Object):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Object
-_core_.Object_swigregister(ObjectPtr)
-_wxPySetDictionary = _core_._wxPySetDictionary
-
-_wxPyFixStockObjects = _core_._wxPyFixStockObjects
+ For wx.Objects that use C++ reference counting internally, this method
+ can be used to determine if two objects are referencing the same data
+ object.
+ """
+ return _core_.Object_IsSameAs(*args, **kwargs)
+ ClassName = property(GetClassName,doc="See `GetClassName`")
+_core_.Object_swigregister(Object)
+_wxPySetDictionary = _core_._wxPySetDictionary
cvar = _core_.cvar
EmptyString = cvar.EmptyString
BITMAP_TYPE_ICON = _core_.BITMAP_TYPE_ICON
BITMAP_TYPE_ANI = _core_.BITMAP_TYPE_ANI
BITMAP_TYPE_IFF = _core_.BITMAP_TYPE_IFF
+BITMAP_TYPE_TGA = _core_.BITMAP_TYPE_TGA
BITMAP_TYPE_MACCURSOR = _core_.BITMAP_TYPE_MACCURSOR
BITMAP_TYPE_ANY = _core_.BITMAP_TYPE_ANY
CURSOR_NONE = _core_.CURSOR_NONE
class Size(object):
"""
wx.Size is a useful data structure used to represent the size of
- something. It simply contians integer width and height
- proprtites. In most places in wxPython where a wx.Size is
+ something. It simply contains integer width and height
+ properties. In most places in wxPython where a wx.Size is
expected a (width, height) tuple can be used instead.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxSize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
width = property(_core_.Size_width_get, _core_.Size_width_set)
height = property(_core_.Size_height_get, _core_.Size_height_set)
x = width; y = height
- def __init__(self, *args, **kwargs):
+ def __init__(self, *args, **kwargs):
"""
__init__(self, int w=0, int h=0) -> Size
Creates a size object.
"""
- newobj = _core_.new_Size(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_core_.delete_Size):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _core_.Size_swiginit(self,_core_.new_Size(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_Size
+ __del__ = lambda self : None;
def __eq__(*args, **kwargs):
"""
- __eq__(self, Size sz) -> bool
+ __eq__(self, PyObject other) -> bool
Test for equality of wx.Size objects.
"""
def __ne__(*args, **kwargs):
"""
- __ne__(self, Size sz) -> bool
+ __ne__(self, PyObject other) -> bool
- Test for inequality.
+ Test for inequality of wx.Size objects.
"""
return _core_.Size___ne__(*args, **kwargs)
"""
return _core_.Size_DecTo(*args, **kwargs)
+ def IncBy(*args, **kwargs):
+ """IncBy(self, int dx, int dy)"""
+ return _core_.Size_IncBy(*args, **kwargs)
+
+ def DecBy(*args, **kwargs):
+ """DecBy(self, int dx, int dy)"""
+ return _core_.Size_DecBy(*args, **kwargs)
+
+ def Scale(*args, **kwargs):
+ """
+ Scale(self, float xscale, float yscale)
+
+ Scales the dimensions of this object by the given factors.
+ """
+ return _core_.Size_Scale(*args, **kwargs)
+
def Set(*args, **kwargs):
"""
Set(self, int w, int h)
__safe_for_unpickling__ = True
def __reduce__(self): return (wx.Size, self.Get())
-
-class SizePtr(Size):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Size
-_core_.Size_swigregister(SizePtr)
+_core_.Size_swigregister(Size)
#---------------------------------------------------------------------------
point x and y properties. In wxPython most places that expect a
wx.RealPoint can also accept a (x,y) tuple.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxRealPoint instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
x = property(_core_.RealPoint_x_get, _core_.RealPoint_x_set)
y = property(_core_.RealPoint_y_get, _core_.RealPoint_y_set)
- def __init__(self, *args, **kwargs):
+ def __init__(self, *args, **kwargs):
"""
__init__(self, double x=0.0, double y=0.0) -> RealPoint
Create a wx.RealPoint object
"""
- newobj = _core_.new_RealPoint(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_core_.delete_RealPoint):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _core_.RealPoint_swiginit(self,_core_.new_RealPoint(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_RealPoint
+ __del__ = lambda self : None;
def __eq__(*args, **kwargs):
"""
- __eq__(self, RealPoint pt) -> bool
+ __eq__(self, PyObject other) -> bool
Test for equality of wx.RealPoint objects.
"""
def __ne__(*args, **kwargs):
"""
- __ne__(self, RealPoint pt) -> bool
+ __ne__(self, PyObject other) -> bool
Test for inequality of wx.RealPoint objects.
"""
__safe_for_unpickling__ = True
def __reduce__(self): return (wx.RealPoint, self.Get())
-
-class RealPointPtr(RealPoint):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = RealPoint
-_core_.RealPoint_swigregister(RealPointPtr)
+_core_.RealPoint_swigregister(RealPoint)
#---------------------------------------------------------------------------
and y properties. Most places in wxPython that expect a wx.Point can
also accept a (x,y) tuple.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPoint instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
x = property(_core_.Point_x_get, _core_.Point_x_set)
y = property(_core_.Point_y_get, _core_.Point_y_set)
- def __init__(self, *args, **kwargs):
+ def __init__(self, *args, **kwargs):
"""
__init__(self, int x=0, int y=0) -> Point
Create a wx.Point object
"""
- newobj = _core_.new_Point(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_core_.delete_Point):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _core_.Point_swiginit(self,_core_.new_Point(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_Point
+ __del__ = lambda self : None;
def __eq__(*args, **kwargs):
"""
- __eq__(self, Point pt) -> bool
+ __eq__(self, PyObject other) -> bool
Test for equality of wx.Point objects.
"""
def __ne__(*args, **kwargs):
"""
- __ne__(self, Point pt) -> bool
+ __ne__(self, PyObject other) -> bool
Test for inequality of wx.Point objects.
"""
__safe_for_unpickling__ = True
def __reduce__(self): return (wx.Point, self.Get())
-
-class PointPtr(Point):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Point
-_core_.Point_swigregister(PointPtr)
+_core_.Point_swigregister(Point)
#---------------------------------------------------------------------------
width and height properties. In wxPython most palces that expect a
wx.Rect can also accept a (x,y,width,height) tuple.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxRect instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, int x=0, int y=0, int width=0, int height=0) -> Rect
Create a new Rect object.
"""
- newobj = _core_.new_Rect(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_core_.delete_Rect):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _core_.Rect_swiginit(self,_core_.new_Rect(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_Rect
+ __del__ = lambda self : None;
def GetX(*args, **kwargs):
"""GetX(self) -> int"""
return _core_.Rect_GetX(*args, **kwargs)
"""SetBottomRight(self, Point p)"""
return _core_.Rect_SetBottomRight(*args, **kwargs)
+ def GetTopRight(*args, **kwargs):
+ """GetTopRight(self) -> Point"""
+ return _core_.Rect_GetTopRight(*args, **kwargs)
+
+ def SetTopRight(*args, **kwargs):
+ """SetTopRight(self, Point p)"""
+ return _core_.Rect_SetTopRight(*args, **kwargs)
+
+ def GetBottomLeft(*args, **kwargs):
+ """GetBottomLeft(self) -> Point"""
+ return _core_.Rect_GetBottomLeft(*args, **kwargs)
+
+ def SetBottomLeft(*args, **kwargs):
+ """SetBottomLeft(self, Point p)"""
+ return _core_.Rect_SetBottomLeft(*args, **kwargs)
+
def GetLeft(*args, **kwargs):
"""GetLeft(self) -> int"""
return _core_.Rect_GetLeft(*args, **kwargs)
"""
Offset(self, Point pt)
- Same as OffsetXY but uses dx,dy from Point
+ Same as `OffsetXY` but uses dx,dy from Point
"""
return _core_.Rect_Offset(*args, **kwargs)
def __eq__(*args, **kwargs):
"""
- __eq__(self, Rect rect) -> bool
+ __eq__(self, PyObject other) -> bool
- Test for equality.
+ Test for equality of wx.Rect objects.
"""
return _core_.Rect___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
"""
- __ne__(self, Rect rect) -> bool
+ __ne__(self, PyObject other) -> bool
- Test for inequality.
+ Test for inequality of wx.Rect objects.
"""
return _core_.Rect___ne__(*args, **kwargs)
- def InsideXY(*args, **kwargs):
+ def ContainsXY(*args, **kwargs):
+ """
+ ContainsXY(self, int x, int y) -> bool
+
+ Return True if the point is inside the rect.
+ """
+ return _core_.Rect_ContainsXY(*args, **kwargs)
+
+ def Contains(*args, **kwargs):
"""
- InsideXY(self, int x, int y) -> bool
+ Contains(self, Point pt) -> bool
- Return True if the point is (not strcitly) inside the rect.
+ Return True if the point is inside the rect.
"""
- return _core_.Rect_InsideXY(*args, **kwargs)
+ return _core_.Rect_Contains(*args, **kwargs)
- def Inside(*args, **kwargs):
+ def ContainsRect(*args, **kwargs):
"""
- Inside(self, Point pt) -> bool
+ ContainsRect(self, Rect rect) -> bool
- Return True if the point is (not strcitly) inside the rect.
+ Returns ``True`` if the given rectangle is completely inside this
+ rectangle or touches its boundary.
"""
- return _core_.Rect_Inside(*args, **kwargs)
+ return _core_.Rect_ContainsRect(*args, **kwargs)
+
+ #Inside = wx._deprecated(Contains, "Use `Contains` instead.")
+ #InsideXY = wx._deprecated(ContainsXY, "Use `ContainsXY` instead.")
+ #InsideRect = wx._deprecated(ContainsRect, "Use `ContainsRect` instead.")
+ Inside = Contains
+ InsideXY = ContainsXY
+ InsideRect = ContainsRect
def Intersects(*args, **kwargs):
"""
"""
return _core_.Rect_Intersects(*args, **kwargs)
+ def CenterIn(*args, **kwargs):
+ """
+ CenterIn(self, Rect r, int dir=BOTH) -> Rect
+
+ Center this rectangle within the one passed to the method, which is
+ usually, but not necessarily, the larger one.
+ """
+ return _core_.Rect_CenterIn(*args, **kwargs)
+
+ CentreIn = CenterIn
x = property(_core_.Rect_x_get, _core_.Rect_x_set)
y = property(_core_.Rect_y_get, _core_.Rect_y_set)
width = property(_core_.Rect_width_get, _core_.Rect_width_set)
__safe_for_unpickling__ = True
def __reduce__(self): return (wx.Rect, self.Get())
-
-class RectPtr(Rect):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Rect
-_core_.Rect_swigregister(RectPtr)
+ Bottom = property(GetBottom,SetBottom,doc="See `GetBottom` and `SetBottom`")
+ BottomRight = property(GetBottomRight,SetBottomRight,doc="See `GetBottomRight` and `SetBottomRight`")
+ BottomLeft = property(GetBottomLeft,SetBottomLeft,doc="See `GetBottomLeft` and `SetBottomLeft`")
+ Height = property(GetHeight,SetHeight,doc="See `GetHeight` and `SetHeight`")
+ Left = property(GetLeft,SetLeft,doc="See `GetLeft` and `SetLeft`")
+ Position = property(GetPosition,SetPosition,doc="See `GetPosition` and `SetPosition`")
+ Right = property(GetRight,SetRight,doc="See `GetRight` and `SetRight`")
+ Size = property(GetSize,SetSize,doc="See `GetSize` and `SetSize`")
+ Top = property(GetTop,SetTop,doc="See `GetTop` and `SetTop`")
+ TopLeft = property(GetTopLeft,SetTopLeft,doc="See `GetTopLeft` and `SetTopLeft`")
+ TopRight = property(GetTopRight,SetTopRight,doc="See `GetTopRight` and `SetTopRight`")
+ Width = property(GetWidth,SetWidth,doc="See `GetWidth` and `SetWidth`")
+ X = property(GetX,SetX,doc="See `GetX` and `SetX`")
+ Y = property(GetY,SetY,doc="See `GetY` and `SetY`")
+ Empty = property(IsEmpty,doc="See `IsEmpty`")
+_core_.Rect_swigregister(Rect)
def RectPP(*args, **kwargs):
"""
Create a new Rect object from Points representing two corners.
"""
val = _core_.new_RectPP(*args, **kwargs)
- val.thisown = 1
return val
def RectPS(*args, **kwargs):
Create a new Rect from a position and size.
"""
val = _core_.new_RectPS(*args, **kwargs)
- val.thisown = 1
return val
def RectS(*args, **kwargs):
Create a new Rect from a size only.
"""
val = _core_.new_RectS(*args, **kwargs)
- val.thisown = 1
return val
def IntersectRect(*args, **kwargs):
- """
+ """
IntersectRect(Rect r1, Rect r2) -> Rect
Calculate and return the intersection of r1 and r2.
"""
- return _core_.IntersectRect(*args, **kwargs)
+ return _core_.IntersectRect(*args, **kwargs)
#---------------------------------------------------------------------------
class Point2D(object):
wx.Point2Ds represent a point or a vector in a 2d coordinate system
with floating point values.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPoint2D instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, double x=0.0, double y=0.0) -> Point2D
Create a w.Point2D object.
"""
- newobj = _core_.new_Point2D(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.Point2D_swiginit(self,_core_.new_Point2D(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_Point2D
+ __del__ = lambda self : None;
def GetFloor(*args, **kwargs):
"""
GetFloor() -> (x,y)
def __eq__(*args, **kwargs):
"""
- __eq__(self, Point2D pt) -> bool
+ __eq__(self, PyObject other) -> bool
- Test for equality
+ Test for equality of wx.Point2D objects.
"""
return _core_.Point2D___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
"""
- __ne__(self, Point2D pt) -> bool
+ __ne__(self, PyObject other) -> bool
- Test for inequality
+ Test for inequality of wx.Point2D objects.
"""
return _core_.Point2D___ne__(*args, **kwargs)
__safe_for_unpickling__ = True
def __reduce__(self): return (wx.Point2D, self.Get())
-
-class Point2DPtr(Point2D):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Point2D
-_core_.Point2D_swigregister(Point2DPtr)
+ Floor = property(GetFloor,doc="See `GetFloor`")
+ Rounded = property(GetRounded,doc="See `GetRounded`")
+ VectorAngle = property(GetVectorAngle,SetVectorAngle,doc="See `GetVectorAngle` and `SetVectorAngle`")
+ VectorLength = property(GetVectorLength,SetVectorLength,doc="See `GetVectorLength` and `SetVectorLength`")
+_core_.Point2D_swigregister(Point2D)
def Point2DCopy(*args, **kwargs):
"""
Create a w.Point2D object.
"""
val = _core_.new_Point2DCopy(*args, **kwargs)
- val.thisown = 1
return val
def Point2DFromPoint(*args, **kwargs):
Create a w.Point2D object.
"""
val = _core_.new_Point2DFromPoint(*args, **kwargs)
- val.thisown = 1
return val
#---------------------------------------------------------------------------
+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
class InputStream(object):
"""Proxy of C++ InputStream class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPyInputStream instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, PyObject p) -> InputStream"""
- newobj = _core_.new_InputStream(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_core_.delete_InputStream):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _core_.InputStream_swiginit(self,_core_.new_InputStream(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_InputStream
+ __del__ = lambda self : None;
def close(*args, **kwargs):
"""close(self)"""
return _core_.InputStream_close(*args, **kwargs)
"""TellI(self) -> long"""
return _core_.InputStream_TellI(*args, **kwargs)
-
-class InputStreamPtr(InputStream):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = InputStream
-_core_.InputStream_swigregister(InputStreamPtr)
+_core_.InputStream_swigregister(InputStream)
DefaultPosition = cvar.DefaultPosition
DefaultSize = cvar.DefaultSize
class OutputStream(object):
"""Proxy of C++ OutputStream class"""
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxOutputStream instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ 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
def write(*args, **kwargs):
"""write(self, PyObject obj)"""
return _core_.OutputStream_write(*args, **kwargs)
+ def LastWrite(*args, **kwargs):
+ """LastWrite(self) -> size_t"""
+ return _core_.OutputStream_LastWrite(*args, **kwargs)
-class OutputStreamPtr(OutputStream):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = OutputStream
-_core_.OutputStream_swigregister(OutputStreamPtr)
+_core_.OutputStream_swigregister(OutputStream)
#---------------------------------------------------------------------------
class FSFile(Object):
"""Proxy of C++ FSFile class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxFSFile instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, InputStream stream, String loc, String mimetype, String anchor,
DateTime modif) -> FSFile
"""
- newobj = _core_.new_FSFile(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- self.thisown = 0 # It will normally be deleted by the user of the wx.FileSystem
-
- def __del__(self, destroy=_core_.delete_FSFile):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _core_.FSFile_swiginit(self,_core_.new_FSFile(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_FSFile
+ __del__ = lambda self : None;
def GetStream(*args, **kwargs):
"""GetStream(self) -> InputStream"""
return _core_.FSFile_GetStream(*args, **kwargs)
+ def DetachStream(*args, **kwargs):
+ """DetachStream(self)"""
+ return _core_.FSFile_DetachStream(*args, **kwargs)
+
def GetMimeType(*args, **kwargs):
"""GetMimeType(self) -> String"""
return _core_.FSFile_GetMimeType(*args, **kwargs)
"""GetModificationTime(self) -> DateTime"""
return _core_.FSFile_GetModificationTime(*args, **kwargs)
-
-class FSFilePtr(FSFile):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = FSFile
-_core_.FSFile_swigregister(FSFilePtr)
+ Anchor = property(GetAnchor,doc="See `GetAnchor`")
+ Location = property(GetLocation,doc="See `GetLocation`")
+ MimeType = property(GetMimeType,doc="See `GetMimeType`")
+ ModificationTime = property(GetModificationTime,doc="See `GetModificationTime`")
+ Stream = property(GetStream,doc="See `GetStream`")
+_core_.FSFile_swigregister(FSFile)
class CPPFileSystemHandler(object):
"""Proxy of C++ CPPFileSystemHandler class"""
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxFileSystemHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-
-class CPPFileSystemHandlerPtr(CPPFileSystemHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = CPPFileSystemHandler
-_core_.CPPFileSystemHandler_swigregister(CPPFileSystemHandlerPtr)
+ 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__ = _core_.delete_CPPFileSystemHandler
+ __del__ = lambda self : None;
+_core_.CPPFileSystemHandler_swigregister(CPPFileSystemHandler)
class FileSystemHandler(CPPFileSystemHandler):
"""Proxy of C++ FileSystemHandler class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPyFileSystemHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> FileSystemHandler"""
- newobj = _core_.new_FileSystemHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.FileSystemHandler_swiginit(self,_core_.new_FileSystemHandler(*args, **kwargs))
self._setCallbackInfo(self, FileSystemHandler)
def _setCallbackInfo(*args, **kwargs):
"""GetMimeTypeFromExt(self, String location) -> String"""
return _core_.FileSystemHandler_GetMimeTypeFromExt(*args, **kwargs)
-
-class FileSystemHandlerPtr(FileSystemHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = FileSystemHandler
-_core_.FileSystemHandler_swigregister(FileSystemHandlerPtr)
+ Anchor = property(GetAnchor,doc="See `GetAnchor`")
+ LeftLocation = property(GetLeftLocation,doc="See `GetLeftLocation`")
+ MimeTypeFromExt = property(GetMimeTypeFromExt,doc="See `GetMimeTypeFromExt`")
+ Protocol = property(GetProtocol,doc="See `GetProtocol`")
+ RightLocation = property(GetRightLocation,doc="See `GetRightLocation`")
+_core_.FileSystemHandler_swigregister(FileSystemHandler)
class FileSystem(Object):
"""Proxy of C++ FileSystem class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxFileSystem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> FileSystem"""
- newobj = _core_.new_FileSystem(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_core_.delete_FileSystem):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _core_.FileSystem_swiginit(self,_core_.new_FileSystem(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_FileSystem
+ __del__ = lambda self : None;
def ChangePathTo(*args, **kwargs):
"""ChangePathTo(self, String location, bool is_dir=False)"""
return _core_.FileSystem_ChangePathTo(*args, **kwargs)
return _core_.FileSystem_AddHandler(*args, **kwargs)
AddHandler = staticmethod(AddHandler)
+ def RemoveHandler(*args, **kwargs):
+ """RemoveHandler(CPPFileSystemHandler handler) -> CPPFileSystemHandler"""
+ return _core_.FileSystem_RemoveHandler(*args, **kwargs)
+
+ RemoveHandler = staticmethod(RemoveHandler)
def CleanUpHandlers(*args, **kwargs):
"""CleanUpHandlers()"""
return _core_.FileSystem_CleanUpHandlers(*args, **kwargs)
return _core_.FileSystem_URLToFileName(*args, **kwargs)
URLToFileName = staticmethod(URLToFileName)
-
-class FileSystemPtr(FileSystem):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = FileSystem
-_core_.FileSystem_swigregister(FileSystemPtr)
+ Path = property(GetPath,doc="See `GetPath`")
+_core_.FileSystem_swigregister(FileSystem)
def FileSystem_AddHandler(*args, **kwargs):
- """FileSystem_AddHandler(CPPFileSystemHandler handler)"""
- return _core_.FileSystem_AddHandler(*args, **kwargs)
+ """FileSystem_AddHandler(CPPFileSystemHandler handler)"""
+ return _core_.FileSystem_AddHandler(*args, **kwargs)
-def FileSystem_CleanUpHandlers(*args, **kwargs):
- """FileSystem_CleanUpHandlers()"""
- return _core_.FileSystem_CleanUpHandlers(*args, **kwargs)
+def FileSystem_RemoveHandler(*args, **kwargs):
+ """FileSystem_RemoveHandler(CPPFileSystemHandler handler) -> CPPFileSystemHandler"""
+ return _core_.FileSystem_RemoveHandler(*args, **kwargs)
+
+def FileSystem_CleanUpHandlers(*args):
+ """FileSystem_CleanUpHandlers()"""
+ return _core_.FileSystem_CleanUpHandlers(*args)
def FileSystem_FileNameToURL(*args, **kwargs):
- """FileSystem_FileNameToURL(String filename) -> String"""
- return _core_.FileSystem_FileNameToURL(*args, **kwargs)
+ """FileSystem_FileNameToURL(String filename) -> String"""
+ return _core_.FileSystem_FileNameToURL(*args, **kwargs)
def FileSystem_URLToFileName(*args, **kwargs):
- """FileSystem_URLToFileName(String url) -> String"""
- return _core_.FileSystem_URLToFileName(*args, **kwargs)
+ """FileSystem_URLToFileName(String url) -> String"""
+ return _core_.FileSystem_URLToFileName(*args, **kwargs)
class InternetFSHandler(CPPFileSystemHandler):
"""Proxy of C++ InternetFSHandler class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxInternetFSHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> InternetFSHandler"""
- newobj = _core_.new_InternetFSHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.InternetFSHandler_swiginit(self,_core_.new_InternetFSHandler(*args, **kwargs))
def CanOpen(*args, **kwargs):
"""CanOpen(self, String location) -> bool"""
return _core_.InternetFSHandler_CanOpen(*args, **kwargs)
"""OpenFile(self, FileSystem fs, String location) -> FSFile"""
return _core_.InternetFSHandler_OpenFile(*args, **kwargs)
-
-class InternetFSHandlerPtr(InternetFSHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = InternetFSHandler
-_core_.InternetFSHandler_swigregister(InternetFSHandlerPtr)
+_core_.InternetFSHandler_swigregister(InternetFSHandler)
class ZipFSHandler(CPPFileSystemHandler):
"""Proxy of C++ ZipFSHandler class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxZipFSHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> ZipFSHandler"""
- newobj = _core_.new_ZipFSHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.ZipFSHandler_swiginit(self,_core_.new_ZipFSHandler(*args, **kwargs))
def CanOpen(*args, **kwargs):
"""CanOpen(self, String location) -> bool"""
return _core_.ZipFSHandler_CanOpen(*args, **kwargs)
"""FindNext(self) -> String"""
return _core_.ZipFSHandler_FindNext(*args, **kwargs)
-
-class ZipFSHandlerPtr(ZipFSHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ZipFSHandler
-_core_.ZipFSHandler_swigregister(ZipFSHandlerPtr)
+_core_.ZipFSHandler_swigregister(ZipFSHandler)
def __wxMemoryFSHandler_AddFile_wxImage(*args, **kwargs):
- """__wxMemoryFSHandler_AddFile_wxImage(String filename, Image image, long type)"""
- return _core_.__wxMemoryFSHandler_AddFile_wxImage(*args, **kwargs)
+ """__wxMemoryFSHandler_AddFile_wxImage(String filename, Image image, long type)"""
+ return _core_.__wxMemoryFSHandler_AddFile_wxImage(*args, **kwargs)
def __wxMemoryFSHandler_AddFile_wxBitmap(*args, **kwargs):
- """__wxMemoryFSHandler_AddFile_wxBitmap(String filename, Bitmap bitmap, long type)"""
- return _core_.__wxMemoryFSHandler_AddFile_wxBitmap(*args, **kwargs)
+ """__wxMemoryFSHandler_AddFile_wxBitmap(String filename, Bitmap bitmap, long type)"""
+ return _core_.__wxMemoryFSHandler_AddFile_wxBitmap(*args, **kwargs)
def __wxMemoryFSHandler_AddFile_Data(*args, **kwargs):
- """__wxMemoryFSHandler_AddFile_Data(String filename, PyObject data)"""
- return _core_.__wxMemoryFSHandler_AddFile_Data(*args, **kwargs)
+ """__wxMemoryFSHandler_AddFile_Data(String filename, PyObject data)"""
+ return _core_.__wxMemoryFSHandler_AddFile_Data(*args, **kwargs)
def MemoryFSHandler_AddFile(filename, dataItem, imgType=-1):
"""
Add 'file' to the memory filesystem. The dataItem parameter can
class MemoryFSHandler(CPPFileSystemHandler):
"""Proxy of C++ MemoryFSHandler class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMemoryFSHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> MemoryFSHandler"""
- newobj = _core_.new_MemoryFSHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.MemoryFSHandler_swiginit(self,_core_.new_MemoryFSHandler(*args, **kwargs))
def RemoveFile(*args, **kwargs):
"""RemoveFile(String filename)"""
return _core_.MemoryFSHandler_RemoveFile(*args, **kwargs)
"""FindNext(self) -> String"""
return _core_.MemoryFSHandler_FindNext(*args, **kwargs)
-
-class MemoryFSHandlerPtr(MemoryFSHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = MemoryFSHandler
-_core_.MemoryFSHandler_swigregister(MemoryFSHandlerPtr)
+_core_.MemoryFSHandler_swigregister(MemoryFSHandler)
def MemoryFSHandler_RemoveFile(*args, **kwargs):
- """MemoryFSHandler_RemoveFile(String filename)"""
- return _core_.MemoryFSHandler_RemoveFile(*args, **kwargs)
+ """MemoryFSHandler_RemoveFile(String filename)"""
+ return _core_.MemoryFSHandler_RemoveFile(*args, **kwargs)
IMAGE_ALPHA_TRANSPARENT = _core_.IMAGE_ALPHA_TRANSPARENT
IMAGE_ALPHA_THRESHOLD = _core_.IMAGE_ALPHA_THRESHOLD
IMAGE_ALPHA_OPAQUE = _core_.IMAGE_ALPHA_OPAQUE
+IMAGE_QUALITY_NORMAL = _core_.IMAGE_QUALITY_NORMAL
+IMAGE_QUALITY_HIGH = _core_.IMAGE_QUALITY_HIGH
#---------------------------------------------------------------------------
class ImageHandler(Object):
image creation from data. It is used within `wx.Image` and is not
normally seen by the application.
"""
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxImageHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ 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
def GetName(*args, **kwargs):
"""GetName(self) -> String"""
return _core_.ImageHandler_GetName(*args, **kwargs)
"""CanRead(self, String name) -> bool"""
return _core_.ImageHandler_CanRead(*args, **kwargs)
+ def CanReadStream(*args, **kwargs):
+ """CanReadStream(self, InputStream stream) -> bool"""
+ return _core_.ImageHandler_CanReadStream(*args, **kwargs)
+
def SetName(*args, **kwargs):
"""SetName(self, String name)"""
return _core_.ImageHandler_SetName(*args, **kwargs)
"""SetMimeType(self, String mimetype)"""
return _core_.ImageHandler_SetMimeType(*args, **kwargs)
+ Extension = property(GetExtension,SetExtension,doc="See `GetExtension` and `SetExtension`")
+ MimeType = property(GetMimeType,SetMimeType,doc="See `GetMimeType` and `SetMimeType`")
+ Name = property(GetName,SetName,doc="See `GetName` and `SetName`")
+ Type = property(GetType,SetType,doc="See `GetType` and `SetType`")
+_core_.ImageHandler_swigregister(ImageHandler)
+
+class PyImageHandler(ImageHandler):
+ """
+ This is the base class for implementing image file loading/saving, and
+ image creation from data, all written in Python. To create a custom
+ image handler derive a new class from wx.PyImageHandler and provide
+ the following methods::
+
+ def DoCanRead(self, stream) --> bool
+ '''Check if this handler can read the image on the stream'''
+
+ def LoadFile(self, image, stream, verbose, index) --> bool
+ '''Load image data from the stream and load it into image.'''
+
+ def SaveFile(self, image, stream, verbose) --> bool
+ '''Save the iamge data in image to the stream using
+ this handler's image file format.'''
+
+ def GetImageCount(self, stream) --> int
+ '''If this image format can hold more than one image,
+ how many does the image on the stream have?'''
+
+ To activate your handler create an instance of it and pass it to
+ `wx.Image_AddHandler`. Be sure to call `SetName`, `SetType`, and
+ `SetExtension` from your constructor.
-class ImageHandlerPtr(ImageHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ImageHandler
-_core_.ImageHandler_swigregister(ImageHandlerPtr)
+ """
+ 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) -> PyImageHandler
+
+ This is the base class for implementing image file loading/saving, and
+ image creation from data, all written in Python. To create a custom
+ image handler derive a new class from wx.PyImageHandler and provide
+ the following methods::
+
+ def DoCanRead(self, stream) --> bool
+ '''Check if this handler can read the image on the stream'''
+
+ def LoadFile(self, image, stream, verbose, index) --> bool
+ '''Load image data from the stream and load it into image.'''
+
+ def SaveFile(self, image, stream, verbose) --> bool
+ '''Save the iamge data in image to the stream using
+ this handler's image file format.'''
+
+ def GetImageCount(self, stream) --> int
+ '''If this image format can hold more than one image,
+ how many does the image on the stream have?'''
+
+ To activate your handler create an instance of it and pass it to
+ `wx.Image_AddHandler`. Be sure to call `SetName`, `SetType`, and
+ `SetExtension` from your constructor.
+
+ """
+ _core_.PyImageHandler_swiginit(self,_core_.new_PyImageHandler(*args, **kwargs))
+ self._SetSelf(self)
+
+ def _SetSelf(*args, **kwargs):
+ """_SetSelf(self, PyObject self)"""
+ return _core_.PyImageHandler__SetSelf(*args, **kwargs)
+
+_core_.PyImageHandler_swigregister(PyImageHandler)
class ImageHistogram(object):
"""Proxy of C++ ImageHistogram class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxImageHistogram instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> ImageHistogram"""
- newobj = _core_.new_ImageHistogram(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.ImageHistogram_swiginit(self,_core_.new_ImageHistogram(*args, **kwargs))
def MakeKey(*args, **kwargs):
"""
MakeKey(byte r, byte g, byte b) -> unsigned long
"""
return _core_.ImageHistogram_GetCountColour(*args, **kwargs)
-
-class ImageHistogramPtr(ImageHistogram):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ImageHistogram
-_core_.ImageHistogram_swigregister(ImageHistogramPtr)
+_core_.ImageHistogram_swigregister(ImageHistogram)
def ImageHistogram_MakeKey(*args, **kwargs):
- """
+ """
ImageHistogram_MakeKey(byte r, byte g, byte b) -> unsigned long
Get the key in the histogram for the given RGB values
"""
- return _core_.ImageHistogram_MakeKey(*args, **kwargs)
+ return _core_.ImageHistogram_MakeKey(*args, **kwargs)
+
+class Image_RGBValue(object):
+ """
+ An object that contains values for red, green and blue which represent
+ the value of a color. It is used by `wx.Image.HSVtoRGB` and
+ `wx.Image.RGBtoHSV`, which converts between HSV color space and RGB
+ color space.
+ """
+ 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, byte r=0, byte g=0, byte b=0) -> Image_RGBValue
+
+ Constructor.
+ """
+ _core_.Image_RGBValue_swiginit(self,_core_.new_Image_RGBValue(*args, **kwargs))
+ red = property(_core_.Image_RGBValue_red_get, _core_.Image_RGBValue_red_set)
+ green = property(_core_.Image_RGBValue_green_get, _core_.Image_RGBValue_green_set)
+ blue = property(_core_.Image_RGBValue_blue_get, _core_.Image_RGBValue_blue_set)
+_core_.Image_RGBValue_swigregister(Image_RGBValue)
+
+class Image_HSVValue(object):
+ """
+ An object that contains values for hue, saturation and value which
+ represent the value of a color. It is used by `wx.Image.HSVtoRGB` and
+ `wx.Image.RGBtoHSV`, which +converts between HSV color space and RGB
+ color space.
+ """
+ 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, double h=0.0, double s=0.0, double v=0.0) -> Image_HSVValue
+
+ Constructor.
+ """
+ _core_.Image_HSVValue_swiginit(self,_core_.new_Image_HSVValue(*args, **kwargs))
+ hue = property(_core_.Image_HSVValue_hue_get, _core_.Image_HSVValue_hue_set)
+ saturation = property(_core_.Image_HSVValue_saturation_get, _core_.Image_HSVValue_saturation_set)
+ value = property(_core_.Image_HSVValue_value_get, _core_.Image_HSVValue_value_set)
+_core_.Image_HSVValue_swigregister(Image_HSVValue)
class Image(Object):
"""
with `HasAlpha`. Note that currently only images loaded from PNG files
with transparency information will have an alpha channel.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxImage instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, String name, long type=BITMAP_TYPE_ANY, int index=-1) -> Image
Loads an image from a file.
"""
- newobj = _core_.new_Image(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_core_.delete_Image):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _core_.Image_swiginit(self,_core_.new_Image(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_Image
+ __del__ = lambda self : None;
def Create(*args, **kwargs):
"""
Create(self, int width, int height, bool clear=True)
Destroys the image data.
"""
+ args[0].this.own(False)
return _core_.Image_Destroy(*args, **kwargs)
def Scale(*args, **kwargs):
"""
- Scale(self, int width, int height) -> Image
+ Scale(self, int width, int height, int quality=IMAGE_QUALITY_NORMAL) -> Image
Returns a scaled version of the image. This is also useful for scaling
bitmaps in general as the only other way to scale bitmaps is to blit a
- `wx.MemoryDC` into another `wx.MemoryDC`.
+ `wx.MemoryDC` into another `wx.MemoryDC`. The ``quality`` parameter
+ specifies what method to use for resampling the image. It can be
+ either wx.IMAGE_QUALITY_NORMAL, which uses the normal default scaling
+ method of pixel replication, or wx.IMAGE_QUALITY_HIGH which uses
+ bicubic and box averaging resampling methods for upsampling and
+ downsampling respectively.
"""
return _core_.Image_Scale(*args, **kwargs)
+ def ResampleBox(*args, **kwargs):
+ """ResampleBox(self, int width, int height) -> Image"""
+ return _core_.Image_ResampleBox(*args, **kwargs)
+
+ def ResampleBicubic(*args, **kwargs):
+ """ResampleBicubic(self, int width, int height) -> Image"""
+ return _core_.Image_ResampleBicubic(*args, **kwargs)
+
+ def Blur(*args, **kwargs):
+ """
+ Blur(self, int radius) -> Image
+
+ Blurs the image in both horizontal and vertical directions by the
+ specified pixel ``radius``. This should not be used when using a
+ single mask colour for transparency.
+ """
+ return _core_.Image_Blur(*args, **kwargs)
+
+ def BlurHorizontal(*args, **kwargs):
+ """
+ BlurHorizontal(self, int radius) -> Image
+
+ Blurs the image in the horizontal direction only. This should not be
+ used when using a single mask colour for transparency.
+
+ """
+ return _core_.Image_BlurHorizontal(*args, **kwargs)
+
+ def BlurVertical(*args, **kwargs):
+ """
+ BlurVertical(self, int radius) -> Image
+
+ Blurs the image in the vertical direction only. This should not be
+ used when using a single mask colour for transparency.
+ """
+ return _core_.Image_BlurVertical(*args, **kwargs)
+
def ShrinkBy(*args, **kwargs):
"""
ShrinkBy(self, int xFactor, int yFactor) -> Image
def Rescale(*args, **kwargs):
"""
- Rescale(self, int width, int height) -> Image
+ Rescale(self, int width, int height, int quality=IMAGE_QUALITY_NORMAL) -> Image
Changes the size of the image in-place by scaling it: after a call to
this function, the image will have the given width and height.
"""
return _core_.Image_LoadMimeStream(*args, **kwargs)
- def Ok(*args, **kwargs):
+ def IsOk(*args, **kwargs):
"""
- Ok(self) -> bool
+ IsOk(self) -> bool
Returns true if image data is present.
"""
- return _core_.Image_Ok(*args, **kwargs)
+ return _core_.Image_IsOk(*args, **kwargs)
+ Ok = IsOk
def GetWidth(*args, **kwargs):
"""
GetWidth(self) -> int
return _core_.Image_SetAlphaData(*args, **kwargs)
def GetAlphaBuffer(*args, **kwargs):
- """GetAlphaBuffer(self) -> PyObject"""
+ """
+ GetAlphaBuffer(self) -> PyObject
+
+ Returns a writable Python buffer object that is pointing at the Alpha
+ data buffer inside the wx.Image. You need to ensure that you do not
+ use this buffer object after the image has been destroyed.
+ """
return _core_.Image_GetAlphaBuffer(*args, **kwargs)
def SetAlphaBuffer(*args, **kwargs):
- """SetAlphaBuffer(self, buffer alpha)"""
+ """
+ SetAlphaBuffer(self, buffer alpha)
+
+ Sets the internal image alpha pointer to point at a Python buffer
+ object. This can save making an extra copy of the data but you must
+ ensure that the buffer object lives as long as the wx.Image does.
+ """
return _core_.Image_SetAlphaBuffer(*args, **kwargs)
def SetMaskColour(*args, **kwargs):
"""
return _core_.Image_Replace(*args, **kwargs)
+ def ConvertToGreyscale(*args, **kwargs):
+ """
+ ConvertToGreyscale(self, double lr=0.299, double lg=0.587, double lb=0.114) -> Image
+
+ Convert to greyscale image. Uses the luminance component (Y) of the
+ image. The luma value (YUV) is calculated using (R * lr) + (G * lg) + (B * lb),
+ defaults to ITU-T BT.601
+ """
+ return _core_.Image_ConvertToGreyscale(*args, **kwargs)
+
def ConvertToMono(*args, **kwargs):
"""
ConvertToMono(self, byte r, byte g, byte b) -> Image
return _core_.Image_RemoveHandler(*args, **kwargs)
RemoveHandler = staticmethod(RemoveHandler)
+ def GetHandlers(*args, **kwargs):
+ """GetHandlers() -> PyObject"""
+ return _core_.Image_GetHandlers(*args, **kwargs)
+
+ GetHandlers = staticmethod(GetHandlers)
def GetImageExtWildcard(*args, **kwargs):
"""
GetImageExtWildcard() -> String
"""ConvertToMonoBitmap(self, byte red, byte green, byte blue) -> Bitmap"""
return _core_.Image_ConvertToMonoBitmap(*args, **kwargs)
- def __nonzero__(self): return self.Ok()
+ def RotateHue(*args, **kwargs):
+ """
+ RotateHue(self, double angle)
-class ImagePtr(Image):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Image
-_core_.Image_swigregister(ImagePtr)
+ Rotates the hue of each pixel of the image. Hue is a double in the
+ range -1.0..1.0 where -1.0 is -360 degrees and 1.0 is 360 degrees
+ """
+ return _core_.Image_RotateHue(*args, **kwargs)
-def ImageFromMime(*args, **kwargs):
- """
- ImageFromMime(String name, String mimetype, int index=-1) -> Image
+ def RGBtoHSV(*args, **kwargs):
+ """
+ RGBtoHSV(Image_RGBValue rgb) -> Image_HSVValue
- Loads an image from a file, using a MIME type string (such as
+ Converts a color in RGB color space to HSV color space.
+ """
+ return _core_.Image_RGBtoHSV(*args, **kwargs)
+
+ RGBtoHSV = staticmethod(RGBtoHSV)
+ def HSVtoRGB(*args, **kwargs):
+ """
+ HSVtoRGB(Image_HSVValue hsv) -> Image_RGBValue
+
+ Converts a color in HSV color space to RGB color space.
+ """
+ return _core_.Image_HSVtoRGB(*args, **kwargs)
+
+ HSVtoRGB = staticmethod(HSVtoRGB)
+ def __nonzero__(self): return self.IsOk()
+ AlphaBuffer = property(GetAlphaBuffer,SetAlphaBuffer,doc="See `GetAlphaBuffer` and `SetAlphaBuffer`")
+ AlphaData = property(GetAlphaData,SetAlphaData,doc="See `GetAlphaData` and `SetAlphaData`")
+ Data = property(GetData,SetData,doc="See `GetData` and `SetData`")
+ DataBuffer = property(GetDataBuffer,SetDataBuffer,doc="See `GetDataBuffer` and `SetDataBuffer`")
+ Height = property(GetHeight,doc="See `GetHeight`")
+ MaskBlue = property(GetMaskBlue,doc="See `GetMaskBlue`")
+ MaskGreen = property(GetMaskGreen,doc="See `GetMaskGreen`")
+ MaskRed = property(GetMaskRed,doc="See `GetMaskRed`")
+ Width = property(GetWidth,doc="See `GetWidth`")
+_core_.Image_swigregister(Image)
+
+def ImageFromMime(*args, **kwargs):
+ """
+ ImageFromMime(String name, String mimetype, int index=-1) -> Image
+
+ Loads an image from a file, using a MIME type string (such as
'image/jpeg') to specify image type.
"""
val = _core_.new_ImageFromMime(*args, **kwargs)
- val.thisown = 1
return val
def ImageFromStream(*args, **kwargs):
object.
"""
val = _core_.new_ImageFromStream(*args, **kwargs)
- val.thisown = 1
return val
def ImageFromStreamMime(*args, **kwargs):
object, specifying the image format with a MIME type string.
"""
val = _core_.new_ImageFromStreamMime(*args, **kwargs)
- val.thisown = 1
return val
def EmptyImage(*args, **kwargs):
pixels to black.
"""
val = _core_.new_EmptyImage(*args, **kwargs)
- val.thisown = 1
return val
def ImageFromBitmap(*args, **kwargs):
Construct an Image from a `wx.Bitmap`.
"""
val = _core_.new_ImageFromBitmap(*args, **kwargs)
- val.thisown = 1
return val
def ImageFromData(*args, **kwargs):
must be width*height*3.
"""
val = _core_.new_ImageFromData(*args, **kwargs)
- val.thisown = 1
return val
def ImageFromDataWithAlpha(*args, **kwargs):
alpha data must be width*height bytes.
"""
val = _core_.new_ImageFromDataWithAlpha(*args, **kwargs)
- val.thisown = 1
return val
def Image_CanRead(*args, **kwargs):
- """
+ """
Image_CanRead(String filename) -> bool
Returns True if the image handlers can read this file.
"""
- return _core_.Image_CanRead(*args, **kwargs)
+ return _core_.Image_CanRead(*args, **kwargs)
def Image_GetImageCount(*args, **kwargs):
- """
+ """
Image_GetImageCount(String filename, long type=BITMAP_TYPE_ANY) -> int
If the image file contains more than one image and the image handler
is capable of retrieving these individually, this function will return
the number of available images.
"""
- return _core_.Image_GetImageCount(*args, **kwargs)
+ return _core_.Image_GetImageCount(*args, **kwargs)
def Image_CanReadStream(*args, **kwargs):
- """
+ """
Image_CanReadStream(InputStream stream) -> bool
Returns True if the image handlers can read an image file from the
data currently on the input stream, or a readable Python file-like
object.
"""
- return _core_.Image_CanReadStream(*args, **kwargs)
+ return _core_.Image_CanReadStream(*args, **kwargs)
def Image_AddHandler(*args, **kwargs):
- """Image_AddHandler(ImageHandler handler)"""
- return _core_.Image_AddHandler(*args, **kwargs)
+ """Image_AddHandler(ImageHandler handler)"""
+ return _core_.Image_AddHandler(*args, **kwargs)
def Image_InsertHandler(*args, **kwargs):
- """Image_InsertHandler(ImageHandler handler)"""
- return _core_.Image_InsertHandler(*args, **kwargs)
+ """Image_InsertHandler(ImageHandler handler)"""
+ return _core_.Image_InsertHandler(*args, **kwargs)
def Image_RemoveHandler(*args, **kwargs):
- """Image_RemoveHandler(String name) -> bool"""
- return _core_.Image_RemoveHandler(*args, **kwargs)
+ """Image_RemoveHandler(String name) -> bool"""
+ return _core_.Image_RemoveHandler(*args, **kwargs)
-def Image_GetImageExtWildcard(*args, **kwargs):
- """
+def Image_GetHandlers(*args):
+ """Image_GetHandlers() -> PyObject"""
+ return _core_.Image_GetHandlers(*args)
+
+def Image_GetImageExtWildcard(*args):
+ """
Image_GetImageExtWildcard() -> String
Iterates all registered wxImageHandler objects, and returns a string
containing file extension masks suitable for passing to file open/save
dialog boxes.
"""
- return _core_.Image_GetImageExtWildcard(*args, **kwargs)
+ return _core_.Image_GetImageExtWildcard(*args)
+
+def Image_RGBtoHSV(*args, **kwargs):
+ """
+ Image_RGBtoHSV(Image_RGBValue rgb) -> Image_HSVValue
+
+ Converts a color in RGB color space to HSV color space.
+ """
+ return _core_.Image_RGBtoHSV(*args, **kwargs)
+
+def Image_HSVtoRGB(*args, **kwargs):
+ """
+ Image_HSVtoRGB(Image_HSVValue hsv) -> Image_RGBValue
+
+ Converts a color in HSV color space to RGB color space.
+ """
+ return _core_.Image_HSVtoRGB(*args, **kwargs)
+
+
+def _ImageFromBuffer(*args, **kwargs):
+ """_ImageFromBuffer(int width, int height, buffer data, buffer alpha=None) -> Image"""
+ return _core_._ImageFromBuffer(*args, **kwargs)
+def ImageFromBuffer(width, height, dataBuffer, alphaBuffer=None):
+ """
+ Creates a `wx.Image` from the data in dataBuffer. The dataBuffer
+ parameter must be a Python object that implements the buffer interface,
+ such as a string, array, etc. The dataBuffer object is expected to
+ contain a series of RGB bytes and be width*height*3 bytes long. A buffer
+ object can optionally be supplied for the image's alpha channel data, and
+ it is expected to be width*height bytes long.
+
+ The wx.Image will be created with its data and alpha pointers initialized
+ to the memory address pointed to by the buffer objects, thus saving the
+ time needed to copy the image data from the buffer object to the wx.Image.
+ While this has advantages, it also has the shoot-yourself-in-the-foot
+ risks associated with sharing a C pointer between two objects.
+
+ To help alleviate the risk a reference to the data and alpha buffer
+ objects are kept with the wx.Image, so that they won't get deleted until
+ after the wx.Image is deleted. However please be aware that it is not
+ guaranteed that an object won't move its memory buffer to a new location
+ when it needs to resize its contents. If that happens then the wx.Image
+ will end up referring to an invalid memory location and could cause the
+ application to crash. Therefore care should be taken to not manipulate
+ the objects used for the data and alpha buffers in a way that would cause
+ them to change size.
+ """
+ image = _core_._ImageFromBuffer(width, height, dataBuffer, alphaBuffer)
+ image._buffer = dataBuffer
+ image._alpha = alphaBuffer
+ return image
def InitAllImageHandlers():
"""
BMP_1BPP_BW = _core_.BMP_1BPP_BW
class BMPHandler(ImageHandler):
"""A `wx.ImageHandler` for \*.bmp bitmap files."""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxBMPHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> BMPHandler
A `wx.ImageHandler` for \*.bmp bitmap files.
"""
- newobj = _core_.new_BMPHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class BMPHandlerPtr(BMPHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = BMPHandler
-_core_.BMPHandler_swigregister(BMPHandlerPtr)
+ _core_.BMPHandler_swiginit(self,_core_.new_BMPHandler(*args, **kwargs))
+_core_.BMPHandler_swigregister(BMPHandler)
NullImage = cvar.NullImage
IMAGE_OPTION_FILENAME = cvar.IMAGE_OPTION_FILENAME
IMAGE_OPTION_BMP_FORMAT = cvar.IMAGE_OPTION_BMP_FORMAT
class ICOHandler(BMPHandler):
"""A `wx.ImageHandler` for \*.ico icon files."""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxICOHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> ICOHandler
A `wx.ImageHandler` for \*.ico icon files.
"""
- newobj = _core_.new_ICOHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class ICOHandlerPtr(ICOHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ICOHandler
-_core_.ICOHandler_swigregister(ICOHandlerPtr)
+ _core_.ICOHandler_swiginit(self,_core_.new_ICOHandler(*args, **kwargs))
+_core_.ICOHandler_swigregister(ICOHandler)
class CURHandler(ICOHandler):
"""A `wx.ImageHandler` for \*.cur cursor files."""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxCURHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> CURHandler
A `wx.ImageHandler` for \*.cur cursor files.
"""
- newobj = _core_.new_CURHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class CURHandlerPtr(CURHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = CURHandler
-_core_.CURHandler_swigregister(CURHandlerPtr)
+ _core_.CURHandler_swiginit(self,_core_.new_CURHandler(*args, **kwargs))
+_core_.CURHandler_swigregister(CURHandler)
class ANIHandler(CURHandler):
"""A `wx.ImageHandler` for \*.ani animated cursor files."""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxANIHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> ANIHandler
A `wx.ImageHandler` for \*.ani animated cursor files.
"""
- newobj = _core_.new_ANIHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class ANIHandlerPtr(ANIHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ANIHandler
-_core_.ANIHandler_swigregister(ANIHandlerPtr)
+ _core_.ANIHandler_swiginit(self,_core_.new_ANIHandler(*args, **kwargs))
+_core_.ANIHandler_swigregister(ANIHandler)
class PNGHandler(ImageHandler):
"""A `wx.ImageHandler` for PNG image files."""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPNGHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> PNGHandler
A `wx.ImageHandler` for PNG image files.
"""
- newobj = _core_.new_PNGHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class PNGHandlerPtr(PNGHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PNGHandler
-_core_.PNGHandler_swigregister(PNGHandlerPtr)
+ _core_.PNGHandler_swiginit(self,_core_.new_PNGHandler(*args, **kwargs))
+_core_.PNGHandler_swigregister(PNGHandler)
class GIFHandler(ImageHandler):
"""A `wx.ImageHandler` for GIF image files."""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxGIFHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> GIFHandler
A `wx.ImageHandler` for GIF image files.
"""
- newobj = _core_.new_GIFHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class GIFHandlerPtr(GIFHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = GIFHandler
-_core_.GIFHandler_swigregister(GIFHandlerPtr)
+ _core_.GIFHandler_swiginit(self,_core_.new_GIFHandler(*args, **kwargs))
+_core_.GIFHandler_swigregister(GIFHandler)
class PCXHandler(ImageHandler):
"""A `wx.ImageHandler` for PCX imager files."""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPCXHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> PCXHandler
A `wx.ImageHandler` for PCX imager files.
"""
- newobj = _core_.new_PCXHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class PCXHandlerPtr(PCXHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PCXHandler
-_core_.PCXHandler_swigregister(PCXHandlerPtr)
+ _core_.PCXHandler_swiginit(self,_core_.new_PCXHandler(*args, **kwargs))
+_core_.PCXHandler_swigregister(PCXHandler)
class JPEGHandler(ImageHandler):
"""A `wx.ImageHandler` for JPEG/JPG image files."""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxJPEGHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> JPEGHandler
A `wx.ImageHandler` for JPEG/JPG image files.
"""
- newobj = _core_.new_JPEGHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class JPEGHandlerPtr(JPEGHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = JPEGHandler
-_core_.JPEGHandler_swigregister(JPEGHandlerPtr)
+ _core_.JPEGHandler_swiginit(self,_core_.new_JPEGHandler(*args, **kwargs))
+_core_.JPEGHandler_swigregister(JPEGHandler)
class PNMHandler(ImageHandler):
"""A `wx.ImageHandler` for PNM image files."""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPNMHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> PNMHandler
A `wx.ImageHandler` for PNM image files.
"""
- newobj = _core_.new_PNMHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class PNMHandlerPtr(PNMHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PNMHandler
-_core_.PNMHandler_swigregister(PNMHandlerPtr)
+ _core_.PNMHandler_swiginit(self,_core_.new_PNMHandler(*args, **kwargs))
+_core_.PNMHandler_swigregister(PNMHandler)
class XPMHandler(ImageHandler):
"""A `wx.ImageHandler` for XPM image."""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxXPMHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> XPMHandler
A `wx.ImageHandler` for XPM image.
"""
- newobj = _core_.new_XPMHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class XPMHandlerPtr(XPMHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = XPMHandler
-_core_.XPMHandler_swigregister(XPMHandlerPtr)
+ _core_.XPMHandler_swiginit(self,_core_.new_XPMHandler(*args, **kwargs))
+_core_.XPMHandler_swigregister(XPMHandler)
class TIFFHandler(ImageHandler):
"""A `wx.ImageHandler` for TIFF image files."""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxTIFFHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> TIFFHandler
A `wx.ImageHandler` for TIFF image files.
"""
- newobj = _core_.new_TIFFHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.TIFFHandler_swiginit(self,_core_.new_TIFFHandler(*args, **kwargs))
+_core_.TIFFHandler_swigregister(TIFFHandler)
+
+class TGAHandler(ImageHandler):
+ """A `wx.ImageHandler` for TGA image files."""
+ 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) -> TGAHandler
-class TIFFHandlerPtr(TIFFHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = TIFFHandler
-_core_.TIFFHandler_swigregister(TIFFHandlerPtr)
+ A `wx.ImageHandler` for TGA image files.
+ """
+ _core_.TGAHandler_swiginit(self,_core_.new_TGAHandler(*args, **kwargs))
+_core_.TGAHandler_swigregister(TGAHandler)
QUANTIZE_INCLUDE_WINDOWS_COLOURS = _core_.QUANTIZE_INCLUDE_WINDOWS_COLOURS
QUANTIZE_FILL_DESTINATION_IMAGE = _core_.QUANTIZE_FILL_DESTINATION_IMAGE
class Quantize(object):
"""Performs quantization, or colour reduction, on a wxImage."""
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxQuantize instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ 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
def Quantize(*args, **kwargs):
"""
Quantize(Image src, Image dest, int desiredNoColours=236, int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE) -> bool
return _core_.Quantize_Quantize(*args, **kwargs)
Quantize = staticmethod(Quantize)
-
-class QuantizePtr(Quantize):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Quantize
-_core_.Quantize_swigregister(QuantizePtr)
+_core_.Quantize_swigregister(Quantize)
def Quantize_Quantize(*args, **kwargs):
- """
+ """
Quantize_Quantize(Image src, Image dest, int desiredNoColours=236, int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE) -> bool
Reduce the colours in the source image and put the result into the
destination image, setting the palette in the destination if
needed. Both images may be the same, to overwrite the source image.
"""
- return _core_.Quantize_Quantize(*args, **kwargs)
+ return _core_.Quantize_Quantize(*args, **kwargs)
#---------------------------------------------------------------------------
class EvtHandler(Object):
"""Proxy of C++ EvtHandler class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxEvtHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> EvtHandler"""
- newobj = _core_.new_EvtHandler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.EvtHandler_swiginit(self,_core_.new_EvtHandler(*args, **kwargs))
+ self._setOORInfo(self)
+
def GetNextHandler(*args, **kwargs):
"""GetNextHandler(self) -> EvtHandler"""
return _core_.EvtHandler_GetNextHandler(*args, **kwargs)
return _core_.EvtHandler_Connect(*args, **kwargs)
def Disconnect(*args, **kwargs):
- """Disconnect(self, int id, int lastId=-1, wxEventType eventType=wxEVT_NULL) -> bool"""
+ """Disconnect(self, int id, int lastId=-1, EventType eventType=wxEVT_NULL) -> bool"""
return _core_.EvtHandler_Disconnect(*args, **kwargs)
def _setOORInfo(*args, **kwargs):
"""_setOORInfo(self, PyObject _self, bool incref=True)"""
- return _core_.EvtHandler__setOORInfo(*args, **kwargs)
+ val = _core_.EvtHandler__setOORInfo(*args, **kwargs)
+ args[0].thisown = 0
+ return val
def Bind(self, event, handler, source=None, id=wx.ID_ANY, id2=wx.ID_ANY):
"""
id = source.GetId()
return event.Unbind(self, id, id2)
-
-class EvtHandlerPtr(EvtHandler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = EvtHandler
-_core_.EvtHandler_swigregister(EvtHandlerPtr)
+ EvtHandlerEnabled = property(GetEvtHandlerEnabled,SetEvtHandlerEnabled,doc="See `GetEvtHandlerEnabled` and `SetEvtHandlerEnabled`")
+ NextHandler = property(GetNextHandler,SetNextHandler,doc="See `GetNextHandler` and `SetNextHandler`")
+ PreviousHandler = property(GetPreviousHandler,SetPreviousHandler,doc="See `GetPreviousHandler` and `SetPreviousHandler`")
+_core_.EvtHandler_swigregister(EvtHandler)
#---------------------------------------------------------------------------
EVENT_PROPAGATE_NONE = _core_.EVENT_PROPAGATE_NONE
EVENT_PROPAGATE_MAX = _core_.EVENT_PROPAGATE_MAX
-def NewEventType(*args, **kwargs):
- """NewEventType() -> wxEventType"""
- return _core_.NewEventType(*args, **kwargs)
+def NewEventType(*args):
+ """NewEventType() -> EventType"""
+ return _core_.NewEventType(*args)
wxEVT_NULL = _core_.wxEVT_NULL
wxEVT_FIRST = _core_.wxEVT_FIRST
wxEVT_USER_FIRST = _core_.wxEVT_USER_FIRST
wxEVT_SCROLL_PAGEDOWN = _core_.wxEVT_SCROLL_PAGEDOWN
wxEVT_SCROLL_THUMBTRACK = _core_.wxEVT_SCROLL_THUMBTRACK
wxEVT_SCROLL_THUMBRELEASE = _core_.wxEVT_SCROLL_THUMBRELEASE
-wxEVT_SCROLL_ENDSCROLL = _core_.wxEVT_SCROLL_ENDSCROLL
+wxEVT_SCROLL_CHANGED = _core_.wxEVT_SCROLL_CHANGED
+wxEVT_SCROLL_ENDSCROLL = wxEVT_SCROLL_CHANGED
wxEVT_SCROLLWIN_TOP = _core_.wxEVT_SCROLLWIN_TOP
wxEVT_SCROLLWIN_BOTTOM = _core_.wxEVT_SCROLLWIN_BOTTOM
wxEVT_SCROLLWIN_LINEUP = _core_.wxEVT_SCROLLWIN_LINEUP
wxEVT_END_SESSION = _core_.wxEVT_END_SESSION
wxEVT_QUERY_END_SESSION = _core_.wxEVT_QUERY_END_SESSION
wxEVT_ACTIVATE_APP = _core_.wxEVT_ACTIVATE_APP
-wxEVT_POWER = _core_.wxEVT_POWER
wxEVT_ACTIVATE = _core_.wxEVT_ACTIVATE
wxEVT_CREATE = _core_.wxEVT_CREATE
wxEVT_DESTROY = _core_.wxEVT_DESTROY
wxEVT_ICONIZE = _core_.wxEVT_ICONIZE
wxEVT_MAXIMIZE = _core_.wxEVT_MAXIMIZE
wxEVT_MOUSE_CAPTURE_CHANGED = _core_.wxEVT_MOUSE_CAPTURE_CHANGED
+wxEVT_MOUSE_CAPTURE_LOST = _core_.wxEVT_MOUSE_CAPTURE_LOST
wxEVT_PAINT = _core_.wxEVT_PAINT
wxEVT_ERASE_BACKGROUND = _core_.wxEVT_ERASE_BACKGROUND
wxEVT_NC_PAINT = _core_.wxEVT_NC_PAINT
wxEVT_SIZING = _core_.wxEVT_SIZING
wxEVT_MOVING = _core_.wxEVT_MOVING
wxEVT_HIBERNATE = _core_.wxEVT_HIBERNATE
+wxEVT_COMMAND_TEXT_COPY = _core_.wxEVT_COMMAND_TEXT_COPY
+wxEVT_COMMAND_TEXT_CUT = _core_.wxEVT_COMMAND_TEXT_CUT
+wxEVT_COMMAND_TEXT_PASTE = _core_.wxEVT_COMMAND_TEXT_PASTE
wxEVT_COMMAND_LEFT_CLICK = _core_.wxEVT_COMMAND_LEFT_CLICK
wxEVT_COMMAND_LEFT_DCLICK = _core_.wxEVT_COMMAND_LEFT_DCLICK
wxEVT_COMMAND_RIGHT_CLICK = _core_.wxEVT_COMMAND_RIGHT_CLICK
EVT_CHAR = wx.PyEventBinder( wxEVT_CHAR )
EVT_KEY_DOWN = wx.PyEventBinder( wxEVT_KEY_DOWN )
EVT_KEY_UP = wx.PyEventBinder( wxEVT_KEY_UP )
-EVT_HOTKEY = wx.PyEventBinder( wxEVT_HOTKEY, 1)
+EVT_HOTKEY = wx.PyEventBinder( wxEVT_HOTKEY, 1)
EVT_CHAR_HOOK = wx.PyEventBinder( wxEVT_CHAR_HOOK )
EVT_MENU_OPEN = wx.PyEventBinder( wxEVT_MENU_OPEN )
EVT_MENU_CLOSE = wx.PyEventBinder( wxEVT_MENU_CLOSE )
EVT_CHILD_FOCUS = wx.PyEventBinder( wxEVT_CHILD_FOCUS )
EVT_ACTIVATE = wx.PyEventBinder( wxEVT_ACTIVATE )
EVT_ACTIVATE_APP = wx.PyEventBinder( wxEVT_ACTIVATE_APP )
-EVT_HIBERNATE = wx.PyEventBinder( wxEVT_HIBERNATE )
+EVT_HIBERNATE = wx.PyEventBinder( wxEVT_HIBERNATE )
EVT_END_SESSION = wx.PyEventBinder( wxEVT_END_SESSION )
EVT_QUERY_END_SESSION = wx.PyEventBinder( wxEVT_QUERY_END_SESSION )
EVT_DROP_FILES = wx.PyEventBinder( wxEVT_DROP_FILES )
EVT_WINDOW_DESTROY = wx.PyEventBinder( wxEVT_DESTROY )
EVT_SET_CURSOR = wx.PyEventBinder( wxEVT_SET_CURSOR )
EVT_MOUSE_CAPTURE_CHANGED = wx.PyEventBinder( wxEVT_MOUSE_CAPTURE_CHANGED )
+EVT_MOUSE_CAPTURE_LOST = wx.PyEventBinder( wxEVT_MOUSE_CAPTURE_LOST )
EVT_LEFT_DOWN = wx.PyEventBinder( wxEVT_LEFT_DOWN )
EVT_LEFT_UP = wx.PyEventBinder( wxEVT_LEFT_UP )
# Scrolling from wxWindow (sent to wxScrolledWindow)
-EVT_SCROLLWIN = wx.PyEventBinder([ wxEVT_SCROLLWIN_TOP,
+EVT_SCROLLWIN = wx.PyEventBinder([ wxEVT_SCROLLWIN_TOP,
wxEVT_SCROLLWIN_BOTTOM,
wxEVT_SCROLLWIN_LINEUP,
wxEVT_SCROLLWIN_LINEDOWN,
- wxEVT_SCROLLWIN_PAGEUP,
+ wxEVT_SCROLLWIN_PAGEUP,
wxEVT_SCROLLWIN_PAGEDOWN,
wxEVT_SCROLLWIN_THUMBTRACK,
wxEVT_SCROLLWIN_THUMBRELEASE,
EVT_SCROLLWIN_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBRELEASE )
# Scrolling from wx.Slider and wx.ScrollBar
-EVT_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
- wxEVT_SCROLL_BOTTOM,
- wxEVT_SCROLL_LINEUP,
- wxEVT_SCROLL_LINEDOWN,
- wxEVT_SCROLL_PAGEUP,
- wxEVT_SCROLL_PAGEDOWN,
- wxEVT_SCROLL_THUMBTRACK,
- wxEVT_SCROLL_THUMBRELEASE,
- wxEVT_SCROLL_ENDSCROLL,
+EVT_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
+ wxEVT_SCROLL_BOTTOM,
+ wxEVT_SCROLL_LINEUP,
+ wxEVT_SCROLL_LINEDOWN,
+ wxEVT_SCROLL_PAGEUP,
+ wxEVT_SCROLL_PAGEDOWN,
+ wxEVT_SCROLL_THUMBTRACK,
+ wxEVT_SCROLL_THUMBRELEASE,
+ wxEVT_SCROLL_CHANGED,
])
EVT_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP )
EVT_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN )
EVT_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK )
EVT_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE )
-EVT_SCROLL_ENDSCROLL = wx.PyEventBinder( wxEVT_SCROLL_ENDSCROLL )
+EVT_SCROLL_CHANGED = wx.PyEventBinder( wxEVT_SCROLL_CHANGED )
+EVT_SCROLL_ENDSCROLL = EVT_SCROLL_CHANGED
# Scrolling from wx.Slider and wx.ScrollBar, with an id
-EVT_COMMAND_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
- wxEVT_SCROLL_BOTTOM,
- wxEVT_SCROLL_LINEUP,
- wxEVT_SCROLL_LINEDOWN,
- wxEVT_SCROLL_PAGEUP,
- wxEVT_SCROLL_PAGEDOWN,
- wxEVT_SCROLL_THUMBTRACK,
+EVT_COMMAND_SCROLL = wx.PyEventBinder([ wxEVT_SCROLL_TOP,
+ wxEVT_SCROLL_BOTTOM,
+ wxEVT_SCROLL_LINEUP,
+ wxEVT_SCROLL_LINEDOWN,
+ wxEVT_SCROLL_PAGEUP,
+ wxEVT_SCROLL_PAGEDOWN,
+ wxEVT_SCROLL_THUMBTRACK,
wxEVT_SCROLL_THUMBRELEASE,
- wxEVT_SCROLL_ENDSCROLL,
+ wxEVT_SCROLL_CHANGED,
], 1)
EVT_COMMAND_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP, 1)
EVT_COMMAND_SCROLL_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLL_PAGEDOWN, 1)
EVT_COMMAND_SCROLL_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK, 1)
EVT_COMMAND_SCROLL_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLL_THUMBRELEASE, 1)
-EVT_COMMAND_SCROLL_ENDSCROLL = wx.PyEventBinder( wxEVT_SCROLL_ENDSCROLL, 1)
+EVT_COMMAND_SCROLL_CHANGED = wx.PyEventBinder( wxEVT_SCROLL_CHANGED, 1)
+EVT_COMMAND_SCROLL_ENDSCROLL = EVT_COMMAND_SCROLL_CHANGED
EVT_BUTTON = wx.PyEventBinder( wxEVT_COMMAND_BUTTON_CLICKED, 1)
EVT_CHECKBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKBOX_CLICKED, 1)
EVT_CONTEXT_MENU = wx.PyEventBinder( wxEVT_CONTEXT_MENU )
+EVT_TEXT_CUT = wx.PyEventBinder( wxEVT_COMMAND_TEXT_CUT )
+EVT_TEXT_COPY = wx.PyEventBinder( wxEVT_COMMAND_TEXT_COPY )
+EVT_TEXT_PASTE = wx.PyEventBinder( wxEVT_COMMAND_TEXT_PASTE )
#---------------------------------------------------------------------------
callback or member function. wx.Event is an abstract base class for
other event classes
"""
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __del__(self, destroy=_core_.delete_Event):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ 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__ = _core_.delete_Event
+ __del__ = lambda self : None;
def SetEventType(*args, **kwargs):
"""
- SetEventType(self, wxEventType typ)
+ SetEventType(self, EventType typ)
Sets the specific type of the event.
"""
def GetEventType(*args, **kwargs):
"""
- GetEventType(self) -> wxEventType
+ GetEventType(self) -> EventType
Returns the identifier of the given event type, such as
``wxEVT_COMMAND_BUTTON_CLICKED``.
"""
Skip(self, bool skip=True)
- Called by an event handler, it controls whether additional event
- handlers bound to this event will be called after the current event
- handler returns. Skip(false) (the default setting) will prevent
- additional event handlers from being called and control will be
- returned to the sender of the event immediately after the current
- handler has finished. Skip(True) will cause the event processing
- system to continue searching for a handler function for this event.
-
+ This method can be used inside an event handler to control whether
+ further event handlers bound to this event will be called after the
+ current one returns. Without Skip() (or equivalently if Skip(False) is
+ used), the event will not be processed any more. If Skip(True) is
+ called, the event processing system continues searching for a further
+ handler function for this event, even though it has been processed
+ already in the current handler.
"""
return _core_.Event_Skip(*args, **kwargs)
"""Clone(self) -> Event"""
return _core_.Event_Clone(*args, **kwargs)
-
-class EventPtr(Event):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Event
-_core_.Event_swigregister(EventPtr)
+ EventObject = property(GetEventObject,SetEventObject,doc="See `GetEventObject` and `SetEventObject`")
+ EventType = property(GetEventType,SetEventType,doc="See `GetEventType` and `SetEventType`")
+ Id = property(GetId,SetId,doc="See `GetId` and `SetId`")
+ Skipped = property(GetSkipped,doc="See `GetSkipped`")
+ Timestamp = property(GetTimestamp,SetTimestamp,doc="See `GetTimestamp` and `SetTimestamp`")
+_core_.Event_swigregister(Event)
#---------------------------------------------------------------------------
create an instance of this class and then whe it is destroyed the
propogation of the event will be restored.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPropagationDisabler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, Event event) -> PropagationDisabler
create an instance of this class and then whe it is destroyed the
propogation of the event will be restored.
"""
- newobj = _core_.new_PropagationDisabler(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_core_.delete_PropagationDisabler):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
-
-class PropagationDisablerPtr(PropagationDisabler):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PropagationDisabler
-_core_.PropagationDisabler_swigregister(PropagationDisablerPtr)
+ _core_.PropagationDisabler_swiginit(self,_core_.new_PropagationDisabler(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_PropagationDisabler
+ __del__ = lambda self : None;
+_core_.PropagationDisabler_swigregister(PropagationDisabler)
class PropagateOnce(object):
"""
event. Simply create an instance of this class and then whe it is
destroyed the propogation of the event will be restored.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPropagateOnce instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, Event event) -> PropagateOnce
event. Simply create an instance of this class and then whe it is
destroyed the propogation of the event will be restored.
"""
- newobj = _core_.new_PropagateOnce(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_core_.delete_PropagateOnce):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
-
-class PropagateOncePtr(PropagateOnce):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PropagateOnce
-_core_.PropagateOnce_swigregister(PropagateOncePtr)
+ _core_.PropagateOnce_swiginit(self,_core_.new_PropagateOnce(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_PropagateOnce
+ __del__ = lambda self : None;
+_core_.PropagateOnce_swigregister(PropagateOnce)
#---------------------------------------------------------------------------
originate from a variety of simple controls, as well as menus and
toolbars.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxCommandEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, wxEventType commandType=wxEVT_NULL, int winid=0) -> CommandEvent
+ __init__(self, EventType commandType=wxEVT_NULL, int winid=0) -> CommandEvent
This event class contains information about command events, which
originate from a variety of simple controls, as well as menus and
toolbars.
"""
- newobj = _core_.new_CommandEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.CommandEvent_swiginit(self,_core_.new_CommandEvent(*args, **kwargs))
def GetSelection(*args, **kwargs):
"""
GetSelection(self) -> int
"""
GetExtraLong(self) -> long
- Returns extra information dependant on the event objects type. If the event
- comes from a listbox selection, it is a boolean determining whether the event
- was a selection (true) or a deselection (false). A listbox deselection only
- occurs for multiple-selection boxes, and in this case the index and string
- values are indeterminate and the listbox must be examined by the application.
+ Returns extra information dependant on the event objects type. If the
+ event comes from a listbox selection, it is a boolean determining
+ whether the event was a selection (true) or a deselection (false). A
+ listbox deselection only occurs for multiple-selection boxes, and in
+ this case the index and string values are indeterminate and the
+ listbox must be examined by the application.
"""
return _core_.CommandEvent_GetExtraLong(*args, **kwargs)
def GetInt(*args, **kwargs):
"""
- GetInt(self) -> long
+ GetInt(self) -> int
- Returns the integer identifier corresponding to a listbox, choice or radiobox
- selection (only if the event was a selection, not a deselection), or a boolean
- value representing the value of a checkbox.
+ Returns the integer identifier corresponding to a listbox, choice or
+ radiobox selection (only if the event was a selection, not a
+ deselection), or a boolean value representing the value of a checkbox.
"""
return _core_.CommandEvent_GetInt(*args, **kwargs)
+ def GetClientData(*args, **kwargs):
+ """
+ GetClientData(self) -> PyObject
+
+ Returns the client data object for a listbox or choice selection event, (if any.)
+ """
+ return _core_.CommandEvent_GetClientData(*args, **kwargs)
+
+ def SetClientData(*args, **kwargs):
+ """
+ SetClientData(self, PyObject clientData)
+
+ Associate the given client data with the item at position n.
+ """
+ return _core_.CommandEvent_SetClientData(*args, **kwargs)
+
+ GetClientObject = GetClientData
+ SetClientObject = SetClientData
+
def Clone(*args, **kwargs):
"""Clone(self) -> Event"""
return _core_.CommandEvent_Clone(*args, **kwargs)
-
-class CommandEventPtr(CommandEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = CommandEvent
-_core_.CommandEvent_swigregister(CommandEventPtr)
+ ClientData = property(GetClientData,SetClientData,doc="See `GetClientData` and `SetClientData`")
+ ClientObject = property(GetClientObject,SetClientObject,doc="See `GetClientObject` and `SetClientObject`")
+ ExtraLong = property(GetExtraLong,SetExtraLong,doc="See `GetExtraLong` and `SetExtraLong`")
+ Int = property(GetInt,SetInt,doc="See `GetInt` and `SetInt`")
+ Selection = property(GetSelection,doc="See `GetSelection`")
+ String = property(GetString,SetString,doc="See `GetString` and `SetString`")
+_core_.CommandEvent_swigregister(CommandEvent)
#---------------------------------------------------------------------------
allows that change to be prevented from happening. The event handler
can call `Veto` or `Allow` to tell the control what to do.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxNotifyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, wxEventType commandType=wxEVT_NULL, int winid=0) -> NotifyEvent
+ __init__(self, EventType commandType=wxEVT_NULL, int winid=0) -> NotifyEvent
An instance of this class (or one of its derived classes) is sent from
a control when the control's state is being changed and the control
allows that change to be prevented from happening. The event handler
can call `Veto` or `Allow` to tell the control what to do.
"""
- newobj = _core_.new_NotifyEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.NotifyEvent_swiginit(self,_core_.new_NotifyEvent(*args, **kwargs))
def Veto(*args, **kwargs):
"""
Veto(self)
"""
return _core_.NotifyEvent_IsAllowed(*args, **kwargs)
-
-class NotifyEventPtr(NotifyEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = NotifyEvent
-_core_.NotifyEvent_swigregister(NotifyEventPtr)
+_core_.NotifyEvent_swigregister(NotifyEvent)
#---------------------------------------------------------------------------
instnaces of this event class, but send the `wx.ScrollWinEvent`
instead.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxScrollEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, wxEventType commandType=wxEVT_NULL, int winid=0, int pos=0,
+ __init__(self, EventType commandType=wxEVT_NULL, int winid=0, int pos=0,
int orient=0) -> ScrollEvent
"""
- newobj = _core_.new_ScrollEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.ScrollEvent_swiginit(self,_core_.new_ScrollEvent(*args, **kwargs))
def GetOrientation(*args, **kwargs):
"""
GetOrientation(self) -> int
"""SetPosition(self, int pos)"""
return _core_.ScrollEvent_SetPosition(*args, **kwargs)
-
-class ScrollEventPtr(ScrollEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ScrollEvent
-_core_.ScrollEvent_swigregister(ScrollEventPtr)
+ Orientation = property(GetOrientation,SetOrientation,doc="See `GetOrientation` and `SetOrientation`")
+ Position = property(GetPosition,SetPosition,doc="See `GetPosition` and `SetPosition`")
+_core_.ScrollEvent_swigregister(ScrollEvent)
#---------------------------------------------------------------------------
A wx.ScrollWinEvent holds information about scrolling and is sent from
scrolling windows.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxScrollWinEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, wxEventType commandType=wxEVT_NULL, int pos=0, int orient=0) -> ScrollWinEvent
+ __init__(self, EventType commandType=wxEVT_NULL, int pos=0, int orient=0) -> ScrollWinEvent
A wx.ScrollWinEvent holds information about scrolling and is sent from
scrolling windows.
"""
- newobj = _core_.new_ScrollWinEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.ScrollWinEvent_swiginit(self,_core_.new_ScrollWinEvent(*args, **kwargs))
def GetOrientation(*args, **kwargs):
"""
GetOrientation(self) -> int
"""SetPosition(self, int pos)"""
return _core_.ScrollWinEvent_SetPosition(*args, **kwargs)
-
-class ScrollWinEventPtr(ScrollWinEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ScrollWinEvent
-_core_.ScrollWinEvent_swigregister(ScrollWinEventPtr)
+ Orientation = property(GetOrientation,SetOrientation,doc="See `GetOrientation` and `SetOrientation`")
+ Position = property(GetPosition,SetPosition,doc="See `GetPosition` and `SetPosition`")
+_core_.ScrollWinEvent_swigregister(ScrollWinEvent)
#---------------------------------------------------------------------------
underlying GUI behaviour is (which is platform-dependent). The same
applies, of course, to other mouse buttons as well.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMouseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, wxEventType mouseType=wxEVT_NULL) -> MouseEvent
+ __init__(self, EventType mouseType=wxEVT_NULL) -> MouseEvent
Constructs a wx.MouseEvent. Valid event types are:
* wxEVT_MOTION
* wxEVT_MOUSEWHEEL
"""
- newobj = _core_.new_MouseEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.MouseEvent_swiginit(self,_core_.new_MouseEvent(*args, **kwargs))
def IsButton(*args, **kwargs):
"""
IsButton(self) -> bool
"""
ButtonDown(self, int but=MOUSE_BTN_ANY) -> bool
- If the argument is omitted, this returns true if the event was any mouse
- button down event. Otherwise the argument specifies which button-down
- event shold be checked for (see `Button` for the possible values).
+ If the argument is omitted, this returns true if the event was any
+ mouse button down event. Otherwise the argument specifies which
+ button-down event shold be checked for (see `Button` for the possible
+ values).
"""
return _core_.MouseEvent_ButtonDown(*args, **kwargs)
ButtonUp(self, int but=MOUSE_BTN_ANY) -> bool
If the argument is omitted, this returns true if the event was any
- mouse button up event. Otherwise the argument specifies which
- button up event to check for (see `Button` for the possible values).
+ mouse button up event. Otherwise the argument specifies which button
+ up event to check for (see `Button` for the possible values).
"""
return _core_.MouseEvent_ButtonUp(*args, **kwargs)
"Cmd" is a pseudo key which is the same as Control for PC and Unix
platforms but the special "Apple" (a.k.a as "Command") key on
- Macs: it often makes sense to use it instead of, say, `ControlDown`
+ Macs. It often makes sense to use it instead of, say, `ControlDown`
because Cmd key is used for the same thing under Mac as Ctrl
elsewhere. The Ctrl key still exists, it's just not used for this
purpose. So for non-Mac platforms this is the same as `ControlDown`
m_wheelRotation = property(_core_.MouseEvent_m_wheelRotation_get, _core_.MouseEvent_m_wheelRotation_set)
m_wheelDelta = property(_core_.MouseEvent_m_wheelDelta_get, _core_.MouseEvent_m_wheelDelta_set)
m_linesPerAction = property(_core_.MouseEvent_m_linesPerAction_get, _core_.MouseEvent_m_linesPerAction_set)
-
-class MouseEventPtr(MouseEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = MouseEvent
-_core_.MouseEvent_swigregister(MouseEventPtr)
+ Button = property(GetButton,doc="See `GetButton`")
+ LinesPerAction = property(GetLinesPerAction,doc="See `GetLinesPerAction`")
+ LogicalPosition = property(GetLogicalPosition,doc="See `GetLogicalPosition`")
+ Position = property(GetPosition,doc="See `GetPosition`")
+ WheelDelta = property(GetWheelDelta,doc="See `GetWheelDelta`")
+ WheelRotation = property(GetWheelRotation,doc="See `GetWheelRotation`")
+ X = property(GetX,doc="See `GetX`")
+ Y = property(GetY,doc="See `GetY`")
+_core_.MouseEvent_swigregister(MouseEvent)
#---------------------------------------------------------------------------
class SetCursorEvent(Event):
- """Proxy of C++ SetCursorEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxSetCursorEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, int x=0, int y=0) -> SetCursorEvent"""
- newobj = _core_.new_SetCursorEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ A SetCursorEvent is generated when the mouse cursor is about to be set
+ as a result of mouse motion. This event gives the application the
+ chance to perform specific mouse cursor processing based on the
+ current position of the mouse within the window. Use the `SetCursor`
+ method to specify the cursor you want to be displayed.
+ """
+ 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, int x=0, int y=0) -> SetCursorEvent
+
+ Construct a new `wx.SetCursorEvent`.
+ """
+ _core_.SetCursorEvent_swiginit(self,_core_.new_SetCursorEvent(*args, **kwargs))
def GetX(*args, **kwargs):
- """GetX(self) -> int"""
+ """
+ GetX(self) -> int
+
+ Returns the X coordinate of the mouse in client coordinates.
+ """
return _core_.SetCursorEvent_GetX(*args, **kwargs)
def GetY(*args, **kwargs):
- """GetY(self) -> int"""
+ """
+ GetY(self) -> int
+
+ Returns the Y coordinate of the mouse in client coordinates.
+ """
return _core_.SetCursorEvent_GetY(*args, **kwargs)
def SetCursor(*args, **kwargs):
- """SetCursor(self, Cursor cursor)"""
+ """
+ SetCursor(self, Cursor cursor)
+
+ Sets the cursor associated with this event.
+ """
return _core_.SetCursorEvent_SetCursor(*args, **kwargs)
def GetCursor(*args, **kwargs):
- """GetCursor(self) -> Cursor"""
+ """
+ GetCursor(self) -> Cursor
+
+ Returns a reference to the cursor specified by this event.
+ """
return _core_.SetCursorEvent_GetCursor(*args, **kwargs)
def HasCursor(*args, **kwargs):
- """HasCursor(self) -> bool"""
- return _core_.SetCursorEvent_HasCursor(*args, **kwargs)
+ """
+ HasCursor(self) -> bool
+ Returns true if the cursor specified by this event is a valid cursor.
+ """
+ return _core_.SetCursorEvent_HasCursor(*args, **kwargs)
-class SetCursorEventPtr(SetCursorEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = SetCursorEvent
-_core_.SetCursorEvent_swigregister(SetCursorEventPtr)
+ Cursor = property(GetCursor,SetCursor,doc="See `GetCursor` and `SetCursor`")
+ X = property(GetX,doc="See `GetX`")
+ Y = property(GetY,doc="See `GetY`")
+_core_.SetCursorEvent_swigregister(SetCursorEvent)
#---------------------------------------------------------------------------
class KeyEvent(Event):
- """Proxy of C++ KeyEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxKeyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, wxEventType keyType=wxEVT_NULL) -> KeyEvent"""
- newobj = _core_.new_KeyEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ This event class contains information about keypress and character
+ events. These events are only sent to the widget that currently has
+ the keyboard focus.
+
+ Notice that there are three different kinds of keyboard events in
+ wxWidgets: key down and up events and char events. The difference
+ between the first two is clear - the first corresponds to a key press
+ and the second to a key release - otherwise they are identical. Just
+ note that if the key is maintained in a pressed state you will
+ typically get a lot of (automatically generated) down events but only
+ one up so it is wrong to assume that there is one up event
+ corresponding to each down one.
+
+ Both key events provide untranslated key codes while the char event
+ carries the translated one. The untranslated code for alphanumeric
+ keys is always an upper case value. For the other keys it is one of
+ WXK_XXX values from the keycodes table. The translated key is, in
+ general, the character the user expects to appear as the result of the
+ key combination when typing the text into a text entry zone, for
+ example.
+
+ A few examples to clarify this (all assume that CAPS LOCK is unpressed
+ and the standard US keyboard): when the 'A' key is pressed, the key
+ down event key code is equal to ASCII A == 65. But the char event key
+ code is ASCII a == 97. On the other hand, if you press both SHIFT and
+ 'A' keys simultaneously , the key code in key down event will still be
+ just 'A' while the char event key code parameter will now be 'A' as
+ well.
+
+ Although in this simple case it is clear that the correct key code
+ could be found in the key down event handler by checking the value
+ returned by `ShiftDown`, in general you should use EVT_CHAR for this
+ as for non alphanumeric keys or non-US keyboard layouts the
+ translation is keyboard-layout dependent and can only be done properly
+ by the system itself.
+
+ Another kind of translation is done when the control key is pressed:
+ for example, for CTRL-A key press the key down event still carries the
+ same key code 'A' as usual but the char event will have key code of 1,
+ the ASCII value of this key combination.
+
+ You may discover how the other keys on your system behave
+ interactively by running the KeyEvents sample in the wxPython demo and
+ pressing some keys while the blue box at the top has the keyboard
+ focus.
+
+ **Note**: If a key down event is caught and the event handler does not
+ call event.Skip() then the coresponding char event will not
+ happen. This is by design and enables the programs that handle both
+ types of events to be a bit simpler.
+
+ **Note for Windows programmers**: The key and char events in wxWidgets
+ are similar to but slightly different from Windows WM_KEYDOWN and
+ WM_CHAR events. In particular, Alt-x combination will generate a char
+ event in wxWidgets (unless it is used as an accelerator).
+
+ **Tip**: be sure to call event.Skip() for events that you don't
+ process in key event function, otherwise menu shortcuts may cease to
+ work under Windows.
+
+ """
+ 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, EventType eventType=wxEVT_NULL) -> KeyEvent
+
+ Construct a new `wx.KeyEvent`. Valid event types are:
+ *
+ """
+ _core_.KeyEvent_swiginit(self,_core_.new_KeyEvent(*args, **kwargs))
+ def GetModifiers(*args, **kwargs):
+ """
+ GetModifiers(self) -> int
+
+ Returns a bitmask of the current modifier settings. Can be used to
+ check if the key event has exactly the given modifiers without having
+ to explicitly check that the other modifiers are not down. For
+ example::
+
+ if event.GetModifers() == wx.MOD_CONTROL:
+ DoSomething()
+
+ """
+ return _core_.KeyEvent_GetModifiers(*args, **kwargs)
+
def ControlDown(*args, **kwargs):
- """ControlDown(self) -> bool"""
+ """
+ ControlDown(self) -> bool
+
+ Returns ``True`` if the Control key was down at the time of the event.
+ """
return _core_.KeyEvent_ControlDown(*args, **kwargs)
def MetaDown(*args, **kwargs):
- """MetaDown(self) -> bool"""
+ """
+ MetaDown(self) -> bool
+
+ Returns ``True`` if the Meta key was down at the time of the event.
+ """
return _core_.KeyEvent_MetaDown(*args, **kwargs)
def AltDown(*args, **kwargs):
- """AltDown(self) -> bool"""
+ """
+ AltDown(self) -> bool
+
+ Returns ``True`` if the Alt key was down at the time of the event.
+ """
return _core_.KeyEvent_AltDown(*args, **kwargs)
def ShiftDown(*args, **kwargs):
- """ShiftDown(self) -> bool"""
+ """
+ ShiftDown(self) -> bool
+
+ Returns ``True`` if the Shift key was down at the time of the event.
+ """
return _core_.KeyEvent_ShiftDown(*args, **kwargs)
def CmdDown(*args, **kwargs):
"Cmd" is a pseudo key which is the same as Control for PC and Unix
platforms but the special "Apple" (a.k.a as "Command") key on
- Macs: it makes often sense to use it instead of, say, `ControlDown`
+ Macs. It makes often sense to use it instead of, say, `ControlDown`
because Cmd key is used for the same thing under Mac as Ctrl
elsewhere. The Ctrl still exists, it's just not used for this
purpose. So for non-Mac platforms this is the same as `ControlDown`
return _core_.KeyEvent_CmdDown(*args, **kwargs)
def HasModifiers(*args, **kwargs):
- """HasModifiers(self) -> bool"""
+ """
+ HasModifiers(self) -> bool
+
+ Returns true if either CTRL or ALT keys was down at the time of the
+ key event. Note that this function does not take into account neither
+ SHIFT nor META key states (the reason for ignoring the latter is that
+ it is common for NUMLOCK key to be configured as META under X but the
+ key presses even while NUMLOCK is on should be still processed
+ normally).
+ """
return _core_.KeyEvent_HasModifiers(*args, **kwargs)
def GetKeyCode(*args, **kwargs):
- """GetKeyCode(self) -> int"""
+ """
+ GetKeyCode(self) -> int
+
+ Returns the virtual key code. ASCII events return normal ASCII values,
+ while non-ASCII events return values such as WXK_LEFT for the left
+ cursor key. See `wx.KeyEvent` for a full list of the virtual key
+ codes.
+
+ Note that in Unicode build, the returned value is meaningful only if
+ the user entered a character that can be represented in current
+ locale's default charset. You can obtain the corresponding Unicode
+ character using `GetUnicodeKey`.
+ """
return _core_.KeyEvent_GetKeyCode(*args, **kwargs)
- KeyCode = GetKeyCode
def GetUnicodeKey(*args, **kwargs):
- """GetUnicodeKey(self) -> int"""
+ """
+ GetUnicodeKey(self) -> int
+
+ Returns the Unicode character corresponding to this key event. This
+ function is only meaningfule in a Unicode build of wxPython.
+ """
return _core_.KeyEvent_GetUnicodeKey(*args, **kwargs)
GetUniChar = GetUnicodeKey
+ def SetUnicodeKey(*args, **kwargs):
+ """
+ SetUnicodeKey(self, int uniChar)
+
+ Set the Unicode value of the key event, but only if this is a Unicode
+ build of wxPython.
+ """
+ return _core_.KeyEvent_SetUnicodeKey(*args, **kwargs)
+
def GetRawKeyCode(*args, **kwargs):
- """GetRawKeyCode(self) -> unsigned int"""
+ """
+ GetRawKeyCode(self) -> unsigned int
+
+ Returns the raw key code for this event. This is a platform-dependent
+ scan code which should only be used in advanced
+ applications. Currently the raw key codes are not supported by all
+ ports.
+ """
return _core_.KeyEvent_GetRawKeyCode(*args, **kwargs)
def GetRawKeyFlags(*args, **kwargs):
- """GetRawKeyFlags(self) -> unsigned int"""
+ """
+ GetRawKeyFlags(self) -> unsigned int
+
+ Returns the low level key flags for this event. The flags are
+ platform-dependent and should only be used in advanced applications.
+ Currently the raw key flags are not supported by all ports.
+ """
return _core_.KeyEvent_GetRawKeyFlags(*args, **kwargs)
def GetPosition(*args, **kwargs):
"""
GetPosition(self) -> Point
- Find the position of the event.
+ Find the position of the event, if applicable.
"""
return _core_.KeyEvent_GetPosition(*args, **kwargs)
"""
GetPositionTuple() -> (x,y)
- Find the position of the event.
+ Find the position of the event, if applicable.
"""
return _core_.KeyEvent_GetPositionTuple(*args, **kwargs)
def GetX(*args, **kwargs):
- """GetX(self) -> int"""
+ """
+ GetX(self) -> int
+
+ Returns the X position (in client coordinates) of the event, if
+ applicable.
+ """
return _core_.KeyEvent_GetX(*args, **kwargs)
def GetY(*args, **kwargs):
- """GetY(self) -> int"""
+ """
+ GetY(self) -> int
+
+ Returns the Y position (in client coordinates) of the event, if
+ applicable.
+ """
return _core_.KeyEvent_GetY(*args, **kwargs)
m_x = property(_core_.KeyEvent_m_x_get, _core_.KeyEvent_m_x_set)
m_scanCode = property(_core_.KeyEvent_m_scanCode_get, _core_.KeyEvent_m_scanCode_set)
m_rawCode = property(_core_.KeyEvent_m_rawCode_get, _core_.KeyEvent_m_rawCode_set)
m_rawFlags = property(_core_.KeyEvent_m_rawFlags_get, _core_.KeyEvent_m_rawFlags_set)
-
-class KeyEventPtr(KeyEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = KeyEvent
-_core_.KeyEvent_swigregister(KeyEventPtr)
+ KeyCode = property(GetKeyCode,doc="See `GetKeyCode`")
+ Modifiers = property(GetModifiers,doc="See `GetModifiers`")
+ Position = property(GetPosition,doc="See `GetPosition`")
+ RawKeyCode = property(GetRawKeyCode,doc="See `GetRawKeyCode`")
+ RawKeyFlags = property(GetRawKeyFlags,doc="See `GetRawKeyFlags`")
+ UnicodeKey = property(GetUnicodeKey,SetUnicodeKey,doc="See `GetUnicodeKey` and `SetUnicodeKey`")
+ X = property(GetX,doc="See `GetX`")
+ Y = property(GetY,doc="See `GetY`")
+_core_.KeyEvent_swigregister(KeyEvent)
#---------------------------------------------------------------------------
class SizeEvent(Event):
- """Proxy of C++ SizeEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxSizeEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, Size sz=DefaultSize, int winid=0) -> SizeEvent"""
- newobj = _core_.new_SizeEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ A size event holds information about size change events. The EVT_SIZE
+ handler function will be called when the window it is bound to has
+ been resized.
+
+ Note that the size passed is of the whole window: call
+ `wx.Window.GetClientSize` for the area which may be used by the
+ application.
+
+ When a window is resized, usually only a small part of the window is
+ damaged and and that area is all that is in the update region for the
+ next paint event. However, if your drawing depends on the size of the
+ window, you may need to clear the DC explicitly and repaint the whole
+ window. In which case, you may need to call `wx.Window.Refresh` to
+ invalidate the entire window.
+
+ """
+ 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, Size sz=DefaultSize, int winid=0) -> SizeEvent
+
+ Construct a new ``wx.SizeEvent``.
+ """
+ _core_.SizeEvent_swiginit(self,_core_.new_SizeEvent(*args, **kwargs))
def GetSize(*args, **kwargs):
- """GetSize(self) -> Size"""
+ """
+ GetSize(self) -> Size
+
+ Returns the entire size of the window generating the size change
+ event.
+ """
return _core_.SizeEvent_GetSize(*args, **kwargs)
def GetRect(*args, **kwargs):
m_size = property(_core_.SizeEvent_m_size_get, _core_.SizeEvent_m_size_set)
m_rect = property(_core_.SizeEvent_m_rect_get, _core_.SizeEvent_m_rect_set)
-
-class SizeEventPtr(SizeEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = SizeEvent
-_core_.SizeEvent_swigregister(SizeEventPtr)
+ Rect = property(GetRect,SetRect,doc="See `GetRect` and `SetRect`")
+ Size = property(GetSize,SetSize,doc="See `GetSize` and `SetSize`")
+_core_.SizeEvent_swigregister(SizeEvent)
#---------------------------------------------------------------------------
class MoveEvent(Event):
- """Proxy of C++ MoveEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMoveEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, Point pos=DefaultPosition, int winid=0) -> MoveEvent"""
- newobj = _core_.new_MoveEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ This event object is sent for EVT_MOVE event bindings when a window is
+ moved to a new position.
+ """
+ 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, Point pos=DefaultPosition, int winid=0) -> MoveEvent
+
+ Constructor.
+ """
+ _core_.MoveEvent_swiginit(self,_core_.new_MoveEvent(*args, **kwargs))
def GetPosition(*args, **kwargs):
- """GetPosition(self) -> Point"""
+ """
+ GetPosition(self) -> Point
+
+ Returns the position of the window generating the move change event.
+ """
return _core_.MoveEvent_GetPosition(*args, **kwargs)
def GetRect(*args, **kwargs):
m_pos = property(GetPosition, SetPosition)
m_rect = property(GetRect, SetRect)
-
-class MoveEventPtr(MoveEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = MoveEvent
-_core_.MoveEvent_swigregister(MoveEventPtr)
+ Position = property(GetPosition,SetPosition,doc="See `GetPosition` and `SetPosition`")
+ Rect = property(GetRect,SetRect,doc="See `GetRect` and `SetRect`")
+_core_.MoveEvent_swigregister(MoveEvent)
#---------------------------------------------------------------------------
class PaintEvent(Event):
- """Proxy of C++ PaintEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPaintEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """
+ A paint event is sent when a window's contents needs to be repainted.
+ Note that in an EVT_PAINT handler the application must *always* create
+ a `wx.PaintDC` object, even if you do not use it. Otherwise MS
+ Windows assumes that the window has not been painted yet and will send
+ the event again, causing endless refreshes.
+
+ You can optimize painting by retrieving the rectangles that have been
+ damaged using `wx.Window.GetUpdateRegion` and/or `wx.RegionIterator`,
+ and only repainting these rectangles. The rectangles are in terms of
+ the client area, and are unscrolled, so you will need to do some
+ calculations using the current view position to obtain logical,
+ scrolled units.
+
+ """
+ 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, int Id=0) -> PaintEvent"""
- newobj = _core_.new_PaintEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class PaintEventPtr(PaintEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PaintEvent
-_core_.PaintEvent_swigregister(PaintEventPtr)
+ _core_.PaintEvent_swiginit(self,_core_.new_PaintEvent(*args, **kwargs))
+_core_.PaintEvent_swigregister(PaintEvent)
class NcPaintEvent(Event):
"""Proxy of C++ NcPaintEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxNcPaintEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, int winid=0) -> NcPaintEvent"""
- newobj = _core_.new_NcPaintEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class NcPaintEventPtr(NcPaintEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = NcPaintEvent
-_core_.NcPaintEvent_swigregister(NcPaintEventPtr)
+ _core_.NcPaintEvent_swiginit(self,_core_.new_NcPaintEvent(*args, **kwargs))
+_core_.NcPaintEvent_swigregister(NcPaintEvent)
#---------------------------------------------------------------------------
class EraseEvent(Event):
- """Proxy of C++ EraseEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxEraseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, int Id=0, DC dc=(wxDC *) NULL) -> EraseEvent"""
- newobj = _core_.new_EraseEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ An erase event is sent whenever the background of a window needs to be
+ repainted. To intercept this event use the EVT_ERASE_BACKGROUND event
+ binder. On some platforms, such as GTK+, this event is simulated
+ (simply generated just before the paint event) and may cause flicker.
+
+ To paint a custom background use the `GetDC` method and use the returned
+ device context if it is not ``None``, otherwise create a temporary
+ `wx.ClientDC` and draw on that.
+
+ """
+ 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, int Id=0, DC dc=None) -> EraseEvent
+
+ Constructor
+ """
+ _core_.EraseEvent_swiginit(self,_core_.new_EraseEvent(*args, **kwargs))
def GetDC(*args, **kwargs):
- """GetDC(self) -> DC"""
- return _core_.EraseEvent_GetDC(*args, **kwargs)
+ """
+ GetDC(self) -> DC
+ Returns the device context the event handler should draw upon. If
+ ``None`` is returned then create a temporary `wx.ClientDC` and use
+ that instead.
+ """
+ return _core_.EraseEvent_GetDC(*args, **kwargs)
-class EraseEventPtr(EraseEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = EraseEvent
-_core_.EraseEvent_swigregister(EraseEventPtr)
+ DC = property(GetDC,doc="See `GetDC`")
+_core_.EraseEvent_swigregister(EraseEvent)
#---------------------------------------------------------------------------
class FocusEvent(Event):
- """Proxy of C++ FocusEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxFocusEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, wxEventType type=wxEVT_NULL, int winid=0) -> FocusEvent"""
- newobj = _core_.new_FocusEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ A focus event is sent when a window's focus changes. The window losing
+ focus receives an EVT_KILL_FOCUS event while the window gaining it
+ gets an EVT_SET_FOCUS event.
+
+ Notice that the set focus event happens both when the user gives focus
+ to the window (whether using the mouse or keyboard) and when it is
+ done from the program itself using `wx.Window.SetFocus`.
+
+ """
+ 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, EventType type=wxEVT_NULL, int winid=0) -> FocusEvent
+
+ Constructor
+ """
+ _core_.FocusEvent_swiginit(self,_core_.new_FocusEvent(*args, **kwargs))
def GetWindow(*args, **kwargs):
- """GetWindow(self) -> Window"""
+ """
+ GetWindow(self) -> Window
+
+ Returns the other window associated with this event, that is the
+ window which had the focus before for the EVT_SET_FOCUS event and the
+ window which is going to receive focus for the wxEVT_KILL_FOCUS event.
+
+ Warning: the window returned may be None!
+ """
return _core_.FocusEvent_GetWindow(*args, **kwargs)
def SetWindow(*args, **kwargs):
"""SetWindow(self, Window win)"""
return _core_.FocusEvent_SetWindow(*args, **kwargs)
-
-class FocusEventPtr(FocusEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = FocusEvent
-_core_.FocusEvent_swigregister(FocusEventPtr)
+ Window = property(GetWindow,SetWindow,doc="See `GetWindow` and `SetWindow`")
+_core_.FocusEvent_swigregister(FocusEvent)
#---------------------------------------------------------------------------
class ChildFocusEvent(CommandEvent):
- """Proxy of C++ ChildFocusEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxChildFocusEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, Window win=None) -> ChildFocusEvent"""
- newobj = _core_.new_ChildFocusEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def GetWindow(*args, **kwargs):
- """GetWindow(self) -> Window"""
- return _core_.ChildFocusEvent_GetWindow(*args, **kwargs)
+ """
+ A child focus event is sent to a (parent-)window when one of its child
+ windows gains focus, so that the window could restore the focus back
+ to its corresponding child if it loses it now and regains later.
+
+ Notice that child window is the direct child of the window receiving
+ the event, and so may not be the actual widget recieving focus if it
+ is further down the containment heirarchy. Use `wx.Window.FindFocus`
+ to get the widget that is actually receiving focus.
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, Window win=None) -> ChildFocusEvent
+
+ Constructor
+ """
+ _core_.ChildFocusEvent_swiginit(self,_core_.new_ChildFocusEvent(*args, **kwargs))
+ def GetWindow(*args, **kwargs):
+ """
+ GetWindow(self) -> Window
+ The window, or (grand)parent of the window which has just received the
+ focus.
+ """
+ return _core_.ChildFocusEvent_GetWindow(*args, **kwargs)
-class ChildFocusEventPtr(ChildFocusEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ChildFocusEvent
-_core_.ChildFocusEvent_swigregister(ChildFocusEventPtr)
+ Window = property(GetWindow,doc="See `GetWindow`")
+_core_.ChildFocusEvent_swigregister(ChildFocusEvent)
#---------------------------------------------------------------------------
class ActivateEvent(Event):
- """Proxy of C++ ActivateEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxActivateEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, wxEventType type=wxEVT_NULL, bool active=True, int Id=0) -> ActivateEvent"""
- newobj = _core_.new_ActivateEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ An activate event is sent when a top-level window or the entire
+ application is being activated or deactivated.
+
+ A top-level window (a dialog or frame) receives an activate event when
+ is being activated or deactivated. This is indicated visually by the
+ title bar changing colour, and a subwindow gaining the keyboard focus.
+ An application is activated or deactivated when one of its frames
+ becomes activated, or a frame becomes inactivate resulting in all
+ application frames being inactive.
+
+ Please note that usually you should call event.Skip() in your handlers
+ for these events so the default handlers will still be called, as not
+ doing so can result in strange effects.
+
+ """
+ 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, EventType type=wxEVT_NULL, bool active=True, int Id=0) -> ActivateEvent
+
+ Constructor
+ """
+ _core_.ActivateEvent_swiginit(self,_core_.new_ActivateEvent(*args, **kwargs))
def GetActive(*args, **kwargs):
- """GetActive(self) -> bool"""
- return _core_.ActivateEvent_GetActive(*args, **kwargs)
+ """
+ GetActive(self) -> bool
+ Returns true if the application or window is being activated, false
+ otherwise.
+ """
+ return _core_.ActivateEvent_GetActive(*args, **kwargs)
-class ActivateEventPtr(ActivateEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ActivateEvent
-_core_.ActivateEvent_swigregister(ActivateEventPtr)
+ Active = property(GetActive,doc="See `GetActive`")
+_core_.ActivateEvent_swigregister(ActivateEvent)
#---------------------------------------------------------------------------
class InitDialogEvent(Event):
- """Proxy of C++ InitDialogEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxInitDialogEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, int Id=0) -> InitDialogEvent"""
- newobj = _core_.new_InitDialogEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class InitDialogEventPtr(InitDialogEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = InitDialogEvent
-_core_.InitDialogEvent_swigregister(InitDialogEventPtr)
+ """
+ A wx.InitDialogEvent is sent as a dialog is being initialised, or for
+ any window when `wx.Window.InitDialog` is called. Handlers for this
+ event can transfer data to the window, or anything else that should be
+ done before the user begins editing the form. The default handler
+ calls `wx.Window.TransferDataToWindow`.
+ """
+ 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, int Id=0) -> InitDialogEvent
+
+ Constructor
+ """
+ _core_.InitDialogEvent_swiginit(self,_core_.new_InitDialogEvent(*args, **kwargs))
+_core_.InitDialogEvent_swigregister(InitDialogEvent)
#---------------------------------------------------------------------------
class MenuEvent(Event):
- """Proxy of C++ MenuEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMenuEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, wxEventType type=wxEVT_NULL, int winid=0, Menu menu=None) -> MenuEvent"""
- newobj = _core_.new_MenuEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ This class is used for a variety of menu-related events. Note that
+ these do not include menu command events, which are handled by sending
+ `wx.CommandEvent` objects.
+
+ The default handler for wx.EVT_MENU_HIGHLIGHT displays menu item help
+ text in the first field of the status bar.
+ """
+ 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, EventType type=wxEVT_NULL, int winid=0, Menu menu=None) -> MenuEvent
+
+ Constructor
+ """
+ _core_.MenuEvent_swiginit(self,_core_.new_MenuEvent(*args, **kwargs))
def GetMenuId(*args, **kwargs):
- """GetMenuId(self) -> int"""
+ """
+ GetMenuId(self) -> int
+
+ Returns the menu identifier associated with the event. This method
+ should be only used with the HIGHLIGHT events.
+ """
return _core_.MenuEvent_GetMenuId(*args, **kwargs)
def IsPopup(*args, **kwargs):
- """IsPopup(self) -> bool"""
+ """
+ IsPopup(self) -> bool
+
+ Returns ``True`` if the menu which is being opened or closed is a
+ popup menu, ``False`` if it is a normal one. This method should only
+ be used with the OPEN and CLOSE events.
+ """
return _core_.MenuEvent_IsPopup(*args, **kwargs)
def GetMenu(*args, **kwargs):
- """GetMenu(self) -> Menu"""
- return _core_.MenuEvent_GetMenu(*args, **kwargs)
+ """
+ GetMenu(self) -> Menu
+ Returns the menu which is being opened or closed. This method should
+ only be used with the OPEN and CLOSE events.
+ """
+ return _core_.MenuEvent_GetMenu(*args, **kwargs)
-class MenuEventPtr(MenuEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = MenuEvent
-_core_.MenuEvent_swigregister(MenuEventPtr)
+ Menu = property(GetMenu,doc="See `GetMenu`")
+ MenuId = property(GetMenuId,doc="See `GetMenuId`")
+_core_.MenuEvent_swigregister(MenuEvent)
#---------------------------------------------------------------------------
class CloseEvent(Event):
- """Proxy of C++ CloseEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxCloseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, wxEventType type=wxEVT_NULL, int winid=0) -> CloseEvent"""
- newobj = _core_.new_CloseEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ This event class contains information about window and session close
+ events.
+
+ The handler function for EVT_CLOSE is called when the user has tried
+ to close a a frame or dialog box using the window manager controls or
+ the system menu. It can also be invoked by the application itself
+ programmatically, for example by calling the `wx.Window.Close`
+ function.
+
+ You should check whether the application is forcing the deletion of
+ the window using `CanVeto`. If it returns ``False``, you must destroy
+ the window using `wx.Window.Destroy`. If the return value is ``True``,
+ it is up to you whether you respond by destroying the window or not.
+ For example you may wish to display a message dialog prompting to save
+ files or to cancel the close.
+
+ If you don't destroy the window, you should call `Veto` to let the
+ calling code know that you did not destroy the window. This allows the
+ `wx.Window.Close` function to return ``True`` or ``False`` depending
+ on whether the close instruction was honored or not.
+ """
+ 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, EventType type=wxEVT_NULL, int winid=0) -> CloseEvent
+
+ Constructor.
+ """
+ _core_.CloseEvent_swiginit(self,_core_.new_CloseEvent(*args, **kwargs))
def SetLoggingOff(*args, **kwargs):
- """SetLoggingOff(self, bool logOff)"""
+ """
+ SetLoggingOff(self, bool logOff)
+
+ Sets the 'logging off' flag.
+ """
return _core_.CloseEvent_SetLoggingOff(*args, **kwargs)
def GetLoggingOff(*args, **kwargs):
- """GetLoggingOff(self) -> bool"""
+ """
+ GetLoggingOff(self) -> bool
+
+ Returns ``True`` if the user is logging off or ``False`` if the
+ system is shutting down. This method can only be called for end
+ session and query end session events, it doesn't make sense for close
+ window event.
+ """
return _core_.CloseEvent_GetLoggingOff(*args, **kwargs)
def Veto(*args, **kwargs):
- """Veto(self, bool veto=True)"""
- return _core_.CloseEvent_Veto(*args, **kwargs)
+ """
+ Veto(self, bool veto=True)
- def SetCanVeto(*args, **kwargs):
- """SetCanVeto(self, bool canVeto)"""
- return _core_.CloseEvent_SetCanVeto(*args, **kwargs)
+ Call this from your event handler to veto a system shutdown or to
+ signal to the calling application that a window close did not happen.
- def CanVeto(*args, **kwargs):
- """CanVeto(self) -> bool"""
- return _core_.CloseEvent_CanVeto(*args, **kwargs)
+ You can only veto a shutdown or close if `CanVeto` returns true.
+ """
+ return _core_.CloseEvent_Veto(*args, **kwargs)
def GetVeto(*args, **kwargs):
"""GetVeto(self) -> bool"""
return _core_.CloseEvent_GetVeto(*args, **kwargs)
+ def SetCanVeto(*args, **kwargs):
+ """
+ SetCanVeto(self, bool canVeto)
+
+ Sets the 'can veto' flag.
+ """
+ return _core_.CloseEvent_SetCanVeto(*args, **kwargs)
+
+ def CanVeto(*args, **kwargs):
+ """
+ CanVeto(self) -> bool
+
+ Returns true if you can veto a system shutdown or a window close
+ event. Vetoing a window close event is not possible if the calling
+ code wishes to force the application to exit, and so this function
+ must be called to check this.
+ """
+ return _core_.CloseEvent_CanVeto(*args, **kwargs)
-class CloseEventPtr(CloseEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = CloseEvent
-_core_.CloseEvent_swigregister(CloseEventPtr)
+ LoggingOff = property(GetLoggingOff,SetLoggingOff,doc="See `GetLoggingOff` and `SetLoggingOff`")
+_core_.CloseEvent_swigregister(CloseEvent)
#---------------------------------------------------------------------------
class ShowEvent(Event):
- """Proxy of C++ ShowEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxShowEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, int winid=0, bool show=False) -> ShowEvent"""
- newobj = _core_.new_ShowEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """An EVT_SHOW event is sent when a window is shown or hidden."""
+ 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, int winid=0, bool show=False) -> ShowEvent
+
+ An EVT_SHOW event is sent when a window is shown or hidden.
+ """
+ _core_.ShowEvent_swiginit(self,_core_.new_ShowEvent(*args, **kwargs))
def SetShow(*args, **kwargs):
"""SetShow(self, bool show)"""
return _core_.ShowEvent_SetShow(*args, **kwargs)
"""GetShow(self) -> bool"""
return _core_.ShowEvent_GetShow(*args, **kwargs)
-
-class ShowEventPtr(ShowEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ShowEvent
-_core_.ShowEvent_swigregister(ShowEventPtr)
+ Show = property(GetShow,SetShow,doc="See `GetShow` and `SetShow`")
+_core_.ShowEvent_swigregister(ShowEvent)
#---------------------------------------------------------------------------
class IconizeEvent(Event):
- """Proxy of C++ IconizeEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxIconizeEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, int id=0, bool iconized=True) -> IconizeEvent"""
- newobj = _core_.new_IconizeEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ An EVT_ICONIZE event is sent when a frame is iconized (minimized) or
+ restored.
+ """
+ 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, int id=0, bool iconized=True) -> IconizeEvent
+
+ An EVT_ICONIZE event is sent when a frame is iconized (minimized) or
+ restored.
+ """
+ _core_.IconizeEvent_swiginit(self,_core_.new_IconizeEvent(*args, **kwargs))
def Iconized(*args, **kwargs):
- """Iconized(self) -> bool"""
- return _core_.IconizeEvent_Iconized(*args, **kwargs)
+ """
+ Iconized(self) -> bool
+ Returns ``True`` if the frame has been iconized, ``False`` if it has
+ been restored.
+ """
+ return _core_.IconizeEvent_Iconized(*args, **kwargs)
-class IconizeEventPtr(IconizeEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = IconizeEvent
-_core_.IconizeEvent_swigregister(IconizeEventPtr)
+_core_.IconizeEvent_swigregister(IconizeEvent)
#---------------------------------------------------------------------------
class MaximizeEvent(Event):
- """Proxy of C++ MaximizeEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMaximizeEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, int id=0) -> MaximizeEvent"""
- newobj = _core_.new_MaximizeEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class MaximizeEventPtr(MaximizeEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = MaximizeEvent
-_core_.MaximizeEvent_swigregister(MaximizeEventPtr)
+ """An EVT_MAXIMIZE event is sent when a frame is maximized or restored."""
+ 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, int id=0) -> MaximizeEvent
+
+ An EVT_MAXIMIZE event is sent when a frame is maximized or restored.
+ """
+ _core_.MaximizeEvent_swiginit(self,_core_.new_MaximizeEvent(*args, **kwargs))
+_core_.MaximizeEvent_swigregister(MaximizeEvent)
#---------------------------------------------------------------------------
class DropFilesEvent(Event):
- """Proxy of C++ DropFilesEvent class"""
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxDropFilesEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ """
+ This class is used for drop files events, that is, when files have
+ been dropped onto the window. This functionality is only available
+ under Windows. The window must have previously been enabled for
+ dropping by calling `wx.Window.DragAcceptFiles`.
+
+ Important note: this is a separate implementation to the more general
+ drag and drop implementation using `wx.FileDropTarget`, and etc. This
+ implementation uses the older, Windows message-based approach of
+ dropping files.
+
+ Use wx.EVT_DROP_FILES to bind an event handler to receive file drop
+ events.
+
+ """
+ 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
def GetPosition(*args, **kwargs):
- """GetPosition(self) -> Point"""
+ """
+ GetPosition(self) -> Point
+
+ Returns the position at which the files were dropped.
+ """
return _core_.DropFilesEvent_GetPosition(*args, **kwargs)
def GetNumberOfFiles(*args, **kwargs):
- """GetNumberOfFiles(self) -> int"""
+ """
+ GetNumberOfFiles(self) -> int
+
+ Returns the number of files dropped.
+ """
return _core_.DropFilesEvent_GetNumberOfFiles(*args, **kwargs)
def GetFiles(*args, **kwargs):
- """GetFiles(self) -> PyObject"""
- return _core_.DropFilesEvent_GetFiles(*args, **kwargs)
+ """
+ GetFiles(self) -> PyObject
+ Returns a list of the filenames that were dropped.
+ """
+ return _core_.DropFilesEvent_GetFiles(*args, **kwargs)
-class DropFilesEventPtr(DropFilesEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = DropFilesEvent
-_core_.DropFilesEvent_swigregister(DropFilesEventPtr)
+ Files = property(GetFiles,doc="See `GetFiles`")
+ NumberOfFiles = property(GetNumberOfFiles,doc="See `GetNumberOfFiles`")
+ Position = property(GetPosition,doc="See `GetPosition`")
+_core_.DropFilesEvent_swigregister(DropFilesEvent)
#---------------------------------------------------------------------------
UPDATE_UI_PROCESS_ALL = _core_.UPDATE_UI_PROCESS_ALL
UPDATE_UI_PROCESS_SPECIFIED = _core_.UPDATE_UI_PROCESS_SPECIFIED
class UpdateUIEvent(CommandEvent):
- """Proxy of C++ UpdateUIEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxUpdateUIEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, int commandId=0) -> UpdateUIEvent"""
- newobj = _core_.new_UpdateUIEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ This class is used for EVT_UPDATE_UI pseudo-events which are sent by
+ wxWidgets to give an application the chance to update various user
+ interface elements.
+
+ Without update UI events, an application has to work hard to
+ check/uncheck, enable/disable, and set the text for elements such as
+ menu items and toolbar buttons. The code for doing this has to be
+ mixed up with the code that is invoked when an action is invoked for a
+ menu item or button.
+
+ With update UI events, you define an event handler to look at the
+ state of the application and change UI elements accordingly. wxWidgets
+ will call your handler functions in idle time, so you don't have to
+ worry where to call this code. In addition to being a clearer and more
+ declarative method, it also means you don't have to worry whether
+ you're updating a toolbar or menubar identifier. The same handler can
+ update a menu item and toolbar button, if the ID values are the same.
+
+ Instead of directly manipulating the menu or button, you call
+ functions in the event object, such as `Check`. wxWidgets will
+ determine whether such a call has been made, and which UI element to
+ update.
+
+ These events will work for popup menus as well as menubars. Just
+ before a menu is popped up, `wx.Menu.UpdateUI` is called to process
+ any UI events for the window that owns the menu.
+
+ If you find that the overhead of UI update processing is affecting
+ your application, you can do one or both of the following:
+
+ 1. Call `wx.UpdateUIEvent.SetMode` with a value of
+ wx.UPDATE_UI_PROCESS_SPECIFIED, and set the extra style
+ wx.WS_EX_PROCESS_UPDATE_EVENTS for every window that should
+ receive update events. No other windows will receive update
+ events.
+
+ 2. Call `wx.UpdateUIEvent.SetUpdateInterval` with a millisecond
+ value to set the delay between updates. You may need to call
+ `wx.Window.UpdateWindowUI` at critical points, for example when
+ a dialog is about to be shown, in case the user sees a slight
+ delay before windows are updated.
+
+ Note that although events are sent in idle time, defining a EVT_IDLE
+ handler for a window does not affect this because the events are sent
+ from an internal idle handler.
+
+ wxWidgets tries to optimize update events on some platforms. On
+ Windows and GTK+, events for menubar items are only sent when the menu
+ is about to be shown, and not in idle time.
+
+ """
+ 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, int commandId=0) -> UpdateUIEvent
+
+ Constructor
+ """
+ _core_.UpdateUIEvent_swiginit(self,_core_.new_UpdateUIEvent(*args, **kwargs))
def GetChecked(*args, **kwargs):
- """GetChecked(self) -> bool"""
+ """
+ GetChecked(self) -> bool
+
+ Returns ``True`` if the UI element should be checked.
+ """
return _core_.UpdateUIEvent_GetChecked(*args, **kwargs)
def GetEnabled(*args, **kwargs):
- """GetEnabled(self) -> bool"""
+ """
+ GetEnabled(self) -> bool
+
+ Returns ``True`` if the UI element should be enabled.
+ """
return _core_.UpdateUIEvent_GetEnabled(*args, **kwargs)
+ def GetShown(*args, **kwargs):
+ """
+ GetShown(self) -> bool
+
+ Returns ``True`` if the UI element should be shown.
+ """
+ return _core_.UpdateUIEvent_GetShown(*args, **kwargs)
+
def GetText(*args, **kwargs):
- """GetText(self) -> String"""
+ """
+ GetText(self) -> String
+
+ Returns the text that should be set for the UI element.
+ """
return _core_.UpdateUIEvent_GetText(*args, **kwargs)
def GetSetText(*args, **kwargs):
- """GetSetText(self) -> bool"""
+ """
+ GetSetText(self) -> bool
+
+ Returns ``True`` if the application has called `SetText`. For
+ wxWidgets internal use only.
+ """
return _core_.UpdateUIEvent_GetSetText(*args, **kwargs)
def GetSetChecked(*args, **kwargs):
- """GetSetChecked(self) -> bool"""
+ """
+ GetSetChecked(self) -> bool
+
+ Returns ``True`` if the application has called `Check`. For wxWidgets
+ internal use only.
+ """
return _core_.UpdateUIEvent_GetSetChecked(*args, **kwargs)
def GetSetEnabled(*args, **kwargs):
- """GetSetEnabled(self) -> bool"""
+ """
+ GetSetEnabled(self) -> bool
+
+ Returns ``True`` if the application has called `Enable`. For wxWidgets
+ internal use only.
+ """
return _core_.UpdateUIEvent_GetSetEnabled(*args, **kwargs)
+ def GetSetShown(*args, **kwargs):
+ """
+ GetSetShown(self) -> bool
+
+ Returns ``True`` if the application has called `Show`. For wxWidgets
+ internal use only.
+ """
+ return _core_.UpdateUIEvent_GetSetShown(*args, **kwargs)
+
def Check(*args, **kwargs):
- """Check(self, bool check)"""
+ """
+ Check(self, bool check)
+
+ Check or uncheck the UI element.
+ """
return _core_.UpdateUIEvent_Check(*args, **kwargs)
def Enable(*args, **kwargs):
- """Enable(self, bool enable)"""
+ """
+ Enable(self, bool enable)
+
+ Enable or disable the UI element.
+ """
return _core_.UpdateUIEvent_Enable(*args, **kwargs)
+ def Show(*args, **kwargs):
+ """
+ Show(self, bool show)
+
+ Show or hide the UI element.
+ """
+ return _core_.UpdateUIEvent_Show(*args, **kwargs)
+
def SetText(*args, **kwargs):
- """SetText(self, String text)"""
+ """
+ SetText(self, String text)
+
+ Sets the text for this UI element.
+ """
return _core_.UpdateUIEvent_SetText(*args, **kwargs)
def SetUpdateInterval(*args, **kwargs):
- """SetUpdateInterval(long updateInterval)"""
+ """
+ SetUpdateInterval(long updateInterval)
+
+ Sets the interval between updates in milliseconds. Set to -1 to
+ disable updates, or to 0 to update as frequently as possible. The
+ default is 0.
+
+ Use this to reduce the overhead of UI update events if your
+ application has a lot of windows. If you set the value to -1 or
+ greater than 0, you may also need to call `wx.Window.UpdateWindowUI`
+ at appropriate points in your application, such as when a dialog is
+ about to be shown.
+ """
return _core_.UpdateUIEvent_SetUpdateInterval(*args, **kwargs)
SetUpdateInterval = staticmethod(SetUpdateInterval)
def GetUpdateInterval(*args, **kwargs):
- """GetUpdateInterval() -> long"""
+ """
+ GetUpdateInterval() -> long
+
+ Returns the current interval between updates in milliseconds. -1
+ disables updates, 0 updates as frequently as possible.
+ """
return _core_.UpdateUIEvent_GetUpdateInterval(*args, **kwargs)
GetUpdateInterval = staticmethod(GetUpdateInterval)
def CanUpdate(*args, **kwargs):
- """CanUpdate(Window win) -> bool"""
+ """
+ CanUpdate(Window win) -> bool
+
+ Returns ``True`` if it is appropriate to update (send UI update events
+ to) this window.
+
+ This function looks at the mode used (see `wx.UpdateUIEvent.SetMode`),
+ the wx.WS_EX_PROCESS_UPDATE_EVENTS flag in window, the time update
+ events were last sent in idle time, and the update interval, to
+ determine whether events should be sent to this window now. By default
+ this will always return true because the update mode is initially
+ wx.UPDATE_UI_PROCESS_ALL and the interval is set to 0; so update
+ events will be sent as often as possible. You can reduce the frequency
+ that events are sent by changing the mode and/or setting an update
+ interval.
+
+ """
return _core_.UpdateUIEvent_CanUpdate(*args, **kwargs)
CanUpdate = staticmethod(CanUpdate)
def ResetUpdateTime(*args, **kwargs):
- """ResetUpdateTime()"""
+ """
+ ResetUpdateTime()
+
+ Used internally to reset the last-updated time to the current time. It
+ is assumed that update events are normally sent in idle time, so this
+ is called at the end of idle processing.
+ """
return _core_.UpdateUIEvent_ResetUpdateTime(*args, **kwargs)
ResetUpdateTime = staticmethod(ResetUpdateTime)
def SetMode(*args, **kwargs):
- """SetMode(int mode)"""
+ """
+ SetMode(int mode)
+
+ Specify how wxWidgets will send update events: to all windows, or only
+ to those which specify that they will process the events.
+
+ The mode may be one of the following values:
+
+ ============================= ==========================================
+ wxUPDATE_UI_PROCESS_ALL Send UI update events to all windows. This
+ is the default setting.
+ wxUPDATE_UI_PROCESS_SPECIFIED Send UI update events only to windows that
+ have the wx.WS_EX_PROCESS_UI_UPDATES extra
+ style set.
+ ============================= ==========================================
+
+ """
return _core_.UpdateUIEvent_SetMode(*args, **kwargs)
SetMode = staticmethod(SetMode)
def GetMode(*args, **kwargs):
- """GetMode() -> int"""
+ """
+ GetMode() -> int
+
+ Returns a value specifying how wxWidgets will send update events: to
+ all windows, or only to those which specify that they will process the
+ events.
+ """
return _core_.UpdateUIEvent_GetMode(*args, **kwargs)
GetMode = staticmethod(GetMode)
-
-class UpdateUIEventPtr(UpdateUIEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = UpdateUIEvent
-_core_.UpdateUIEvent_swigregister(UpdateUIEventPtr)
+ Checked = property(GetChecked,Check,doc="See `GetChecked`")
+ Enabled = property(GetEnabled,Enable,doc="See `GetEnabled`")
+ Shown = property(GetShown,Show,doc="See `GetShown`")
+ Text = property(GetText,SetText,doc="See `GetText` and `SetText`")
+_core_.UpdateUIEvent_swigregister(UpdateUIEvent)
def UpdateUIEvent_SetUpdateInterval(*args, **kwargs):
- """UpdateUIEvent_SetUpdateInterval(long updateInterval)"""
- return _core_.UpdateUIEvent_SetUpdateInterval(*args, **kwargs)
+ """
+ UpdateUIEvent_SetUpdateInterval(long updateInterval)
-def UpdateUIEvent_GetUpdateInterval(*args, **kwargs):
- """UpdateUIEvent_GetUpdateInterval() -> long"""
- return _core_.UpdateUIEvent_GetUpdateInterval(*args, **kwargs)
+ Sets the interval between updates in milliseconds. Set to -1 to
+ disable updates, or to 0 to update as frequently as possible. The
+ default is 0.
+
+ Use this to reduce the overhead of UI update events if your
+ application has a lot of windows. If you set the value to -1 or
+ greater than 0, you may also need to call `wx.Window.UpdateWindowUI`
+ at appropriate points in your application, such as when a dialog is
+ about to be shown.
+ """
+ return _core_.UpdateUIEvent_SetUpdateInterval(*args, **kwargs)
+
+def UpdateUIEvent_GetUpdateInterval(*args):
+ """
+ UpdateUIEvent_GetUpdateInterval() -> long
+
+ Returns the current interval between updates in milliseconds. -1
+ disables updates, 0 updates as frequently as possible.
+ """
+ return _core_.UpdateUIEvent_GetUpdateInterval(*args)
def UpdateUIEvent_CanUpdate(*args, **kwargs):
- """UpdateUIEvent_CanUpdate(Window win) -> bool"""
- return _core_.UpdateUIEvent_CanUpdate(*args, **kwargs)
+ """
+ UpdateUIEvent_CanUpdate(Window win) -> bool
+
+ Returns ``True`` if it is appropriate to update (send UI update events
+ to) this window.
-def UpdateUIEvent_ResetUpdateTime(*args, **kwargs):
- """UpdateUIEvent_ResetUpdateTime()"""
- return _core_.UpdateUIEvent_ResetUpdateTime(*args, **kwargs)
+ This function looks at the mode used (see `wx.UpdateUIEvent.SetMode`),
+ the wx.WS_EX_PROCESS_UPDATE_EVENTS flag in window, the time update
+ events were last sent in idle time, and the update interval, to
+ determine whether events should be sent to this window now. By default
+ this will always return true because the update mode is initially
+ wx.UPDATE_UI_PROCESS_ALL and the interval is set to 0; so update
+ events will be sent as often as possible. You can reduce the frequency
+ that events are sent by changing the mode and/or setting an update
+ interval.
+
+ """
+ return _core_.UpdateUIEvent_CanUpdate(*args, **kwargs)
+
+def UpdateUIEvent_ResetUpdateTime(*args):
+ """
+ UpdateUIEvent_ResetUpdateTime()
+
+ Used internally to reset the last-updated time to the current time. It
+ is assumed that update events are normally sent in idle time, so this
+ is called at the end of idle processing.
+ """
+ return _core_.UpdateUIEvent_ResetUpdateTime(*args)
def UpdateUIEvent_SetMode(*args, **kwargs):
- """UpdateUIEvent_SetMode(int mode)"""
- return _core_.UpdateUIEvent_SetMode(*args, **kwargs)
+ """
+ UpdateUIEvent_SetMode(int mode)
+
+ Specify how wxWidgets will send update events: to all windows, or only
+ to those which specify that they will process the events.
+
+ The mode may be one of the following values:
-def UpdateUIEvent_GetMode(*args, **kwargs):
- """UpdateUIEvent_GetMode() -> int"""
- return _core_.UpdateUIEvent_GetMode(*args, **kwargs)
+ ============================= ==========================================
+ wxUPDATE_UI_PROCESS_ALL Send UI update events to all windows. This
+ is the default setting.
+ wxUPDATE_UI_PROCESS_SPECIFIED Send UI update events only to windows that
+ have the wx.WS_EX_PROCESS_UI_UPDATES extra
+ style set.
+ ============================= ==========================================
+
+ """
+ return _core_.UpdateUIEvent_SetMode(*args, **kwargs)
+
+def UpdateUIEvent_GetMode(*args):
+ """
+ UpdateUIEvent_GetMode() -> int
+
+ Returns a value specifying how wxWidgets will send update events: to
+ all windows, or only to those which specify that they will process the
+ events.
+ """
+ return _core_.UpdateUIEvent_GetMode(*args)
#---------------------------------------------------------------------------
class SysColourChangedEvent(Event):
- """Proxy of C++ SysColourChangedEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxSysColourChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self) -> SysColourChangedEvent"""
- newobj = _core_.new_SysColourChangedEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class SysColourChangedEventPtr(SysColourChangedEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = SysColourChangedEvent
-_core_.SysColourChangedEvent_swigregister(SysColourChangedEventPtr)
+ """
+ This class is used for EVT_SYS_COLOUR_CHANGED, which are generated
+ when the user changes the colour settings using the control
+ panel. This is only applicable under Windows.
+
+ The default event handler for this event propagates the event to child
+ windows, since Windows only sends the events to top-level windows. If
+ intercepting this event for a top-level window, remember to call
+ `Skip` so the the base class handler will still be executed, or to
+ pass the event on to the window's children explicitly.
+
+ """
+ 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) -> SysColourChangedEvent
+
+ Constructor
+ """
+ _core_.SysColourChangedEvent_swiginit(self,_core_.new_SysColourChangedEvent(*args, **kwargs))
+_core_.SysColourChangedEvent_swigregister(SysColourChangedEvent)
#---------------------------------------------------------------------------
class MouseCaptureChangedEvent(Event):
- """Proxy of C++ MouseCaptureChangedEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMouseCaptureChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, int winid=0, Window gainedCapture=None) -> MouseCaptureChangedEvent"""
- newobj = _core_.new_MouseCaptureChangedEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ An mouse capture changed event (EVT_MOUSE_CAPTURE_CHANGED) is sent to
+ a window that loses its mouse capture. This is called even if
+ `wx.Window.ReleaseMouse` was called by the application code. Handling
+ this event allows an application to cater for unexpected capture
+ releases which might otherwise confuse mouse handling code.
+
+ This event is implemented under Windows only.
+ """
+ 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, int winid=0, Window gainedCapture=None) -> MouseCaptureChangedEvent
+
+ Constructor
+ """
+ _core_.MouseCaptureChangedEvent_swiginit(self,_core_.new_MouseCaptureChangedEvent(*args, **kwargs))
def GetCapturedWindow(*args, **kwargs):
- """GetCapturedWindow(self) -> Window"""
+ """
+ GetCapturedWindow(self) -> Window
+
+ Returns the window that gained the capture, or ``None`` if it was a
+ non-wxWidgets window.
+ """
return _core_.MouseCaptureChangedEvent_GetCapturedWindow(*args, **kwargs)
+ CapturedWindow = property(GetCapturedWindow,doc="See `GetCapturedWindow`")
+_core_.MouseCaptureChangedEvent_swigregister(MouseCaptureChangedEvent)
+
+#---------------------------------------------------------------------------
+
+class MouseCaptureLostEvent(Event):
+ """
+ A mouse capture lost event is sent to a window that obtained mouse
+ capture, which was subsequently loss due to "external" event, for
+ example when a dialog box is shown or if another application captures
+ the mouse.
+
+ If this happens, this event is sent to all windows that are on the
+ capture stack (i.e. a window that called `wx.Window.CaptureMouse`, but
+ didn't call `wx.Window.ReleaseMouse` yet). The event is *not* sent
+ if the capture changes because of a call to CaptureMouse or
+ ReleaseMouse.
+
+ This event is currently emitted under Windows only.
+
+ """
+ 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, int winid=0) -> MouseCaptureLostEvent
+
+ A mouse capture lost event is sent to a window that obtained mouse
+ capture, which was subsequently loss due to "external" event, for
+ example when a dialog box is shown or if another application captures
+ the mouse.
+
+ If this happens, this event is sent to all windows that are on the
+ capture stack (i.e. a window that called `wx.Window.CaptureMouse`, but
+ didn't call `wx.Window.ReleaseMouse` yet). The event is *not* sent
+ if the capture changes because of a call to CaptureMouse or
+ ReleaseMouse.
-class MouseCaptureChangedEventPtr(MouseCaptureChangedEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = MouseCaptureChangedEvent
-_core_.MouseCaptureChangedEvent_swigregister(MouseCaptureChangedEventPtr)
+ This event is currently emitted under Windows only.
+
+ """
+ _core_.MouseCaptureLostEvent_swiginit(self,_core_.new_MouseCaptureLostEvent(*args, **kwargs))
+_core_.MouseCaptureLostEvent_swigregister(MouseCaptureLostEvent)
#---------------------------------------------------------------------------
class DisplayChangedEvent(Event):
- """Proxy of C++ DisplayChangedEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxDisplayChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """
+ An EVT_DISPLAY_CHANGED event is sent to all windows when the display
+ resolution has changed.
+
+ This event is implemented under Windows only.
+ """
+ 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) -> DisplayChangedEvent"""
- newobj = _core_.new_DisplayChangedEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
-
-class DisplayChangedEventPtr(DisplayChangedEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = DisplayChangedEvent
-_core_.DisplayChangedEvent_swigregister(DisplayChangedEventPtr)
+ _core_.DisplayChangedEvent_swiginit(self,_core_.new_DisplayChangedEvent(*args, **kwargs))
+_core_.DisplayChangedEvent_swigregister(DisplayChangedEvent)
#---------------------------------------------------------------------------
class PaletteChangedEvent(Event):
- """Proxy of C++ PaletteChangedEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPaletteChangedEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, int id=0) -> PaletteChangedEvent"""
- newobj = _core_.new_PaletteChangedEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ An EVT_PALETTE_CHANGED event is sent when the system palette has
+ changed, thereby giving each window a chance to redo their own to
+ match.
+
+ This event is implemented under Windows only.
+ """
+ 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, int id=0) -> PaletteChangedEvent
+
+ An EVT_PALETTE_CHANGED event is sent when the system palette has
+ changed, thereby giving each window a chance to redo their own to
+ match.
+
+ This event is implemented under Windows only.
+ """
+ _core_.PaletteChangedEvent_swiginit(self,_core_.new_PaletteChangedEvent(*args, **kwargs))
def SetChangedWindow(*args, **kwargs):
"""SetChangedWindow(self, Window win)"""
return _core_.PaletteChangedEvent_SetChangedWindow(*args, **kwargs)
"""GetChangedWindow(self) -> Window"""
return _core_.PaletteChangedEvent_GetChangedWindow(*args, **kwargs)
-
-class PaletteChangedEventPtr(PaletteChangedEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PaletteChangedEvent
-_core_.PaletteChangedEvent_swigregister(PaletteChangedEventPtr)
+ ChangedWindow = property(GetChangedWindow,SetChangedWindow,doc="See `GetChangedWindow` and `SetChangedWindow`")
+_core_.PaletteChangedEvent_swigregister(PaletteChangedEvent)
#---------------------------------------------------------------------------
class QueryNewPaletteEvent(Event):
- """Proxy of C++ QueryNewPaletteEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxQueryNewPaletteEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, int winid=0) -> QueryNewPaletteEvent"""
- newobj = _core_.new_QueryNewPaletteEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ An EVT_QUERY_NEW_PALETE event indicates the window is getting keyboard
+ focus and should re-do its palette.
+
+ This event is implemented under Windows only.
+ """
+ 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, int winid=0) -> QueryNewPaletteEvent
+
+ Constructor.
+ """
+ _core_.QueryNewPaletteEvent_swiginit(self,_core_.new_QueryNewPaletteEvent(*args, **kwargs))
def SetPaletteRealized(*args, **kwargs):
- """SetPaletteRealized(self, bool realized)"""
+ """
+ SetPaletteRealized(self, bool realized)
+
+ App should set this if it changes the palette.
+ """
return _core_.QueryNewPaletteEvent_SetPaletteRealized(*args, **kwargs)
def GetPaletteRealized(*args, **kwargs):
"""GetPaletteRealized(self) -> bool"""
return _core_.QueryNewPaletteEvent_GetPaletteRealized(*args, **kwargs)
-
-class QueryNewPaletteEventPtr(QueryNewPaletteEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = QueryNewPaletteEvent
-_core_.QueryNewPaletteEvent_swigregister(QueryNewPaletteEventPtr)
+ PaletteRealized = property(GetPaletteRealized,SetPaletteRealized,doc="See `GetPaletteRealized` and `SetPaletteRealized`")
+_core_.QueryNewPaletteEvent_swigregister(QueryNewPaletteEvent)
#---------------------------------------------------------------------------
class NavigationKeyEvent(Event):
- """Proxy of C++ NavigationKeyEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxNavigationKeyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ """
+ EVT_NAVIGATION_KEY events are used to control moving the focus between
+ widgets, otherwise known as tab-traversal. You woudl normally not
+ catch navigation events in applications as there are already
+ appropriate handlers in `wx.Dialog` and `wx.Panel`, but you may find
+ it useful to send navigation events in certain situations to change
+ the focus in certain ways, although it's probably easier to just call
+ `wx.Window.Navigate`.
+ """
+ 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) -> NavigationKeyEvent"""
- newobj = _core_.new_NavigationKeyEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.NavigationKeyEvent_swiginit(self,_core_.new_NavigationKeyEvent(*args, **kwargs))
def GetDirection(*args, **kwargs):
- """GetDirection(self) -> bool"""
+ """
+ GetDirection(self) -> bool
+
+ Returns ``True`` if the direction is forward, ``False`` otherwise.
+ """
return _core_.NavigationKeyEvent_GetDirection(*args, **kwargs)
def SetDirection(*args, **kwargs):
- """SetDirection(self, bool forward)"""
+ """
+ SetDirection(self, bool forward)
+
+ Specify the direction that the navigation should take. Usually the
+ difference between using Tab and Shift-Tab.
+ """
return _core_.NavigationKeyEvent_SetDirection(*args, **kwargs)
def IsWindowChange(*args, **kwargs):
- """IsWindowChange(self) -> bool"""
+ """
+ IsWindowChange(self) -> bool
+
+ Returns ``True`` if window change is allowed.
+ """
return _core_.NavigationKeyEvent_IsWindowChange(*args, **kwargs)
def SetWindowChange(*args, **kwargs):
- """SetWindowChange(self, bool ischange)"""
+ """
+ SetWindowChange(self, bool ischange)
+
+ Specify if the navigation should be able to change parent windows.
+ For example, changing notebook pages, etc. This is usually implemented
+ by using Control-Tab.
+ """
return _core_.NavigationKeyEvent_SetWindowChange(*args, **kwargs)
def IsFromTab(*args, **kwargs):
- """IsFromTab(self) -> bool"""
+ """
+ IsFromTab(self) -> bool
+
+ Returns ``True`` if the navigation event is originated from the Tab
+ key.
+ """
return _core_.NavigationKeyEvent_IsFromTab(*args, **kwargs)
def SetFromTab(*args, **kwargs):
- """SetFromTab(self, bool bIs)"""
+ """
+ SetFromTab(self, bool bIs)
+
+ Set to true under MSW if the event was generated using the tab key.
+ This is required for proper navogation over radio buttons.
+ """
return _core_.NavigationKeyEvent_SetFromTab(*args, **kwargs)
def SetFlags(*args, **kwargs):
- """SetFlags(self, long flags)"""
+ """
+ SetFlags(self, long flags)
+
+ Set the navigation flags to a combination of the following:
+
+ * wx.NavigationKeyEvent.IsBackward
+ * wx.NavigationKeyEvent.IsForward
+ * wx.NavigationKeyEvent.WinChange
+ * wx.NavigationKeyEvent.FromTab
+
+ """
return _core_.NavigationKeyEvent_SetFlags(*args, **kwargs)
def GetCurrentFocus(*args, **kwargs):
- """GetCurrentFocus(self) -> Window"""
+ """
+ GetCurrentFocus(self) -> Window
+
+ Returns the child window which currenty has the focus. May be
+ ``None``.
+ """
return _core_.NavigationKeyEvent_GetCurrentFocus(*args, **kwargs)
def SetCurrentFocus(*args, **kwargs):
- """SetCurrentFocus(self, Window win)"""
+ """
+ SetCurrentFocus(self, Window win)
+
+ Set the window that has the focus.
+ """
return _core_.NavigationKeyEvent_SetCurrentFocus(*args, **kwargs)
IsBackward = _core_.NavigationKeyEvent_IsBackward
IsForward = _core_.NavigationKeyEvent_IsForward
WinChange = _core_.NavigationKeyEvent_WinChange
FromTab = _core_.NavigationKeyEvent_FromTab
-
-class NavigationKeyEventPtr(NavigationKeyEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = NavigationKeyEvent
-_core_.NavigationKeyEvent_swigregister(NavigationKeyEventPtr)
+ CurrentFocus = property(GetCurrentFocus,SetCurrentFocus,doc="See `GetCurrentFocus` and `SetCurrentFocus`")
+ Direction = property(GetDirection,SetDirection,doc="See `GetDirection` and `SetDirection`")
+_core_.NavigationKeyEvent_swigregister(NavigationKeyEvent)
#---------------------------------------------------------------------------
class WindowCreateEvent(CommandEvent):
- """Proxy of C++ WindowCreateEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxWindowCreateEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, Window win=None) -> WindowCreateEvent"""
- newobj = _core_.new_WindowCreateEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ The EVT_WINDOW_CREATE event is sent as soon as the window object (the
+ underlying GUI object) exists.
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, Window win=None) -> WindowCreateEvent
+
+ The EVT_WINDOW_CREATE event is sent as soon as the window object (the
+ underlying GUI object) exists.
+ """
+ _core_.WindowCreateEvent_swiginit(self,_core_.new_WindowCreateEvent(*args, **kwargs))
def GetWindow(*args, **kwargs):
- """GetWindow(self) -> Window"""
- return _core_.WindowCreateEvent_GetWindow(*args, **kwargs)
+ """
+ GetWindow(self) -> Window
+ Returns the window that this event refers to.
+ """
+ return _core_.WindowCreateEvent_GetWindow(*args, **kwargs)
-class WindowCreateEventPtr(WindowCreateEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = WindowCreateEvent
-_core_.WindowCreateEvent_swigregister(WindowCreateEventPtr)
+ Window = property(GetWindow,doc="See `GetWindow`")
+_core_.WindowCreateEvent_swigregister(WindowCreateEvent)
class WindowDestroyEvent(CommandEvent):
- """Proxy of C++ WindowDestroyEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxWindowDestroyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, Window win=None) -> WindowDestroyEvent"""
- newobj = _core_.new_WindowDestroyEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ The EVT_WINDOW_DESTROY event is sent from the `wx.Window` destructor
+ when the GUI window is destroyed.
+
+ When a class derived from `wx.Window` is destroyed its destructor will
+ have already run by the time this event is sent. Therefore this event
+ will not usually be received at all by the window itself. Since it is
+ received after the destructor has run, an object should not try to
+ handle its own wx.WindowDestroyEvent, but it can be used to get
+ notification of the destruction of another window.
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """
+ __init__(self, Window win=None) -> WindowDestroyEvent
+
+ The EVT_WINDOW_DESTROY event is sent from the `wx.Window` destructor
+ when the GUI window is destroyed.
+
+ When a class derived from `wx.Window` is destroyed its destructor will
+ have already run by the time this event is sent. Therefore this event
+ will not usually be received at all by the window itself. Since it is
+ received after the destructor has run, an object should not try to
+ handle its own wx.WindowDestroyEvent, but it can be used to get
+ notification of the destruction of another window.
+ """
+ _core_.WindowDestroyEvent_swiginit(self,_core_.new_WindowDestroyEvent(*args, **kwargs))
def GetWindow(*args, **kwargs):
- """GetWindow(self) -> Window"""
- return _core_.WindowDestroyEvent_GetWindow(*args, **kwargs)
+ """
+ GetWindow(self) -> Window
+ Returns the window that this event refers to.
+ """
+ return _core_.WindowDestroyEvent_GetWindow(*args, **kwargs)
-class WindowDestroyEventPtr(WindowDestroyEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = WindowDestroyEvent
-_core_.WindowDestroyEvent_swigregister(WindowDestroyEventPtr)
+ Window = property(GetWindow,doc="See `GetWindow`")
+_core_.WindowDestroyEvent_swigregister(WindowDestroyEvent)
#---------------------------------------------------------------------------
class ContextMenuEvent(CommandEvent):
- """Proxy of C++ ContextMenuEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxContextMenuEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, wxEventType type=wxEVT_NULL, int winid=0, Point pt=DefaultPosition) -> ContextMenuEvent"""
- newobj = _core_.new_ContextMenuEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ This class is used for context menu events (EVT_CONTECT_MENU,) sent to
+ give the application a chance to show a context (popup) menu.
+ """
+ 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, EventType type=wxEVT_NULL, int winid=0, Point pt=DefaultPosition) -> ContextMenuEvent
+
+ Constructor.
+ """
+ _core_.ContextMenuEvent_swiginit(self,_core_.new_ContextMenuEvent(*args, **kwargs))
def GetPosition(*args, **kwargs):
- """GetPosition(self) -> Point"""
+ """
+ GetPosition(self) -> Point
+
+ Returns the position (in screen coordinants) at which the menu should
+ be shown.
+ """
return _core_.ContextMenuEvent_GetPosition(*args, **kwargs)
def SetPosition(*args, **kwargs):
- """SetPosition(self, Point pos)"""
- return _core_.ContextMenuEvent_SetPosition(*args, **kwargs)
+ """
+ SetPosition(self, Point pos)
+ Sets the position at which the menu should be shown.
+ """
+ return _core_.ContextMenuEvent_SetPosition(*args, **kwargs)
-class ContextMenuEventPtr(ContextMenuEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ContextMenuEvent
-_core_.ContextMenuEvent_swigregister(ContextMenuEventPtr)
+ Position = property(GetPosition,SetPosition,doc="See `GetPosition` and `SetPosition`")
+_core_.ContextMenuEvent_swigregister(ContextMenuEvent)
#---------------------------------------------------------------------------
IDLE_PROCESS_ALL = _core_.IDLE_PROCESS_ALL
IDLE_PROCESS_SPECIFIED = _core_.IDLE_PROCESS_SPECIFIED
class IdleEvent(Event):
- """Proxy of C++ IdleEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxIdleEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self) -> IdleEvent"""
- newobj = _core_.new_IdleEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ This class is used for EVT_IDLE events, which are generated and sent
+ when the application *becomes* idle. In other words, the when the
+ event queue becomes empty then idle events are sent to all windows (by
+ default) and as long as none of them call `RequestMore` then there are
+ no more idle events until after the system event queue has some normal
+ events and then becomes empty again.
+
+ By default, idle events are sent to all windows. If this is causing a
+ significant overhead in your application, you can call
+ `wx.IdleEvent.SetMode` with the value wx.IDLE_PROCESS_SPECIFIED, and
+ set the wx.WS_EX_PROCESS_IDLE extra window style for every window
+ which should receive idle events. Then idle events will only be sent
+ to those windows and not to any others.
+ """
+ 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) -> IdleEvent
+
+ Constructor
+ """
+ _core_.IdleEvent_swiginit(self,_core_.new_IdleEvent(*args, **kwargs))
def RequestMore(*args, **kwargs):
- """RequestMore(self, bool needMore=True)"""
+ """
+ RequestMore(self, bool needMore=True)
+
+ Tells wxWidgets that more processing is required. This function can be
+ called by an EVT_IDLE handler for a window to indicate that the
+ application should forward the EVT_IDLE event once more to the
+ application windows. If no window calls this function during its
+ EVT_IDLE handler, then the application will remain in a passive event
+ loop until a new event is posted to the application by the windowing
+ system.
+ """
return _core_.IdleEvent_RequestMore(*args, **kwargs)
def MoreRequested(*args, **kwargs):
- """MoreRequested(self) -> bool"""
+ """
+ MoreRequested(self) -> bool
+
+ Returns ``True`` if the OnIdle function processing this event
+ requested more processing time.
+ """
return _core_.IdleEvent_MoreRequested(*args, **kwargs)
def SetMode(*args, **kwargs):
- """SetMode(int mode)"""
+ """
+ SetMode(int mode)
+
+ Static method for specifying how wxWidgets will send idle events: to
+ all windows, or only to those which specify that they will process the
+ events.
+
+ The mode can be one of the following values:
+
+ ========================= ========================================
+ wx.IDLE_PROCESS_ALL Send idle events to all windows
+ wx.IDLE_PROCESS_SPECIFIED Send idle events only to windows that have
+ the wx.WS_EX_PROCESS_IDLE extra style
+ flag set.
+ ========================= ========================================
+
+ """
return _core_.IdleEvent_SetMode(*args, **kwargs)
SetMode = staticmethod(SetMode)
def GetMode(*args, **kwargs):
- """GetMode() -> int"""
+ """
+ GetMode() -> int
+
+ Static method returning a value specifying how wxWidgets will send
+ idle events: to all windows, or only to those which specify that they
+ will process the events.
+ """
return _core_.IdleEvent_GetMode(*args, **kwargs)
GetMode = staticmethod(GetMode)
def CanSend(*args, **kwargs):
- """CanSend(Window win) -> bool"""
+ """
+ CanSend(Window win) -> bool
+
+ Returns ``True`` if it is appropriate to send idle events to this
+ window.
+
+ This function looks at the mode used (see `wx.IdleEvent.SetMode`), and
+ the wx.WS_EX_PROCESS_IDLE style in window to determine whether idle
+ events should be sent to this window now. By default this will always
+ return ``True`` because the update mode is initially
+ wx.IDLE_PROCESS_ALL. You can change the mode to only send idle events
+ to windows with the wx.WS_EX_PROCESS_IDLE extra window style set.
+ """
return _core_.IdleEvent_CanSend(*args, **kwargs)
CanSend = staticmethod(CanSend)
-
-class IdleEventPtr(IdleEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = IdleEvent
-_core_.IdleEvent_swigregister(IdleEventPtr)
+_core_.IdleEvent_swigregister(IdleEvent)
def IdleEvent_SetMode(*args, **kwargs):
- """IdleEvent_SetMode(int mode)"""
- return _core_.IdleEvent_SetMode(*args, **kwargs)
+ """
+ IdleEvent_SetMode(int mode)
+
+ Static method for specifying how wxWidgets will send idle events: to
+ all windows, or only to those which specify that they will process the
+ events.
-def IdleEvent_GetMode(*args, **kwargs):
- """IdleEvent_GetMode() -> int"""
- return _core_.IdleEvent_GetMode(*args, **kwargs)
+ The mode can be one of the following values:
+
+ ========================= ========================================
+ wx.IDLE_PROCESS_ALL Send idle events to all windows
+ wx.IDLE_PROCESS_SPECIFIED Send idle events only to windows that have
+ the wx.WS_EX_PROCESS_IDLE extra style
+ flag set.
+ ========================= ========================================
+
+ """
+ return _core_.IdleEvent_SetMode(*args, **kwargs)
+
+def IdleEvent_GetMode(*args):
+ """
+ IdleEvent_GetMode() -> int
+
+ Static method returning a value specifying how wxWidgets will send
+ idle events: to all windows, or only to those which specify that they
+ will process the events.
+ """
+ return _core_.IdleEvent_GetMode(*args)
def IdleEvent_CanSend(*args, **kwargs):
- """IdleEvent_CanSend(Window win) -> bool"""
- return _core_.IdleEvent_CanSend(*args, **kwargs)
+ """
+ IdleEvent_CanSend(Window win) -> bool
+
+ Returns ``True`` if it is appropriate to send idle events to this
+ window.
+
+ This function looks at the mode used (see `wx.IdleEvent.SetMode`), and
+ the wx.WS_EX_PROCESS_IDLE style in window to determine whether idle
+ events should be sent to this window now. By default this will always
+ return ``True`` because the update mode is initially
+ wx.IDLE_PROCESS_ALL. You can change the mode to only send idle events
+ to windows with the wx.WS_EX_PROCESS_IDLE extra window style set.
+ """
+ return _core_.IdleEvent_CanSend(*args, **kwargs)
+
+#---------------------------------------------------------------------------
+
+class ClipboardTextEvent(CommandEvent):
+ """
+ A Clipboard Text event is sent when a window intercepts a text
+ copy/cut/paste message, i.e. the user has cut/copied/pasted data
+ from/into a text control via ctrl-C/X/V, ctrl/shift-del/insert, a
+ popup menu command, etc. NOTE : under windows these events are *NOT*
+ generated automatically for a Rich Edit text control.
+ """
+ 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, EventType type=wxEVT_NULL, int winid=0) -> ClipboardTextEvent
+
+ A Clipboard Text event is sent when a window intercepts a text
+ copy/cut/paste message, i.e. the user has cut/copied/pasted data
+ from/into a text control via ctrl-C/X/V, ctrl/shift-del/insert, a
+ popup menu command, etc. NOTE : under windows these events are *NOT*
+ generated automatically for a Rich Edit text control.
+ """
+ _core_.ClipboardTextEvent_swiginit(self,_core_.new_ClipboardTextEvent(*args, **kwargs))
+_core_.ClipboardTextEvent_swigregister(ClipboardTextEvent)
#---------------------------------------------------------------------------
class PyEvent(Event):
- """Proxy of C++ PyEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPyEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, int winid=0, wxEventType commandType=wxEVT_NULL) -> PyEvent"""
- newobj = _core_.new_PyEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- self.SetSelf(self)
-
- def __del__(self, destroy=_core_.delete_PyEvent):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
+ """
+ wx.PyEvent can be used as a base class for implementing custom event
+ types in Python. You should derived from this class instead of
+ `wx.Event` because this class is Python-aware and is able to transport
+ its Python bits safely through the wxWidgets event system and have
+ them still be there when the event handler is invoked.
- def SetSelf(*args, **kwargs):
- """SetSelf(self, PyObject self)"""
- return _core_.PyEvent_SetSelf(*args, **kwargs)
+ :see: `wx.PyCommandEvent`
- def GetSelf(*args, **kwargs):
- """GetSelf(self) -> PyObject"""
- return _core_.PyEvent_GetSelf(*args, **kwargs)
+ """
+ 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, int winid=0, EventType eventType=wxEVT_NULL) -> PyEvent"""
+ _core_.PyEvent_swiginit(self,_core_.new_PyEvent(*args, **kwargs))
+ self._SetSelf(self)
+
+ __swig_destroy__ = _core_.delete_PyEvent
+ __del__ = lambda self : None;
+ def _SetSelf(*args, **kwargs):
+ """_SetSelf(self, PyObject self)"""
+ return _core_.PyEvent__SetSelf(*args, **kwargs)
+ def _GetSelf(*args, **kwargs):
+ """_GetSelf(self) -> PyObject"""
+ return _core_.PyEvent__GetSelf(*args, **kwargs)
-class PyEventPtr(PyEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PyEvent
-_core_.PyEvent_swigregister(PyEventPtr)
+_core_.PyEvent_swigregister(PyEvent)
class PyCommandEvent(CommandEvent):
- """Proxy of C++ PyCommandEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPyCommandEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, wxEventType commandType=wxEVT_NULL, int id=0) -> PyCommandEvent"""
- newobj = _core_.new_PyCommandEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- self.SetSelf(self)
-
- def __del__(self, destroy=_core_.delete_PyCommandEvent):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
+ """
+ wx.PyCommandEvent can be used as a base class for implementing custom
+ event types in Python, where the event shoudl travel up to parent
+ windows looking for a handler. You should derived from this class
+ instead of `wx.CommandEvent` because this class is Python-aware and is
+ able to transport its Python bits safely through the wxWidgets event
+ system and have them still be there when the event handler is invoked.
+
+ :see: `wx.PyEvent`
- def SetSelf(*args, **kwargs):
- """SetSelf(self, PyObject self)"""
- return _core_.PyCommandEvent_SetSelf(*args, **kwargs)
+ """
+ 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, EventType eventType=wxEVT_NULL, int id=0) -> PyCommandEvent"""
+ _core_.PyCommandEvent_swiginit(self,_core_.new_PyCommandEvent(*args, **kwargs))
+ self._SetSelf(self)
- def GetSelf(*args, **kwargs):
- """GetSelf(self) -> PyObject"""
- return _core_.PyCommandEvent_GetSelf(*args, **kwargs)
+ __swig_destroy__ = _core_.delete_PyCommandEvent
+ __del__ = lambda self : None;
+ def _SetSelf(*args, **kwargs):
+ """_SetSelf(self, PyObject self)"""
+ return _core_.PyCommandEvent__SetSelf(*args, **kwargs)
+ def _GetSelf(*args, **kwargs):
+ """_GetSelf(self) -> PyObject"""
+ return _core_.PyCommandEvent__GetSelf(*args, **kwargs)
-class PyCommandEventPtr(PyCommandEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PyCommandEvent
-_core_.PyCommandEvent_swigregister(PyCommandEventPtr)
+_core_.PyCommandEvent_swigregister(PyCommandEvent)
class DateEvent(CommandEvent):
- """Proxy of C++ DateEvent class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxDateEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
- """__init__(self, Window win, DateTime dt, wxEventType type) -> DateEvent"""
- newobj = _core_.new_DateEvent(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ """
+ This event class holds information about a date change event and is
+ used together with `wx.DatePickerCtrl`. It also serves as a base class
+ for `wx.calendar.CalendarEvent`. Bind these event types with
+ EVT_DATE_CHANGED.
+ """
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
+ """__init__(self, Window win, DateTime dt, EventType type) -> DateEvent"""
+ _core_.DateEvent_swiginit(self,_core_.new_DateEvent(*args, **kwargs))
def GetDate(*args, **kwargs):
- """GetDate(self) -> DateTime"""
+ """
+ GetDate(self) -> DateTime
+
+ Returns the date.
+ """
return _core_.DateEvent_GetDate(*args, **kwargs)
def SetDate(*args, **kwargs):
- """SetDate(self, DateTime date)"""
- return _core_.DateEvent_SetDate(*args, **kwargs)
+ """
+ SetDate(self, DateTime date)
+ Sets the date carried by the event, normally only used by the library
+ internally.
+ """
+ return _core_.DateEvent_SetDate(*args, **kwargs)
-class DateEventPtr(DateEvent):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = DateEvent
-_core_.DateEvent_swigregister(DateEventPtr)
+ Date = property(GetDate,SetDate,doc="See `GetDate` and `SetDate`")
+_core_.DateEvent_swigregister(DateEvent)
wxEVT_DATE_CHANGED = _core_.wxEVT_DATE_CHANGED
EVT_DATE_CHANGED = wx.PyEventBinder( wxEVT_DATE_CHANGED, 1 )
The ``wx.PyApp`` class is an *implementation detail*, please use the
`wx.App` class (or some other derived class) instead.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPyApp instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> PyApp
Create a new application object, starting the bootstrap process.
"""
- newobj = _core_.new_PyApp(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.PyApp_swiginit(self,_core_.new_PyApp(*args, **kwargs))
self._setCallbackInfo(self, PyApp, False)
self._setOORInfo(self, False)
- def __del__(self, destroy=_core_.delete_PyApp):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ __swig_destroy__ = _core_.delete_PyApp
+ __del__ = lambda self : None;
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class, bool incref)"""
return _core_.PyApp__setCallbackInfo(*args, **kwargs)
"""
return _core_.PyApp_Exit(*args, **kwargs)
+ def GetLayoutDirection(*args, **kwargs):
+ """
+ GetLayoutDirection(self) -> int
+
+ Return the layout direction for the current locale.
+ """
+ return _core_.PyApp_GetLayoutDirection(*args, **kwargs)
+
def ExitMainLoop(*args, **kwargs):
"""
ExitMainLoop(self)
return _core_.PyApp_GetComCtl32Version(*args, **kwargs)
GetComCtl32Version = staticmethod(GetComCtl32Version)
+ def IsDisplayAvailable(*args, **kwargs):
+ """
+ IsDisplayAvailable() -> bool
-class PyAppPtr(PyApp):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PyApp
-_core_.PyApp_swigregister(PyAppPtr)
+ Tests if it is possible to create a GUI in the current environment.
+ This will mean different things on the different platforms.
-def PyApp_IsMainLoopRunning(*args, **kwargs):
- """
+ * On X Windows systems this function will return ``False`` if it is
+ not able to open a connection to the X display, which can happen
+ if $DISPLAY is not set, or is not set correctly.
+
+ * On Mac OS X a ``False`` return value will mean that wx is not
+ able to access the window manager, which can happen if logged in
+ remotely or if running from the normal version of python instead
+ of the framework version, (i.e., pythonw.)
+
+ * On MS Windows...
+
+ """
+ return _core_.PyApp_IsDisplayAvailable(*args, **kwargs)
+
+ IsDisplayAvailable = staticmethod(IsDisplayAvailable)
+ AppName = property(GetAppName,SetAppName,doc="See `GetAppName` and `SetAppName`")
+ AssertMode = property(GetAssertMode,SetAssertMode,doc="See `GetAssertMode` and `SetAssertMode`")
+ ClassName = property(GetClassName,SetClassName,doc="See `GetClassName` and `SetClassName`")
+ ExitOnFrameDelete = property(GetExitOnFrameDelete,SetExitOnFrameDelete,doc="See `GetExitOnFrameDelete` and `SetExitOnFrameDelete`")
+ LayoutDirection = property(GetLayoutDirection,doc="See `GetLayoutDirection`")
+ PrintMode = property(GetPrintMode,SetPrintMode,doc="See `GetPrintMode` and `SetPrintMode`")
+ TopWindow = property(GetTopWindow,SetTopWindow,doc="See `GetTopWindow` and `SetTopWindow`")
+ Traits = property(GetTraits,doc="See `GetTraits`")
+ UseBestVisual = property(GetUseBestVisual,SetUseBestVisual,doc="See `GetUseBestVisual` and `SetUseBestVisual`")
+ VendorName = property(GetVendorName,SetVendorName,doc="See `GetVendorName` and `SetVendorName`")
+ Active = property(IsActive)
+_core_.PyApp_swigregister(PyApp)
+
+def PyApp_IsMainLoopRunning(*args):
+ """
PyApp_IsMainLoopRunning() -> bool
Returns True if we're running the main loop, i.e. if the events can
currently be dispatched.
"""
- return _core_.PyApp_IsMainLoopRunning(*args, **kwargs)
+ return _core_.PyApp_IsMainLoopRunning(*args)
-def PyApp_GetMacSupportPCMenuShortcuts(*args, **kwargs):
- """PyApp_GetMacSupportPCMenuShortcuts() -> bool"""
- return _core_.PyApp_GetMacSupportPCMenuShortcuts(*args, **kwargs)
+def PyApp_GetMacSupportPCMenuShortcuts(*args):
+ """PyApp_GetMacSupportPCMenuShortcuts() -> bool"""
+ return _core_.PyApp_GetMacSupportPCMenuShortcuts(*args)
-def PyApp_GetMacAboutMenuItemId(*args, **kwargs):
- """PyApp_GetMacAboutMenuItemId() -> long"""
- return _core_.PyApp_GetMacAboutMenuItemId(*args, **kwargs)
+def PyApp_GetMacAboutMenuItemId(*args):
+ """PyApp_GetMacAboutMenuItemId() -> long"""
+ return _core_.PyApp_GetMacAboutMenuItemId(*args)
-def PyApp_GetMacPreferencesMenuItemId(*args, **kwargs):
- """PyApp_GetMacPreferencesMenuItemId() -> long"""
- return _core_.PyApp_GetMacPreferencesMenuItemId(*args, **kwargs)
+def PyApp_GetMacPreferencesMenuItemId(*args):
+ """PyApp_GetMacPreferencesMenuItemId() -> long"""
+ return _core_.PyApp_GetMacPreferencesMenuItemId(*args)
-def PyApp_GetMacExitMenuItemId(*args, **kwargs):
- """PyApp_GetMacExitMenuItemId() -> long"""
- return _core_.PyApp_GetMacExitMenuItemId(*args, **kwargs)
+def PyApp_GetMacExitMenuItemId(*args):
+ """PyApp_GetMacExitMenuItemId() -> long"""
+ return _core_.PyApp_GetMacExitMenuItemId(*args)
-def PyApp_GetMacHelpMenuTitleName(*args, **kwargs):
- """PyApp_GetMacHelpMenuTitleName() -> String"""
- return _core_.PyApp_GetMacHelpMenuTitleName(*args, **kwargs)
+def PyApp_GetMacHelpMenuTitleName(*args):
+ """PyApp_GetMacHelpMenuTitleName() -> String"""
+ return _core_.PyApp_GetMacHelpMenuTitleName(*args)
def PyApp_SetMacSupportPCMenuShortcuts(*args, **kwargs):
- """PyApp_SetMacSupportPCMenuShortcuts(bool val)"""
- return _core_.PyApp_SetMacSupportPCMenuShortcuts(*args, **kwargs)
+ """PyApp_SetMacSupportPCMenuShortcuts(bool val)"""
+ return _core_.PyApp_SetMacSupportPCMenuShortcuts(*args, **kwargs)
def PyApp_SetMacAboutMenuItemId(*args, **kwargs):
- """PyApp_SetMacAboutMenuItemId(long val)"""
- return _core_.PyApp_SetMacAboutMenuItemId(*args, **kwargs)
+ """PyApp_SetMacAboutMenuItemId(long val)"""
+ return _core_.PyApp_SetMacAboutMenuItemId(*args, **kwargs)
def PyApp_SetMacPreferencesMenuItemId(*args, **kwargs):
- """PyApp_SetMacPreferencesMenuItemId(long val)"""
- return _core_.PyApp_SetMacPreferencesMenuItemId(*args, **kwargs)
+ """PyApp_SetMacPreferencesMenuItemId(long val)"""
+ return _core_.PyApp_SetMacPreferencesMenuItemId(*args, **kwargs)
def PyApp_SetMacExitMenuItemId(*args, **kwargs):
- """PyApp_SetMacExitMenuItemId(long val)"""
- return _core_.PyApp_SetMacExitMenuItemId(*args, **kwargs)
+ """PyApp_SetMacExitMenuItemId(long val)"""
+ return _core_.PyApp_SetMacExitMenuItemId(*args, **kwargs)
def PyApp_SetMacHelpMenuTitleName(*args, **kwargs):
- """PyApp_SetMacHelpMenuTitleName(String val)"""
- return _core_.PyApp_SetMacHelpMenuTitleName(*args, **kwargs)
+ """PyApp_SetMacHelpMenuTitleName(String val)"""
+ return _core_.PyApp_SetMacHelpMenuTitleName(*args, **kwargs)
-def PyApp_GetComCtl32Version(*args, **kwargs):
- """
+def PyApp_GetComCtl32Version(*args):
+ """
PyApp_GetComCtl32Version() -> int
Returns 400, 470, 471, etc. for comctl32.dll 4.00, 4.70, 4.71 or 0 if
it wasn't found at all. Raises an exception on non-Windows platforms.
"""
- return _core_.PyApp_GetComCtl32Version(*args, **kwargs)
+ return _core_.PyApp_GetComCtl32Version(*args)
-#---------------------------------------------------------------------------
+def PyApp_IsDisplayAvailable(*args):
+ """
+ PyApp_IsDisplayAvailable() -> bool
+
+ Tests if it is possible to create a GUI in the current environment.
+ This will mean different things on the different platforms.
+
+ * On X Windows systems this function will return ``False`` if it is
+ not able to open a connection to the X display, which can happen
+ if $DISPLAY is not set, or is not set correctly.
+ * On Mac OS X a ``False`` return value will mean that wx is not
+ able to access the window manager, which can happen if logged in
+ remotely or if running from the normal version of python instead
+ of the framework version, (i.e., pythonw.)
+
+ * On MS Windows...
-def Exit(*args, **kwargs):
"""
+ return _core_.PyApp_IsDisplayAvailable(*args)
+
+#---------------------------------------------------------------------------
+
+
+def Exit(*args):
+ """
Exit()
Force an exit of the application. Convenience for wx.GetApp().Exit()
"""
- return _core_.Exit(*args, **kwargs)
+ return _core_.Exit(*args)
-def Yield(*args, **kwargs):
- """
+def Yield(*args):
+ """
Yield() -> bool
Yield to other apps/messages. Convenience for wx.GetApp().Yield()
"""
- return _core_.Yield(*args, **kwargs)
+ return _core_.Yield(*args)
-def YieldIfNeeded(*args, **kwargs):
- """
+def YieldIfNeeded(*args):
+ """
YieldIfNeeded() -> bool
Yield to other apps/messages. Convenience for wx.GetApp().Yield(True)
"""
- return _core_.YieldIfNeeded(*args, **kwargs)
+ return _core_.YieldIfNeeded(*args)
def SafeYield(*args, **kwargs):
- """
+ """
SafeYield(Window win=None, bool onlyIfNeeded=False) -> bool
This function is similar to `wx.Yield`, except that it disables the
:Returns: the result of the call to `wx.Yield`.
"""
- return _core_.SafeYield(*args, **kwargs)
+ return _core_.SafeYield(*args, **kwargs)
-def WakeUpIdle(*args, **kwargs):
- """
+def WakeUpIdle(*args):
+ """
WakeUpIdle()
Cause the message queue to become empty again, so idle events will be
sent.
"""
- return _core_.WakeUpIdle(*args, **kwargs)
+ return _core_.WakeUpIdle(*args)
def PostEvent(*args, **kwargs):
- """
+ """
PostEvent(EvtHandler dest, Event event)
Send an event to a window or other wx.EvtHandler to be processed
later.
"""
- return _core_.PostEvent(*args, **kwargs)
+ return _core_.PostEvent(*args, **kwargs)
-def App_CleanUp(*args, **kwargs):
- """
+def App_CleanUp(*args):
+ """
App_CleanUp()
For internal use only, it is used to cleanup after wxWidgets when
Python shuts down.
"""
- return _core_.App_CleanUp(*args, **kwargs)
+ return _core_.App_CleanUp(*args)
-def GetApp(*args, **kwargs):
- """
+def GetApp(*args):
+ """
GetApp() -> PyApp
Return a reference to the current wx.App object.
"""
- return _core_.GetApp(*args, **kwargs)
+ return _core_.GetApp(*args)
def SetDefaultPyEncoding(*args, **kwargs):
- """
+ """
SetDefaultPyEncoding(string encoding)
Sets the encoding that wxPython will use when it needs to convert a
see http://www.alanwood.net/demos/charsetdiffs.html for differences
between the common latin/roman encodings.
"""
- return _core_.SetDefaultPyEncoding(*args, **kwargs)
+ return _core_.SetDefaultPyEncoding(*args, **kwargs)
-def GetDefaultPyEncoding(*args, **kwargs):
- """
+def GetDefaultPyEncoding(*args):
+ """
GetDefaultPyEncoding() -> string
Gets the current encoding that wxPython will use when it needs to
convert a Python string or unicode object to or from a wxString.
"""
- return _core_.GetDefaultPyEncoding(*args, **kwargs)
+ return _core_.GetDefaultPyEncoding(*args)
#----------------------------------------------------------------------
class PyOnDemandOutputWindow:
style=wx.TE_MULTILINE|wx.TE_READONLY)
self.text.AppendText(st)
self.frame.Show(True)
- EVT_CLOSE(self.frame, self.OnCloseWindow)
+ self.frame.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
def OnCloseWindow(self, event):
#----------------------------------------------------------------------
_defRedirect = (wx.Platform == '__WXMSW__' or wx.Platform == '__WXMAC__')
-
+
class App(wx.PyApp):
"""
The ``wx.App`` class represents the application and is used to:
initialization to ensure that the system, toolkit and
wxWidgets are fully initialized.
"""
+
wx.PyApp.__init__(self)
- if wx.Platform == "__WXMAC__":
- try:
- import MacOS
- if not MacOS.WMAvailable():
- print """\
-This program needs access to the screen. Please run with 'pythonw',
-not 'python', and only when you are logged in on the main display of
-your Mac."""
- _sys.exit(1)
- except SystemExit:
- raise
- except:
- pass
+ # make sure we can create a GUI
+ if not self.IsDisplayAvailable():
+
+ if wx.Platform == "__WXMAC__":
+ msg = """This program needs access to the screen.
+Please run with 'pythonw', not 'python', and only when you are logged
+in on the main display of your Mac."""
+
+ elif wx.Platform == "__WXGTK__":
+ msg ="Unable to access the X Display, is $DISPLAY set properly?"
+
+ else:
+ msg = "Unable to create GUI"
+ # TODO: more description is needed for wxMSW...
+ raise SystemExit(msg)
+
# This has to be done before OnInit
self.SetUseBestVisual(useBestVisual)
self._BootstrapApp()
+ def OnPreInit(self):
+ """
+ Things that must be done after _BootstrapApp has done its
+ thing, but would be nice if they were already done by the time
+ that OnInit is called.
+ """
+ wx.StockGDI._initStockObjects()
+
+
def __del__(self, destroy=wx.PyApp.__del__):
self.RestoreStdio() # Just in case the MainLoop was overridden
destroy(self)
def Destroy(self):
+ self.this.own(False)
wx.PyApp.Destroy(self)
- self.thisown = 0
def SetTopWindow(self, frame):
"""Set the \"main\" top level window"""
class EventLoop(object):
"""Proxy of C++ EventLoop class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxEventLoop instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> EventLoop"""
- newobj = _core_.new_EventLoop(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_core_.delete_EventLoop):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _core_.EventLoop_swiginit(self,_core_.new_EventLoop(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_EventLoop
+ __del__ = lambda self : None;
def Run(*args, **kwargs):
"""Run(self) -> int"""
return _core_.EventLoop_Run(*args, **kwargs)
return _core_.EventLoop_SetActive(*args, **kwargs)
SetActive = staticmethod(SetActive)
+_core_.EventLoop_swigregister(EventLoop)
-class EventLoopPtr(EventLoop):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = EventLoop
-_core_.EventLoop_swigregister(EventLoopPtr)
-
-def EventLoop_GetActive(*args, **kwargs):
- """EventLoop_GetActive() -> EventLoop"""
- return _core_.EventLoop_GetActive(*args, **kwargs)
+def EventLoop_GetActive(*args):
+ """EventLoop_GetActive() -> EventLoop"""
+ return _core_.EventLoop_GetActive(*args)
def EventLoop_SetActive(*args, **kwargs):
- """EventLoop_SetActive(EventLoop loop)"""
- return _core_.EventLoop_SetActive(*args, **kwargs)
+ """EventLoop_SetActive(EventLoop loop)"""
+ return _core_.EventLoop_SetActive(*args, **kwargs)
+
+class EventLoopActivator(object):
+ """Proxy of C++ EventLoopActivator 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, EventLoop evtLoop) -> EventLoopActivator"""
+ _core_.EventLoopActivator_swiginit(self,_core_.new_EventLoopActivator(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_EventLoopActivator
+ __del__ = lambda self : None;
+_core_.EventLoopActivator_swigregister(EventLoopActivator)
#---------------------------------------------------------------------------
+ACCEL_ALT = _core_.ACCEL_ALT
+ACCEL_CTRL = _core_.ACCEL_CTRL
+ACCEL_SHIFT = _core_.ACCEL_SHIFT
+ACCEL_NORMAL = _core_.ACCEL_NORMAL
+ACCEL_CMD = _core_.ACCEL_CMD
class AcceleratorEntry(object):
"""
A class used to define items in an `wx.AcceleratorTable`. wxPython
:see: `wx.AcceleratorTable`
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxAcceleratorEntry instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, int flags=0, int keyCode=0, int cmdID=0) -> AcceleratorEntry
Construct a wx.AcceleratorEntry.
"""
- newobj = _core_.new_AcceleratorEntry(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_core_.delete_AcceleratorEntry):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _core_.AcceleratorEntry_swiginit(self,_core_.new_AcceleratorEntry(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_AcceleratorEntry
+ __del__ = lambda self : None;
def Set(*args, **kwargs):
"""
Set(self, int flags, int keyCode, int cmd)
"""
return _core_.AcceleratorEntry_Set(*args, **kwargs)
+ def Create(*args, **kwargs):
+ """
+ Create(String str) -> AcceleratorEntry
+
+ Create accelerator corresponding to the specified string, or None if
+ it coulnd't be parsed.
+ """
+ return _core_.AcceleratorEntry_Create(*args, **kwargs)
+
+ Create = staticmethod(Create)
def GetFlags(*args, **kwargs):
"""
GetFlags(self) -> int
"""
return _core_.AcceleratorEntry_GetCommand(*args, **kwargs)
+ def IsOk(*args, **kwargs):
+ """IsOk(self) -> bool"""
+ return _core_.AcceleratorEntry_IsOk(*args, **kwargs)
+
+ def ToString(*args, **kwargs):
+ """
+ ToString(self) -> String
+
+ Returns a string representation for the this accelerator. The string
+ is formatted using the <flags>-<keycode> format where <flags> maybe a
+ hyphen-separed list of "shift|alt|ctrl"
+
+ """
+ return _core_.AcceleratorEntry_ToString(*args, **kwargs)
+
+ def FromString(*args, **kwargs):
+ """
+ FromString(self, String str) -> bool
+
+ Returns true if the given string correctly initialized this object.
+ """
+ return _core_.AcceleratorEntry_FromString(*args, **kwargs)
+
+ Command = property(GetCommand,doc="See `GetCommand`")
+ Flags = property(GetFlags,doc="See `GetFlags`")
+ KeyCode = property(GetKeyCode,doc="See `GetKeyCode`")
+_core_.AcceleratorEntry_swigregister(AcceleratorEntry)
-class AcceleratorEntryPtr(AcceleratorEntry):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = AcceleratorEntry
-_core_.AcceleratorEntry_swigregister(AcceleratorEntryPtr)
+def AcceleratorEntry_Create(*args, **kwargs):
+ """
+ AcceleratorEntry_Create(String str) -> AcceleratorEntry
+
+ Create accelerator corresponding to the specified string, or None if
+ it coulnd't be parsed.
+ """
+ return _core_.AcceleratorEntry_Create(*args, **kwargs)
class AcceleratorTable(Object):
"""
button commands are supported; on GTK, only menu commands are
supported.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxAcceleratorTable instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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__(entries) -> AcceleratorTable
:see: `wx.AcceleratorEntry`
"""
- newobj = _core_.new_AcceleratorTable(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_core_.delete_AcceleratorTable):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
- def Ok(*args, **kwargs):
- """Ok(self) -> bool"""
- return _core_.AcceleratorTable_Ok(*args, **kwargs)
-
+ _core_.AcceleratorTable_swiginit(self,_core_.new_AcceleratorTable(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_AcceleratorTable
+ __del__ = lambda self : None;
+ def IsOk(*args, **kwargs):
+ """IsOk(self) -> bool"""
+ return _core_.AcceleratorTable_IsOk(*args, **kwargs)
-class AcceleratorTablePtr(AcceleratorTable):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = AcceleratorTable
-_core_.AcceleratorTable_swigregister(AcceleratorTablePtr)
+ Ok = IsOk
+_core_.AcceleratorTable_swigregister(AcceleratorTable)
def GetAccelFromString(*args, **kwargs):
- """GetAccelFromString(String label) -> AcceleratorEntry"""
- return _core_.GetAccelFromString(*args, **kwargs)
+ """GetAccelFromString(String label) -> AcceleratorEntry"""
+ return _core_.GetAccelFromString(*args, **kwargs)
#---------------------------------------------------------------------------
class VisualAttributes(object):
"""struct containing all the visual attributes of a control"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxVisualAttributes instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> VisualAttributes
struct containing all the visual attributes of a control
"""
- newobj = _core_.new_VisualAttributes(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
- def __del__(self, destroy=_core_.delete_VisualAttributes):
- """__del__(self)"""
- try:
- if self.thisown: destroy(self)
- except: pass
-
+ _core_.VisualAttributes_swiginit(self,_core_.new_VisualAttributes(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_VisualAttributes
+ __del__ = lambda self : None;
font = property(_core_.VisualAttributes_font_get, _core_.VisualAttributes_font_set)
colFg = property(_core_.VisualAttributes_colFg_get, _core_.VisualAttributes_colFg_set)
colBg = property(_core_.VisualAttributes_colBg_get, _core_.VisualAttributes_colBg_set)
-
-class VisualAttributesPtr(VisualAttributes):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = VisualAttributes
-_core_.VisualAttributes_swigregister(VisualAttributesPtr)
+_core_.VisualAttributes_swigregister(VisualAttributes)
NullAcceleratorTable = cvar.NullAcceleratorTable
PanelNameStr = cvar.PanelNameStr
appear on screen themselves.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0, String name=PanelNameStr) -> Window
Construct and show a generic Window.
"""
- newobj = _core_.new_Window(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.Window_swiginit(self,_core_.new_Window(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
Returns True if the window has either been successfully deleted, or it
has been added to the list of windows pending real deletion.
"""
+ args[0].this.own(False)
return _core_.Window_Destroy(*args, **kwargs)
def DestroyChildren(*args, **kwargs):
"""
return _core_.Window_IsBeingDeleted(*args, **kwargs)
- def SetTitle(*args, **kwargs):
- """
- SetTitle(self, String title)
-
- Sets the window's title. Applicable only to frames and dialogs.
- """
- return _core_.Window_SetTitle(*args, **kwargs)
-
- def GetTitle(*args, **kwargs):
- """
- GetTitle(self) -> String
-
- Gets the window's title. Applicable only to frames and dialogs.
- """
- return _core_.Window_GetTitle(*args, **kwargs)
-
def SetLabel(*args, **kwargs):
"""
SetLabel(self, String label)
return _core_.Window_PrevControlId(*args, **kwargs)
PrevControlId = staticmethod(PrevControlId)
+ def GetLayoutDirection(*args, **kwargs):
+ """
+ GetLayoutDirection(self) -> int
+
+ Get the layout direction (LTR or RTL) for this window. Returns
+ ``wx.Layout_Default`` if layout direction is not supported.
+ """
+ return _core_.Window_GetLayoutDirection(*args, **kwargs)
+
+ def SetLayoutDirection(*args, **kwargs):
+ """
+ SetLayoutDirection(self, int dir)
+
+ Set the layout direction (LTR or RTL) for this window.
+ """
+ return _core_.Window_SetLayoutDirection(*args, **kwargs)
+
+ def AdjustForLayoutDirection(*args, **kwargs):
+ """
+ AdjustForLayoutDirection(self, int x, int width, int widthTotal) -> int
+
+ Mirror coordinates for RTL layout if this window uses it and if the
+ mirroring is not done automatically like Win32.
+ """
+ return _core_.Window_AdjustForLayoutDirection(*args, **kwargs)
+
def SetSize(*args, **kwargs):
"""
SetSize(self, Size size)
"""
return _core_.Window_MoveXY(*args, **kwargs)
- def SetBestFittingSize(*args, **kwargs):
+ def SetInitialSize(*args, **kwargs):
"""
- SetBestFittingSize(self, Size size=DefaultSize)
+ SetInitialSize(self, Size size=DefaultSize)
A 'Smart' SetSize that will fill in default size components with the
window's *best size* values. Also set's the minsize for use with sizers.
"""
- return _core_.Window_SetBestFittingSize(*args, **kwargs)
+ return _core_.Window_SetInitialSize(*args, **kwargs)
+ SetBestFittingSize = wx._deprecated(SetInitialSize, 'Use `SetInitialSize`')
def Raise(*args, **kwargs):
"""
Raise(self)
- Raises the window to the top of the window hierarchy if it is a
- managed window (dialog or frame).
+ Raises the window to the top of the window hierarchy. In current
+ version of wxWidgets this works both for manage and child windows.
"""
return _core_.Window_Raise(*args, **kwargs)
"""
Lower(self)
- Lowers the window to the bottom of the window hierarchy if it is a
- managed window (dialog or frame).
+ Lowers the window to the bottom of the window hierarchy. In current
+ version of wxWidgets this works both for manage and child windows.
"""
return _core_.Window_Lower(*args, **kwargs)
dimensions the border or title bar have when trying to fit the window
around panel items, for example.
"""
- return _core_.Window_SetClientRect(*args, **kwargs)
+ return _core_.Window_SetClientRect(*args, **kwargs)
+
+ def GetPosition(*args, **kwargs):
+ """
+ GetPosition(self) -> Point
+
+ Get the window's position. Notice that the position is in client
+ coordinates for child windows and screen coordinates for the top level
+ ones, use `GetScreenPosition` if you need screen coordinates for all
+ kinds of windows.
+ """
+ return _core_.Window_GetPosition(*args, **kwargs)
+
+ def GetPositionTuple(*args, **kwargs):
+ """
+ GetPositionTuple() -> (x,y)
+
+ Get the window's position. Notice that the position is in client
+ coordinates for child windows and screen coordinates for the top level
+ ones, use `GetScreenPosition` if you need screen coordinates for all
+ kinds of windows.
+ """
+ return _core_.Window_GetPositionTuple(*args, **kwargs)
+
+ def GetScreenPosition(*args, **kwargs):
+ """
+ GetScreenPosition(self) -> Point
- def GetPosition(*args, **kwargs):
+ Get the position of the window in screen coordinantes.
"""
- GetPosition(self) -> Point
+ return _core_.Window_GetScreenPosition(*args, **kwargs)
- Get the window's position.
+ def GetScreenPositionTuple(*args, **kwargs):
"""
- return _core_.Window_GetPosition(*args, **kwargs)
+ GetScreenPositionTuple() -> (x,y)
- def GetPositionTuple(*args, **kwargs):
+ Get the position of the window in screen coordinantes.
"""
- GetPositionTuple() -> (x,y)
+ return _core_.Window_GetScreenPositionTuple(*args, **kwargs)
- Get the window's position.
+ def GetScreenRect(*args, **kwargs):
"""
- return _core_.Window_GetPositionTuple(*args, **kwargs)
+ GetScreenRect(self) -> Rect
+
+ Returns the size and position of the window in screen coordinantes as
+ a `wx.Rect` object.
+ """
+ return _core_.Window_GetScreenRect(*args, **kwargs)
def GetSize(*args, **kwargs):
"""
"""
GetRect(self) -> Rect
- Returns the size and position of the window as a wx.Rect object.
+ Returns the size and position of the window as a `wx.Rect` object.
"""
return _core_.Window_GetRect(*args, **kwargs)
"""
return _core_.Window_InvalidateBestSize(*args, **kwargs)
- def GetBestFittingSize(*args, **kwargs):
+ def CacheBestSize(*args, **kwargs):
+ """
+ CacheBestSize(self, Size size)
+
+ Cache the best size so it doesn't need to be calculated again, (at least until
+ some properties of the window change.)
+ """
+ return _core_.Window_CacheBestSize(*args, **kwargs)
+
+ def GetEffectiveMinSize(*args, **kwargs):
"""
- GetBestFittingSize(self) -> Size
+ GetEffectiveMinSize(self) -> Size
This function will merge the window's best size into the window's
minimum size, giving priority to the min size components, and returns
the results.
"""
- return _core_.Window_GetBestFittingSize(*args, **kwargs)
-
- def GetAdjustedBestSize(*args, **kwargs):
- """
- GetAdjustedBestSize(self) -> Size
+ return _core_.Window_GetEffectiveMinSize(*args, **kwargs)
- This method is similar to GetBestSize, except in one
- thing. GetBestSize should return the minimum untruncated size of the
- window, while this method will return the largest of BestSize and any
- user specified minimum size. ie. it is the minimum size the window
- should currently be drawn at, not the minimal size it can possibly
- tolerate.
- """
- return _core_.Window_GetAdjustedBestSize(*args, **kwargs)
+ GetBestFittingSize = wx._deprecated(GetEffectiveMinSize, 'Use `GetEffectiveMinSize` instead.')
+ def GetAdjustedBestSize(self):
+ s = self.GetBestSize()
+ return wx.Size(max(s.width, self.GetMinWidth()),
+ max(s.height, self.GetMinHeight()))
+ GetAdjustedBestSize = wx._deprecated(GetAdjustedBestSize, 'Use `GetEffectiveMinSize` instead.')
def Center(*args, **kwargs):
"""
return _core_.Window_Center(*args, **kwargs)
Centre = Center
- def CenterOnScreen(*args, **kwargs):
- """
- CenterOnScreen(self, int dir=BOTH)
-
- Center on screen (only works for top level windows)
- """
- return _core_.Window_CenterOnScreen(*args, **kwargs)
-
- CentreOnScreen = CenterOnScreen
def CenterOnParent(*args, **kwargs):
"""
CenterOnParent(self, int dir=BOTH)
"""
return _core_.Window_IsEnabled(*args, **kwargs)
+ def IsShownOnScreen(*args, **kwargs):
+ """
+ IsShownOnScreen(self) -> bool
+
+ Returns ``True`` if the window is physically visible on the screen,
+ i.e. it is shown and all its parents up to the toplevel window are
+ shown as well.
+ """
+ return _core_.Window_IsShownOnScreen(*args, **kwargs)
+
def SetWindowStyleFlag(*args, **kwargs):
"""
SetWindowStyleFlag(self, long style)
"""
return _core_.Window_AcceptsFocusFromKeyboard(*args, **kwargs)
- def GetDefaultItem(*args, **kwargs):
- """
- GetDefaultItem(self) -> Window
-
- Get the default child of this parent, i.e. the one which is activated
- by pressing <Enter> such as the OK button on a wx.Dialog.
- """
- return _core_.Window_GetDefaultItem(*args, **kwargs)
-
- def SetDefaultItem(*args, **kwargs):
- """
- SetDefaultItem(self, Window child) -> Window
-
- Set this child as default, return the old default.
- """
- return _core_.Window_SetDefaultItem(*args, **kwargs)
-
- def SetTmpDefaultItem(*args, **kwargs):
- """
- SetTmpDefaultItem(self, Window win)
-
- Set this child as temporary default
- """
- return _core_.Window_SetTmpDefaultItem(*args, **kwargs)
-
def Navigate(*args, **kwargs):
"""
Navigate(self, int flags=NavigationKeyEvent.IsForward) -> bool
"""
return _core_.Window_RemoveChild(*args, **kwargs)
+ def SetDoubleBuffered(*args, **kwargs):
+ """
+ SetDoubleBuffered(self, bool on)
+
+ Currently wxGTK2 only.
+ """
+ return _core_.Window_SetDoubleBuffered(*args, **kwargs)
+
def FindWindowById(*args, **kwargs):
"""
FindWindowById(self, long winid) -> Window
SetEventHandler(self, EvtHandler handler)
Sets the event handler for this window. An event handler is an object
- that is capable of processing the events sent to a window. By default,
- the window is its own event handler, but an application may wish to
- substitute another, for example to allow central implementation of
- event-handling for a variety of different window classes.
+ that is capable of processing the events sent to a window. (In other
+ words, is able to dispatch the events to handler function.) By
+ default, the window is its own event handler, but an application may
+ wish to substitute another, for example to allow central
+ implementation of event-handling for a variety of different window
+ classes.
It is usually better to use `wx.Window.PushEventHandler` since this sets
up a chain of event handlers, where an event not handled by one event
- handler is handed to the next one in the chain.
+ handler is handed off to the next one in the chain.
"""
return _core_.Window_SetEventHandler(*args, **kwargs)
Pushes this event handler onto the event handler stack for the window.
An event handler is an object that is capable of processing the events
- sent to a window. By default, the window is its own event handler, but
- an application may wish to substitute another, for example to allow
- central implementation of event-handling for a variety of different
- window classes.
+ sent to a window. (In other words, is able to dispatch the events to
+ handler function.) By default, the window is its own event handler,
+ but an application may wish to substitute another, for example to
+ allow central implementation of event-handling for a variety of
+ different window classes.
wx.Window.PushEventHandler allows an application to set up a chain of
event handlers, where an event not handled by one event handler is
- handed to the next one in the chain. Use `wx.Window.PopEventHandler` to
- remove the event handler.
+ handed to the next one in the chain. Use `wx.Window.PopEventHandler`
+ to remove the event handler. Ownership of the handler is *not* given
+ to the window, so you should be sure to pop the handler before the
+ window is destroyed and either let PopEventHandler destroy it, or call
+ its Destroy method yourself.
"""
return _core_.Window_PushEventHandler(*args, **kwargs)
Removes and returns the top-most event handler on the event handler
stack. If deleteHandler is True then the wx.EvtHandler object will be
- destroyed after it is popped.
+ destroyed after it is popped, and ``None`` will be returned instead.
"""
return _core_.Window_PopEventHandler(*args, **kwargs)
RemoveEventHandler(self, EvtHandler handler) -> bool
Find the given handler in the event handler chain and remove (but not
- delete) it from the event handler chain, return True if it was found
+ delete) it from the event handler chain, returns True if it was found
and False otherwise (this also results in an assert failure so this
function should only be called when the handler is supposed to be
there.)
mouse and when the mouse is released the capture returns to the window
which had had captured it previously and it is only really released if
there were no previous window. In particular, this means that you must
- release the mouse as many times as you capture it.
+ release the mouse as many times as you capture it, unless the window
+ receives the `wx.MouseCaptureLostEvent` event.
+
+ Any application which captures the mouse in the beginning of some
+ operation *must* handle `wx.MouseCaptureLostEvent` and cancel this
+ operation when it receives the event. The event handler must not
+ recapture mouse.
"""
return _core_.Window_CaptureMouse(*args, **kwargs)
window instead of waiting for the EVT_PAINT event to happen, (normally
this would usually only happen when the flow of control returns to the
event loop.) Notice that this function doesn't refresh the window and
- does nothing if the window has been already repainted. Use Refresh
+ does nothing if the window has been already repainted. Use `Refresh`
first if you want to immediately redraw the window (or some portion of
it) unconditionally.
"""
"""
return _core_.Window_Freeze(*args, **kwargs)
+ def IsFrozen(*args, **kwargs):
+ """
+ IsFrozen(self) -> bool
+
+ Returns ``True`` if the window has been frozen and not thawed yet.
+
+ :see: `Freeze` and `Thaw`
+ """
+ return _core_.Window_IsFrozen(*args, **kwargs)
+
def Thaw(*args, **kwargs):
"""
Thaw(self)
"""
return _core_.Window_PrepareDC(*args, **kwargs)
+ def IsDoubleBuffered(*args, **kwargs):
+ """
+ IsDoubleBuffered(self) -> bool
+
+ Returns ``True`` if the window contents is double-buffered by the
+ system, i.e. if any drawing done on the window is really done on a
+ temporary backing surface and transferred to the screen all at once
+ later.
+ """
+ return _core_.Window_IsDoubleBuffered(*args, **kwargs)
+
def GetUpdateRegion(*args, **kwargs):
"""
GetUpdateRegion(self) -> Region
function from your application to ensure that your UI is up-to-date at
a particular point in time (as far as your EVT_UPDATE_UI handlers are
concerned). This may be necessary if you have called
- wx.UpdateUIEvent.SetMode or wx.UpdateUIEvent.SetUpdateInterval to
+ `wx.UpdateUIEvent.SetMode` or `wx.UpdateUIEvent.SetUpdateInterval` to
limit the overhead that wxWindows incurs by sending update UI events
in idle time.
"""
"""
return _core_.Window_PopupMenu(*args, **kwargs)
+ def HasMultiplePages(*args, **kwargs):
+ """HasMultiplePages(self) -> bool"""
+ return _core_.Window_HasMultiplePages(*args, **kwargs)
+
def GetHandle(*args, **kwargs):
"""
GetHandle(self) -> long
Sets the help text to be used as context-sensitive help for this
window. Note that the text is actually stored by the current
- wxHelpProvider implementation, and not in the window object itself.
+ `wx.HelpProvider` implementation, and not in the window object itself.
"""
return _core_.Window_SetHelpText(*args, **kwargs)
"""
return _core_.Window_SetHelpTextForId(*args, **kwargs)
+ def GetHelpTextAtPoint(*args, **kwargs):
+ """
+ GetHelpTextAtPoint(self, Point pt, wxHelpEvent::Origin origin) -> String
+
+ Get the help string associated with the given position in this window.
+
+ Notice that pt may be invalid if event origin is keyboard or unknown
+ and this method should return the global window help text then
+
+ """
+ return _core_.Window_GetHelpTextAtPoint(*args, **kwargs)
+
def GetHelpText(*args, **kwargs):
"""
GetHelpText(self) -> String
Gets the help text to be used as context-sensitive help for this
window. Note that the text is actually stored by the current
- wxHelpProvider implementation, and not in the window object itself.
+ `wx.HelpProvider` implementation, and not in the window object itself.
"""
return _core_.Window_GetHelpText(*args, **kwargs)
"""
return _core_.Window_GetDropTarget(*args, **kwargs)
+ def DragAcceptFiles(*args, **kwargs):
+ """
+ DragAcceptFiles(self, bool accept)
+
+ Enables or disables eligibility for drop file events, EVT_DROP_FILES.
+ Only functional on Windows.
+ """
+ return _core_.Window_DragAcceptFiles(*args, **kwargs)
+
def SetConstraints(*args, **kwargs):
"""
SetConstraints(self, LayoutConstraints constraints)
SetAutoLayout(self, bool autoLayout)
Determines whether the Layout function will be called automatically
- when the window is resized. It is called implicitly by SetSizer but
- if you use SetConstraints you should call it manually or otherwise the
- window layout won't be correctly updated when its size changes.
+ when the window is resized. lease note that this only happens for the
+ windows usually used to contain children, namely `wx.Panel` and
+ `wx.TopLevelWindow` (and the classes deriving from them).
+
+ This method is called implicitly by `SetSizer` but if you use
+ `SetConstraints` you should call it manually or otherwise the window
+ layout won't be correctly updated when its size changes.
"""
return _core_.Window_SetAutoLayout(*args, **kwargs)
"""
return _core_.Window_ShouldInheritColours(*args, **kwargs)
+ def CanSetTransparent(*args, **kwargs):
+ """
+ CanSetTransparent(self) -> bool
+
+ Returns ``True`` if the platform supports setting the transparency for
+ this window. Note that this method will err on the side of caution,
+ so it is possible that this will return ``False`` when it is in fact
+ possible to set the transparency.
+
+ NOTE: On X-windows systems the X server must have the composite
+ extension loaded, and there must be a composite manager program (such
+ as xcompmgr) running.
+ """
+ return _core_.Window_CanSetTransparent(*args, **kwargs)
+
+ def SetTransparent(*args, **kwargs):
+ """
+ SetTransparent(self, byte alpha) -> bool
+
+ Attempt to set the transparency of this window to the ``alpha`` value,
+ returns True on success. The ``alpha`` value is an integer in the
+ range of 0 to 255, where 0 is fully transparent and 255 is fully
+ opaque.
+ """
+ return _core_.Window_SetTransparent(*args, **kwargs)
+
def PostCreate(self, pre):
"""
Phase 3 of the 2-phase create <wink!>
if hasattr(self, '_setCallbackInfo'):
self._setCallbackInfo(self, self.__class__)
-
-class WindowPtr(Window):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Window
-_core_.Window_swigregister(WindowPtr)
+ def SendSizeEvent(self):
+ self.GetEventHandler().ProcessEvent(wx.SizeEvent((-1,-1)))
+
+ AcceleratorTable = property(GetAcceleratorTable,SetAcceleratorTable,doc="See `GetAcceleratorTable` and `SetAcceleratorTable`")
+ AdjustedBestSize = property(GetAdjustedBestSize,doc="See `GetAdjustedBestSize`")
+ AutoLayout = property(GetAutoLayout,SetAutoLayout,doc="See `GetAutoLayout` and `SetAutoLayout`")
+ BackgroundColour = property(GetBackgroundColour,SetBackgroundColour,doc="See `GetBackgroundColour` and `SetBackgroundColour`")
+ BackgroundStyle = property(GetBackgroundStyle,SetBackgroundStyle,doc="See `GetBackgroundStyle` and `SetBackgroundStyle`")
+ EffectiveMinSize = property(GetEffectiveMinSize,doc="See `GetEffectiveMinSize`")
+ BestSize = property(GetBestSize,doc="See `GetBestSize`")
+ BestVirtualSize = property(GetBestVirtualSize,doc="See `GetBestVirtualSize`")
+ Border = property(GetBorder,doc="See `GetBorder`")
+ Caret = property(GetCaret,SetCaret,doc="See `GetCaret` and `SetCaret`")
+ CharHeight = property(GetCharHeight,doc="See `GetCharHeight`")
+ CharWidth = property(GetCharWidth,doc="See `GetCharWidth`")
+ Children = property(GetChildren,doc="See `GetChildren`")
+ ClientAreaOrigin = property(GetClientAreaOrigin,doc="See `GetClientAreaOrigin`")
+ ClientRect = property(GetClientRect,SetClientRect,doc="See `GetClientRect` and `SetClientRect`")
+ ClientSize = property(GetClientSize,SetClientSize,doc="See `GetClientSize` and `SetClientSize`")
+ Constraints = property(GetConstraints,SetConstraints,doc="See `GetConstraints` and `SetConstraints`")
+ ContainingSizer = property(GetContainingSizer,SetContainingSizer,doc="See `GetContainingSizer` and `SetContainingSizer`")
+ Cursor = property(GetCursor,SetCursor,doc="See `GetCursor` and `SetCursor`")
+ DefaultAttributes = property(GetDefaultAttributes,doc="See `GetDefaultAttributes`")
+ DropTarget = property(GetDropTarget,SetDropTarget,doc="See `GetDropTarget` and `SetDropTarget`")
+ EventHandler = property(GetEventHandler,SetEventHandler,doc="See `GetEventHandler` and `SetEventHandler`")
+ ExtraStyle = property(GetExtraStyle,SetExtraStyle,doc="See `GetExtraStyle` and `SetExtraStyle`")
+ Font = property(GetFont,SetFont,doc="See `GetFont` and `SetFont`")
+ ForegroundColour = property(GetForegroundColour,SetForegroundColour,doc="See `GetForegroundColour` and `SetForegroundColour`")
+ GrandParent = property(GetGrandParent,doc="See `GetGrandParent`")
+ Handle = property(GetHandle,doc="See `GetHandle`")
+ HelpText = property(GetHelpText,SetHelpText,doc="See `GetHelpText` and `SetHelpText`")
+ Id = property(GetId,SetId,doc="See `GetId` and `SetId`")
+ Label = property(GetLabel,SetLabel,doc="See `GetLabel` and `SetLabel`")
+ LayoutDirection = property(GetLayoutDirection,SetLayoutDirection,doc="See `GetLayoutDirection` and `SetLayoutDirection`")
+ MaxHeight = property(GetMaxHeight,doc="See `GetMaxHeight`")
+ MaxSize = property(GetMaxSize,SetMaxSize,doc="See `GetMaxSize` and `SetMaxSize`")
+ MaxWidth = property(GetMaxWidth,doc="See `GetMaxWidth`")
+ MinHeight = property(GetMinHeight,doc="See `GetMinHeight`")
+ MinSize = property(GetMinSize,SetMinSize,doc="See `GetMinSize` and `SetMinSize`")
+ MinWidth = property(GetMinWidth,doc="See `GetMinWidth`")
+ Name = property(GetName,SetName,doc="See `GetName` and `SetName`")
+ Parent = property(GetParent,doc="See `GetParent`")
+ Position = property(GetPosition,SetPosition,doc="See `GetPosition` and `SetPosition`")
+ Rect = property(GetRect,SetRect,doc="See `GetRect` and `SetRect`")
+ ScreenPosition = property(GetScreenPosition,doc="See `GetScreenPosition`")
+ ScreenRect = property(GetScreenRect,doc="See `GetScreenRect`")
+ Size = property(GetSize,SetSize,doc="See `GetSize` and `SetSize`")
+ Sizer = property(GetSizer,SetSizer,doc="See `GetSizer` and `SetSizer`")
+ ThemeEnabled = property(GetThemeEnabled,SetThemeEnabled,doc="See `GetThemeEnabled` and `SetThemeEnabled`")
+ ToolTip = property(GetToolTip,SetToolTip,doc="See `GetToolTip` and `SetToolTip`")
+ UpdateClientRect = property(GetUpdateClientRect,doc="See `GetUpdateClientRect`")
+ UpdateRegion = property(GetUpdateRegion,doc="See `GetUpdateRegion`")
+ Validator = property(GetValidator,SetValidator,doc="See `GetValidator` and `SetValidator`")
+ VirtualSize = property(GetVirtualSize,SetVirtualSize,doc="See `GetVirtualSize` and `SetVirtualSize`")
+ WindowStyle = property(GetWindowStyle,SetWindowStyle,doc="See `GetWindowStyle` and `SetWindowStyle`")
+ WindowStyleFlag = property(GetWindowStyleFlag,SetWindowStyleFlag,doc="See `GetWindowStyleFlag` and `SetWindowStyleFlag`")
+ WindowVariant = property(GetWindowVariant,SetWindowVariant,doc="See `GetWindowVariant` and `SetWindowVariant`")
+ Shown = property(IsShown,Show,doc="See `IsShown` and `Show`")
+ Enabled = property(IsEnabled,Enable,doc="See `IsEnabled` and `Enable`")
+ TopLevel = property(IsTopLevel,doc="See `IsTopLevel`")
+_core_.Window_swigregister(Window)
def PreWindow(*args, **kwargs):
"""
Precreate a Window for 2-phase creation.
"""
val = _core_.new_PreWindow(*args, **kwargs)
- val.thisown = 1
return val
-def Window_NewControlId(*args, **kwargs):
- """
+def Window_NewControlId(*args):
+ """
Window_NewControlId() -> int
Generate a control id for the controls which were not given one.
"""
- return _core_.Window_NewControlId(*args, **kwargs)
+ return _core_.Window_NewControlId(*args)
def Window_NextControlId(*args, **kwargs):
- """
+ """
Window_NextControlId(int winid) -> int
Get the id of the control following the one with the given
autogenerated) id
"""
- return _core_.Window_NextControlId(*args, **kwargs)
+ return _core_.Window_NextControlId(*args, **kwargs)
def Window_PrevControlId(*args, **kwargs):
- """
+ """
Window_PrevControlId(int winid) -> int
Get the id of the control preceding the one with the given
autogenerated) id
"""
- return _core_.Window_PrevControlId(*args, **kwargs)
+ return _core_.Window_PrevControlId(*args, **kwargs)
-def Window_FindFocus(*args, **kwargs):
- """
+def Window_FindFocus(*args):
+ """
Window_FindFocus() -> Window
Returns the window or control that currently has the keyboard focus,
or None.
"""
- return _core_.Window_FindFocus(*args, **kwargs)
+ return _core_.Window_FindFocus(*args)
-def Window_GetCapture(*args, **kwargs):
- """
+def Window_GetCapture(*args):
+ """
Window_GetCapture() -> Window
Returns the window which currently captures the mouse or None
"""
- return _core_.Window_GetCapture(*args, **kwargs)
+ return _core_.Window_GetCapture(*args)
def Window_GetClassDefaultAttributes(*args, **kwargs):
- """
+ """
Window_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
- return _core_.Window_GetClassDefaultAttributes(*args, **kwargs)
+ return _core_.Window_GetClassDefaultAttributes(*args, **kwargs)
def DLG_PNT(win, point_or_x, y=None):
"""
def FindWindowById(*args, **kwargs):
- """
+ """
FindWindowById(long id, Window parent=None) -> Window
Find the first window in the application with the given id. If parent
boxes; if non-None, the search will be limited to the given window
hierarchy. The search is recursive in both cases.
"""
- return _core_.FindWindowById(*args, **kwargs)
+ return _core_.FindWindowById(*args, **kwargs)
def FindWindowByName(*args, **kwargs):
- """
+ """
FindWindowByName(String name, Window parent=None) -> Window
Find a window by its name (as given in a window constructor or Create
If no window with such name is found, wx.FindWindowByLabel is called.
"""
- return _core_.FindWindowByName(*args, **kwargs)
+ return _core_.FindWindowByName(*args, **kwargs)
def FindWindowByLabel(*args, **kwargs):
- """
+ """
FindWindowByLabel(String label, Window parent=None) -> Window
Find a window by its label. Depending on the type of window, the label
non-None, the search will be limited to the given window
hierarchy. The search is recursive in both cases.
"""
- return _core_.FindWindowByLabel(*args, **kwargs)
+ return _core_.FindWindowByLabel(*args, **kwargs)
def Window_FromHWND(*args, **kwargs):
- """Window_FromHWND(Window parent, unsigned long _hWnd) -> Window"""
- return _core_.Window_FromHWND(*args, **kwargs)
+ """Window_FromHWND(Window parent, unsigned long _hWnd) -> Window"""
+ return _core_.Window_FromHWND(*args, **kwargs)
-def GetTopLevelWindows(*args, **kwargs):
- """
+def GetTopLevelWindows(*args):
+ """
GetTopLevelWindows() -> PyObject
Returns a list of the the application's top-level windows, (frames,
are closed or new top-level windows are created.
"""
- return _core_.GetTopLevelWindows(*args, **kwargs)
+ return _core_.GetTopLevelWindows(*args)
#---------------------------------------------------------------------------
class Validator(EvtHandler):
"""Proxy of C++ Validator class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxValidator instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> Validator"""
- newobj = _core_.new_Validator(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.Validator_swiginit(self,_core_.new_Validator(*args, **kwargs))
self._setOORInfo(self)
def Clone(*args, **kwargs):
return _core_.Validator_SetBellOnError(*args, **kwargs)
SetBellOnError = staticmethod(SetBellOnError)
+ Window = property(GetWindow,SetWindow,doc="See `GetWindow` and `SetWindow`")
+_core_.Validator_swigregister(Validator)
-class ValidatorPtr(Validator):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Validator
-_core_.Validator_swigregister(ValidatorPtr)
-
-def Validator_IsSilent(*args, **kwargs):
- """Validator_IsSilent() -> bool"""
- return _core_.Validator_IsSilent(*args, **kwargs)
+def Validator_IsSilent(*args):
+ """Validator_IsSilent() -> bool"""
+ return _core_.Validator_IsSilent(*args)
def Validator_SetBellOnError(*args, **kwargs):
- """Validator_SetBellOnError(int doIt=True)"""
- return _core_.Validator_SetBellOnError(*args, **kwargs)
+ """Validator_SetBellOnError(int doIt=True)"""
+ return _core_.Validator_SetBellOnError(*args, **kwargs)
class PyValidator(Validator):
"""Proxy of C++ PyValidator class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPyValidator instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> PyValidator"""
- newobj = _core_.new_PyValidator(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.PyValidator_swiginit(self,_core_.new_PyValidator(*args, **kwargs))
self._setCallbackInfo(self, PyValidator, 1)
self._setOORInfo(self)
"""_setCallbackInfo(self, PyObject self, PyObject _class, int incref=True)"""
return _core_.PyValidator__setCallbackInfo(*args, **kwargs)
-
-class PyValidatorPtr(PyValidator):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PyValidator
-_core_.PyValidator_swigregister(PyValidatorPtr)
+_core_.PyValidator_swigregister(PyValidator)
#---------------------------------------------------------------------------
class Menu(EvtHandler):
"""Proxy of C++ Menu class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMenu instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, String title=EmptyString, long style=0) -> Menu"""
- newobj = _core_.new_Menu(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.Menu_swiginit(self,_core_.new_Menu(*args, **kwargs))
self._setOORInfo(self)
def Append(*args, **kwargs):
- """Append(self, int id, String text, String help=EmptyString, int kind=ITEM_NORMAL) -> MenuItem"""
+ """
+ Append(self, int id, String text=EmptyString, String help=EmptyString,
+ int kind=ITEM_NORMAL) -> MenuItem
+ """
return _core_.Menu_Append(*args, **kwargs)
def AppendSeparator(*args, **kwargs):
"""AppendMenu(self, int id, String text, Menu submenu, String help=EmptyString) -> MenuItem"""
return _core_.Menu_AppendMenu(*args, **kwargs)
+ def AppendSubMenu(*args, **kwargs):
+ """AppendSubMenu(self, Menu submenu, String text, String help=EmptyString) -> MenuItem"""
+ return _core_.Menu_AppendSubMenu(*args, **kwargs)
+
def AppendItem(*args, **kwargs):
"""AppendItem(self, MenuItem item) -> MenuItem"""
return _core_.Menu_AppendItem(*args, **kwargs)
- def Break(*args, **kwargs):
- """Break(self)"""
- return _core_.Menu_Break(*args, **kwargs)
-
def InsertItem(*args, **kwargs):
"""InsertItem(self, size_t pos, MenuItem item) -> MenuItem"""
return _core_.Menu_InsertItem(*args, **kwargs)
+ def PrependItem(*args, **kwargs):
+ """PrependItem(self, MenuItem item) -> MenuItem"""
+ return _core_.Menu_PrependItem(*args, **kwargs)
+
+ def Break(*args, **kwargs):
+ """Break(self)"""
+ return _core_.Menu_Break(*args, **kwargs)
+
def Insert(*args, **kwargs):
"""
- Insert(self, size_t pos, int id, String text, String help=EmptyString,
+ Insert(self, size_t pos, int id, String text=EmptyString, String help=EmptyString,
int kind=ITEM_NORMAL) -> MenuItem
"""
return _core_.Menu_Insert(*args, **kwargs)
"""InsertMenu(self, size_t pos, int id, String text, Menu submenu, String help=EmptyString) -> MenuItem"""
return _core_.Menu_InsertMenu(*args, **kwargs)
- def PrependItem(*args, **kwargs):
- """PrependItem(self, MenuItem item) -> MenuItem"""
- return _core_.Menu_PrependItem(*args, **kwargs)
-
def Prepend(*args, **kwargs):
- """Prepend(self, int id, String text, String help=EmptyString, int kind=ITEM_NORMAL) -> MenuItem"""
+ """
+ Prepend(self, int id, String text=EmptyString, String help=EmptyString,
+ int kind=ITEM_NORMAL) -> MenuItem
+ """
return _core_.Menu_Prepend(*args, **kwargs)
def PrependSeparator(*args, **kwargs):
Deletes the C++ object this Python object is a proxy for.
"""
+ args[0].this.own(False)
return _core_.Menu_Destroy(*args, **kwargs)
def DestroyId(*args, **kwargs):
- """
- DestroyId(self, int id) -> bool
-
- Deletes the C++ object this Python object is a proxy for.
- """
+ """DestroyId(self, int id) -> bool"""
return _core_.Menu_DestroyId(*args, **kwargs)
def DestroyItem(*args, **kwargs):
- """
- DestroyItem(self, MenuItem item) -> bool
-
- Deletes the C++ object this Python object is a proxy for.
- """
+ """DestroyItem(self, MenuItem item) -> bool"""
return _core_.Menu_DestroyItem(*args, **kwargs)
def GetMenuItemCount(*args, **kwargs):
"""GetParent(self) -> Menu"""
return _core_.Menu_GetParent(*args, **kwargs)
-
-class MenuPtr(Menu):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Menu
-_core_.Menu_swigregister(MenuPtr)
+ EventHandler = property(GetEventHandler,SetEventHandler,doc="See `GetEventHandler` and `SetEventHandler`")
+ HelpString = property(GetHelpString,SetHelpString,doc="See `GetHelpString` and `SetHelpString`")
+ InvokingWindow = property(GetInvokingWindow,SetInvokingWindow,doc="See `GetInvokingWindow` and `SetInvokingWindow`")
+ MenuBar = property(GetMenuBar,doc="See `GetMenuBar`")
+ MenuItemCount = property(GetMenuItemCount,doc="See `GetMenuItemCount`")
+ MenuItems = property(GetMenuItems,doc="See `GetMenuItems`")
+ Parent = property(GetParent,SetParent,doc="See `GetParent` and `SetParent`")
+ Style = property(GetStyle,doc="See `GetStyle`")
+ Title = property(GetTitle,SetTitle,doc="See `GetTitle` and `SetTitle`")
+_core_.Menu_swigregister(Menu)
DefaultValidator = cvar.DefaultValidator
#---------------------------------------------------------------------------
class MenuBar(Window):
"""Proxy of C++ MenuBar class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMenuBar instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, long style=0) -> MenuBar"""
- newobj = _core_.new_MenuBar(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.MenuBar_swiginit(self,_core_.new_MenuBar(*args, **kwargs))
self._setOORInfo(self)
def Append(*args, **kwargs):
"""Detach(self)"""
return _core_.MenuBar_Detach(*args, **kwargs)
+ def UpdateMenus(*args, **kwargs):
+ """UpdateMenus(self)"""
+ return _core_.MenuBar_UpdateMenus(*args, **kwargs)
+
+ def SetAutoWindowMenu(*args, **kwargs):
+ """SetAutoWindowMenu(bool enable)"""
+ return _core_.MenuBar_SetAutoWindowMenu(*args, **kwargs)
-class MenuBarPtr(MenuBar):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = MenuBar
-_core_.MenuBar_swigregister(MenuBarPtr)
+ SetAutoWindowMenu = staticmethod(SetAutoWindowMenu)
+ def GetAutoWindowMenu(*args, **kwargs):
+ """GetAutoWindowMenu() -> bool"""
+ return _core_.MenuBar_GetAutoWindowMenu(*args, **kwargs)
+
+ GetAutoWindowMenu = staticmethod(GetAutoWindowMenu)
+ def GetMenus(self):
+ """Return a list of (menu, label) items for the menus in the MenuBar. """
+ return [(self.GetMenu(i), self.GetLabelTop(i))
+ for i in range(self.GetMenuCount())]
+
+ def SetMenus(self, items):
+ """Clear and add new menus to the MenuBar from a list of (menu, label) items. """
+ for i in range(self.GetMenuCount()-1, -1, -1):
+ self.Remove(i)
+ for m, l in items:
+ self.Append(m, l)
+
+ Frame = property(GetFrame,doc="See `GetFrame`")
+ Menu = property(GetMenu,doc="See `GetMenu`")
+ MenuCount = property(GetMenuCount,doc="See `GetMenuCount`")
+ Menus = property(GetMenus,SetMenus,doc="See `GetMenus` and `SetMenus`")
+_core_.MenuBar_swigregister(MenuBar)
+
+def MenuBar_SetAutoWindowMenu(*args, **kwargs):
+ """MenuBar_SetAutoWindowMenu(bool enable)"""
+ return _core_.MenuBar_SetAutoWindowMenu(*args, **kwargs)
+
+def MenuBar_GetAutoWindowMenu(*args):
+ """MenuBar_GetAutoWindowMenu() -> bool"""
+ return _core_.MenuBar_GetAutoWindowMenu(*args)
#---------------------------------------------------------------------------
class MenuItem(Object):
"""Proxy of C++ MenuItem class"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxMenuItem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, Menu parentMenu=None, int id=ID_ANY, String text=EmptyString,
String help=EmptyString, int kind=ITEM_NORMAL,
Menu subMenu=None) -> MenuItem
"""
- newobj = _core_.new_MenuItem(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.MenuItem_swiginit(self,_core_.new_MenuItem(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_MenuItem
+ __del__ = lambda self : None;
def GetMenu(*args, **kwargs):
"""GetMenu(self) -> Menu"""
return _core_.MenuItem_GetMenu(*args, **kwargs)
"""SetAccel(self, AcceleratorEntry accel)"""
return _core_.MenuItem_SetAccel(*args, **kwargs)
+ def SetBitmap(*args, **kwargs):
+ """SetBitmap(self, Bitmap bitmap)"""
+ return _core_.MenuItem_SetBitmap(*args, **kwargs)
+
+ def GetBitmap(*args, **kwargs):
+ """GetBitmap(self) -> Bitmap"""
+ return _core_.MenuItem_GetBitmap(*args, **kwargs)
+
def SetFont(*args, **kwargs):
"""SetFont(self, Font font)"""
return _core_.MenuItem_SetFont(*args, **kwargs)
"""ResetOwnerDrawn(self)"""
return _core_.MenuItem_ResetOwnerDrawn(*args, **kwargs)
- def SetBitmap(*args, **kwargs):
- """SetBitmap(self, Bitmap bitmap)"""
- return _core_.MenuItem_SetBitmap(*args, **kwargs)
-
- def GetBitmap(*args, **kwargs):
- """GetBitmap(self) -> Bitmap"""
- return _core_.MenuItem_GetBitmap(*args, **kwargs)
-
-
-class MenuItemPtr(MenuItem):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = MenuItem
-_core_.MenuItem_swigregister(MenuItemPtr)
+ Accel = property(GetAccel,SetAccel,doc="See `GetAccel` and `SetAccel`")
+ BackgroundColour = property(GetBackgroundColour,SetBackgroundColour,doc="See `GetBackgroundColour` and `SetBackgroundColour`")
+ Bitmap = property(GetBitmap,SetBitmap,doc="See `GetBitmap` and `SetBitmap`")
+ DisabledBitmap = property(GetDisabledBitmap,SetDisabledBitmap,doc="See `GetDisabledBitmap` and `SetDisabledBitmap`")
+ Font = property(GetFont,SetFont,doc="See `GetFont` and `SetFont`")
+ Help = property(GetHelp,SetHelp,doc="See `GetHelp` and `SetHelp`")
+ Id = property(GetId,SetId,doc="See `GetId` and `SetId`")
+ Kind = property(GetKind,SetKind,doc="See `GetKind` and `SetKind`")
+ Label = property(GetLabel,doc="See `GetLabel`")
+ MarginWidth = property(GetMarginWidth,SetMarginWidth,doc="See `GetMarginWidth` and `SetMarginWidth`")
+ Menu = property(GetMenu,SetMenu,doc="See `GetMenu` and `SetMenu`")
+ SubMenu = property(GetSubMenu,SetSubMenu,doc="See `GetSubMenu` and `SetSubMenu`")
+ Text = property(GetText,SetText,doc="See `GetText` and `SetText`")
+ TextColour = property(GetTextColour,SetTextColour,doc="See `GetTextColour` and `SetTextColour`")
+_core_.MenuItem_swigregister(MenuItem)
def MenuItem_GetLabelFromText(*args, **kwargs):
- """MenuItem_GetLabelFromText(String text) -> String"""
- return _core_.MenuItem_GetLabelFromText(*args, **kwargs)
+ """MenuItem_GetLabelFromText(String text) -> String"""
+ return _core_.MenuItem_GetLabelFromText(*args, **kwargs)
-def MenuItem_GetDefaultMarginWidth(*args, **kwargs):
- """MenuItem_GetDefaultMarginWidth() -> int"""
- return _core_.MenuItem_GetDefaultMarginWidth(*args, **kwargs)
+def MenuItem_GetDefaultMarginWidth(*args):
+ """MenuItem_GetDefaultMarginWidth() -> int"""
+ return _core_.MenuItem_GetDefaultMarginWidth(*args)
#---------------------------------------------------------------------------
A control is generally a small window which processes user input
and/or displays one or more item of data.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxControl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
+ def __init__(self, *args, **kwargs):
"""
__init__(self, Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0, Validator validator=DefaultValidator,
Create a Control. Normally you should only call this from a subclass'
__init__ as a plain old wx.Control is not very useful.
"""
- newobj = _core_.new_Control(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.Control_swiginit(self,_core_.new_Control(*args, **kwargs))
self._setOORInfo(self)
def Create(*args, **kwargs):
"""
return _core_.Control_Create(*args, **kwargs)
- def Command(*args, **kwargs):
+ def GetAlignment(*args, **kwargs):
"""
- Command(self, CommandEvent event)
-
- Simulates the effect of the user issuing a command to the item.
-
- :see: `wx.CommandEvent`
+ GetAlignment(self) -> int
+ Get the control alignment (left/right/centre, top/bottom/centre)
"""
- return _core_.Control_Command(*args, **kwargs)
+ return _core_.Control_GetAlignment(*args, **kwargs)
- def GetLabel(*args, **kwargs):
+ def GetLabelText(*args, **kwargs):
"""
- GetLabel(self) -> String
+ GetLabelText(self) -> String
- Return a control's text.
+ Get just the text of the label, without mnemonic characters ('&')
"""
- return _core_.Control_GetLabel(*args, **kwargs)
+ return _core_.Control_GetLabelText(*args, **kwargs)
- def SetLabel(*args, **kwargs):
+ def Command(*args, **kwargs):
"""
- SetLabel(self, String label)
+ Command(self, CommandEvent event)
+
+ Simulates the effect of the user issuing a command to the item.
+
+ :see: `wx.CommandEvent`
- Sets the item's text.
"""
- return _core_.Control_SetLabel(*args, **kwargs)
+ return _core_.Control_Command(*args, **kwargs)
def GetClassDefaultAttributes(*args, **kwargs):
"""
return _core_.Control_GetClassDefaultAttributes(*args, **kwargs)
GetClassDefaultAttributes = staticmethod(GetClassDefaultAttributes)
-
-class ControlPtr(Control):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Control
-_core_.Control_swigregister(ControlPtr)
+ Alignment = property(GetAlignment,doc="See `GetAlignment`")
+ LabelText = property(GetLabelText,doc="See `GetLabelText`")
+_core_.Control_swigregister(Control)
ControlNameStr = cvar.ControlNameStr
def PreControl(*args, **kwargs):
Precreate a Control control for 2-phase creation
"""
val = _core_.new_PreControl(*args, **kwargs)
- val.thisown = 1
return val
def Control_GetClassDefaultAttributes(*args, **kwargs):
- """
+ """
Control_GetClassDefaultAttributes(int variant=WINDOW_VARIANT_NORMAL) -> VisualAttributes
Get the default attributes for this class. This is useful if you want
the returned font. See `wx.Window.SetWindowVariant` for more about
this.
"""
- return _core_.Control_GetClassDefaultAttributes(*args, **kwargs)
+ return _core_.Control_GetClassDefaultAttributes(*args, **kwargs)
#---------------------------------------------------------------------------
optionally, client data associated with them.
"""
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxItemContainer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ 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
def Append(*args, **kwargs):
"""
Append(self, String item, PyObject clientData=None) -> int
def Insert(*args, **kwargs):
"""
- Insert(self, String item, int pos, PyObject clientData=None) -> int
+ Insert(self, String item, unsigned int pos, PyObject clientData=None) -> int
Insert an item into the control before the item at the ``pos`` index,
optionally associating some data object with the item.
def Delete(*args, **kwargs):
"""
- Delete(self, int n)
+ Delete(self, unsigned int n)
Deletes the item at the zero-based index 'n' from the control. Note
that it is an error (signalled by a `wx.PyAssertionError` exception if
def GetClientData(*args, **kwargs):
"""
- GetClientData(self, int n) -> PyObject
+ GetClientData(self, unsigned int n) -> PyObject
Returns the client data associated with the given item, (if any.)
"""
def SetClientData(*args, **kwargs):
"""
- SetClientData(self, int n, PyObject clientData)
+ SetClientData(self, unsigned int n, PyObject clientData)
Associate the given client data with the item at position n.
"""
def GetCount(*args, **kwargs):
"""
- GetCount(self) -> int
+ GetCount(self) -> unsigned int
Returns the number of items in the control.
"""
def GetString(*args, **kwargs):
"""
- GetString(self, int n) -> String
+ GetString(self, unsigned int n) -> String
Returns the label of the item with the given index.
"""
def SetString(*args, **kwargs):
"""
- SetString(self, int n, String s)
+ SetString(self, unsigned int n, String s)
Sets the label for the given item.
"""
"""
return _core_.ItemContainer_Select(*args, **kwargs)
-
-class ItemContainerPtr(ItemContainer):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ItemContainer
-_core_.ItemContainer_swigregister(ItemContainerPtr)
+ def GetItems(self):
+ """Return a list of the strings in the control"""
+ return [self.GetString(i) for i in xrange(self.GetCount())]
+
+ def SetItems(self, items):
+ """Clear and set the strings in the control from a list"""
+ self.Clear()
+ for i in items:
+ self.Append(i)
+
+ Count = property(GetCount,doc="See `GetCount`")
+ Items = property(GetItems,SetItems,doc="See `GetItems` and `SetItems`")
+ Selection = property(GetSelection,SetSelection,doc="See `GetSelection` and `SetSelection`")
+ StringSelection = property(GetStringSelection,SetStringSelection,doc="See `GetStringSelection` and `SetStringSelection`")
+ Strings = property(GetStrings,doc="See `GetStrings`")
+_core_.ItemContainer_swigregister(ItemContainer)
#---------------------------------------------------------------------------
wx.Control class, and is used for the base class of various controls
that have items.
"""
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxControlWithItems instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
-
-class ControlWithItemsPtr(ControlWithItems):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = ControlWithItems
-_core_.ControlWithItems_swigregister(ControlWithItemsPtr)
+ 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
+_core_.ControlWithItems_swigregister(ControlWithItems)
#---------------------------------------------------------------------------
class SizerItem(Object):
"""
The wx.SizerItem class is used to track the position, size and other
- attributes of each item managed by a `wx.Sizer`. In normal usage user
- code should never need to deal directly with a wx.SizerItem, but
- custom classes derived from `wx.PySizer` will probably need to use the
- collection of wx.SizerItems held by wx.Sizer when calculating layout.
+ attributes of each item managed by a `wx.Sizer`. It is not usually
+ necessary to use this class because the sizer elements can also be
+ identified by their positions or window or sizer references but
+ sometimes it may be more convenient to use wx.SizerItem directly.
+ Also, custom classes derived from `wx.PySizer` will probably need to
+ use the collection of wx.SizerItems held by wx.Sizer when calculating
+ layout.
:see: `wx.Sizer`, `wx.GBSizerItem`
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxSizerItem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> SizerItem
:see: `wx.SizerItemSpacer`, `wx.SizerItemWindow`, `wx.SizerItemSizer`
"""
- newobj = _core_.new_SizerItem(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.SizerItem_swiginit(self,_core_.new_SizerItem(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_SizerItem
+ __del__ = lambda self : None;
def DeleteWindows(*args, **kwargs):
"""
DeleteWindows(self)
"""
return _core_.SizerItem_GetUserData(*args, **kwargs)
+ def SetUserData(*args, **kwargs):
+ """
+ SetUserData(self, PyObject userData)
+
+ Associate a Python object with this sizer item.
+ """
+ return _core_.SizerItem_SetUserData(*args, **kwargs)
-class SizerItemPtr(SizerItem):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = SizerItem
-_core_.SizerItem_swigregister(SizerItemPtr)
+ Border = property(GetBorder,SetBorder,doc="See `GetBorder` and `SetBorder`")
+ Flag = property(GetFlag,SetFlag,doc="See `GetFlag` and `SetFlag`")
+ MinSize = property(GetMinSize,doc="See `GetMinSize`")
+ MinSizeWithBorder = property(GetMinSizeWithBorder,doc="See `GetMinSizeWithBorder`")
+ Position = property(GetPosition,doc="See `GetPosition`")
+ Proportion = property(GetProportion,SetProportion,doc="See `GetProportion` and `SetProportion`")
+ Ratio = property(GetRatio,SetRatio,doc="See `GetRatio` and `SetRatio`")
+ Rect = property(GetRect,doc="See `GetRect`")
+ Size = property(GetSize,doc="See `GetSize`")
+ Sizer = property(GetSizer,SetSizer,doc="See `GetSizer` and `SetSizer`")
+ Spacer = property(GetSpacer,SetSpacer,doc="See `GetSpacer` and `SetSpacer`")
+ UserData = property(GetUserData,SetUserData,doc="See `GetUserData` and `SetUserData`")
+ Window = property(GetWindow,SetWindow,doc="See `GetWindow` and `SetWindow`")
+_core_.SizerItem_swigregister(SizerItem)
def SizerItemWindow(*args, **kwargs):
"""
Constructs a `wx.SizerItem` for tracking a window.
"""
val = _core_.new_SizerItemWindow(*args, **kwargs)
- val.thisown = 1
return val
def SizerItemSpacer(*args, **kwargs):
Constructs a `wx.SizerItem` for tracking a spacer.
"""
val = _core_.new_SizerItemSpacer(*args, **kwargs)
- val.thisown = 1
return val
def SizerItemSizer(*args, **kwargs):
Constructs a `wx.SizerItem` for tracking a subsizer
"""
val = _core_.new_SizerItemSizer(*args, **kwargs)
- val.thisown = 1
return val
class Sizer(Object):
wx.Sizer is the abstract base class used for laying out subwindows in
a window. You cannot use wx.Sizer directly; instead, you will have to
use one of the sizer classes derived from it such as `wx.BoxSizer`,
- `wx.StaticBoxSizer`, `wx.NotebookSizer`, `wx.GridSizer`, `wx.FlexGridSizer`
- and `wx.GridBagSizer`.
+ `wx.StaticBoxSizer`, `wx.GridSizer`, `wx.FlexGridSizer` and
+ `wx.GridBagSizer`.
The concept implemented by sizers in wxWidgets is closely related to
layout tools in other GUI toolkits, such as Java's AWT, the GTK
more space than on Windows, then the initial size of a dialog using a
sizer will automatically be bigger on Mac than on Windows.
"""
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ 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__ = _core_.delete_Sizer
+ __del__ = lambda self : None;
def _setOORInfo(*args, **kwargs):
"""_setOORInfo(self, PyObject _self)"""
return _core_.Sizer__setOORInfo(*args, **kwargs)
Returns the `wx.SizerItem` which holds the *item* given. The *item*
parameter can be either a window, a sizer, or the zero-based index of
- the item to be detached.
+ the item to be found.
"""
return _core_.Sizer_GetItem(*args, **kwargs)
"""_SetItemMinSize(self, PyObject item, Size size)"""
return _core_.Sizer__SetItemMinSize(*args, **kwargs)
+ def _ReplaceWin(*args, **kwargs):
+ """_ReplaceWin(self, Window oldwin, Window newwin, bool recursive=False) -> bool"""
+ return _core_.Sizer__ReplaceWin(*args, **kwargs)
+
+ def _ReplaceSizer(*args, **kwargs):
+ """_ReplaceSizer(self, Sizer oldsz, Sizer newsz, bool recursive=False) -> bool"""
+ return _core_.Sizer__ReplaceSizer(*args, **kwargs)
+
+ def _ReplaceItem(*args, **kwargs):
+ """_ReplaceItem(self, size_t index, SizerItem newitem) -> bool"""
+ return _core_.Sizer__ReplaceItem(*args, **kwargs)
+
+ def Replace(self, olditem, item, recursive=False):
+ """
+ Detaches the given ``olditem`` from the sizer and replaces it with
+ ``item`` which can be a window, sizer, or `wx.SizerItem`. The
+ detached child is destroyed only if it is not a window, (because
+ windows are owned by their parent, not the sizer.) The
+ ``recursive`` parameter can be used to search for the given
+ element recursivly in subsizers.
+
+ This method does not cause any layout or resizing to take place,
+ call `Layout` to do so.
+
+ Returns ``True`` if the child item was found and removed.
+ """
+ if isinstance(olditem, wx.Window):
+ return self._ReplaceWin(olditem, item, recursive)
+ elif isinstnace(olditem, wx.Sizer):
+ return self._ReplaceSizer(olditem, item, recursive)
+ elif isinstnace(olditem, int):
+ return self._ReplaceItem(olditem, item)
+ else:
+ raise TypeError("Expected Window, Sizer, or integer for first parameter.")
+
+ def SetContainingWindow(*args, **kwargs):
+ """
+ SetContainingWindow(self, Window window)
+
+ Set (or unset) the window this sizer is used in.
+ """
+ return _core_.Sizer_SetContainingWindow(*args, **kwargs)
+
+ def GetContainingWindow(*args, **kwargs):
+ """
+ GetContainingWindow(self) -> Window
+
+ Get the window this sizer is used in.
+ """
+ return _core_.Sizer_GetContainingWindow(*args, **kwargs)
+
def SetItemMinSize(self, item, *args):
"""
SetItemMinSize(self, item, Size size)
item = (item, )
self.Add(*item)
+ def AddSpacer(self, *args, **kw):
+ """AddSpacer(int size) --> SizerItem
+
+ Add a spacer that is (size,size) pixels.
+ """
+ if args and type(args[0]) == int:
+ return self.Add( (args[0],args[0] ), 0)
+ else: # otherwise stay compatible with old AddSpacer
+ return self.Add(*args, **kw)
+ def PrependSpacer(self, *args, **kw):
+ """PrependSpacer(int size) --> SizerItem
+
+ Prepend a spacer that is (size, size) pixels."""
+ if args and type(args[0]) == int:
+ return self.Prepend( (args[0],args[0] ), 0)
+ else: # otherwise stay compatible with old PrependSpacer
+ return self.Prepend(*args, **kw)
+ def InsertSpacer(self, index, *args, **kw):
+ """InsertSpacer(int index, int size) --> SizerItem
+
+ Insert a spacer at position index that is (size, size) pixels."""
+ if args and type(args[0]) == int:
+ return self.Insert( index, (args[0],args[0] ), 0)
+ else: # otherwise stay compatible with old InsertSpacer
+ return self.Insert(index, *args, **kw)
+
+
+ def AddStretchSpacer(self, prop=1):
+ """AddStretchSpacer(int prop=1) --> SizerItem
+
+ Add a stretchable spacer."""
+ return self.Add((0,0), prop)
+ def PrependStretchSpacer(self, prop=1):
+ """PrependStretchSpacer(int prop=1) --> SizerItem
+
+ Prepend a stretchable spacer."""
+ return self.Prepend((0,0), prop)
+ def InsertStretchSpacer(self, index, prop=1):
+ """InsertStretchSpacer(int index, int prop=1) --> SizerItem
+
+ Insert a stretchable spacer."""
+ return self.Insert(index, (0,0), prop)
+
+
# for backwards compatibility only, please do not use in new code
def AddWindow(self, *args, **kw):
"""Compatibility alias for `Add`."""
def AddSizer(self, *args, **kw):
"""Compatibility alias for `Add`."""
return self.Add(*args, **kw)
- def AddSpacer(self, *args, **kw):
- """Compatibility alias for `Add`."""
- return self.Add(*args, **kw)
def PrependWindow(self, *args, **kw):
"""Compatibility alias for `Prepend`."""
def PrependSizer(self, *args, **kw):
"""Compatibility alias for `Prepend`."""
return self.Prepend(*args, **kw)
- def PrependSpacer(self, *args, **kw):
- """Compatibility alias for `Prepend`."""
- return self.Prepend(*args, **kw)
def InsertWindow(self, *args, **kw):
"""Compatibility alias for `Insert`."""
def InsertSizer(self, *args, **kw):
"""Compatibility alias for `Insert`."""
return self.Insert(*args, **kw)
- def InsertSpacer(self, *args, **kw):
- """Compatibility alias for `Insert`."""
- return self.Insert(*args, **kw)
def RemoveWindow(self, *args, **kw):
"""Compatibility alias for `Remove`."""
"""
IsShown(self, item)
- Determines if the item is currently shown. sizer. To make a sizer
+ Determines if the item is currently shown. To make a sizer
item disappear or reappear, use Show followed by `Layout`. The *item*
parameter can be either a window, a sizer, or the zero-based index of
the item.
"""
return _core_.Sizer_ShowItems(*args, **kwargs)
-
-class SizerPtr(Sizer):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = Sizer
-_core_.Sizer_swigregister(SizerPtr)
+ Children = property(GetChildren,doc="See `GetChildren`")
+ ContainingWindow = property(GetContainingWindow,SetContainingWindow,doc="See `GetContainingWindow` and `SetContainingWindow`")
+ MinSize = property(GetMinSize,SetMinSize,doc="See `GetMinSize` and `SetMinSize`")
+ Position = property(GetPosition,doc="See `GetPosition`")
+ Size = property(GetSize,doc="See `GetSize`")
+_core_.Sizer_swigregister(Sizer)
class PySizer(Sizer):
"""
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxPySizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> PySizer
Creates a wx.PySizer. Must be called from the __init__ in the derived
class.
"""
- newobj = _core_.new_PySizer(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.PySizer_swiginit(self,_core_.new_PySizer(*args, **kwargs))
self._setCallbackInfo(self, PySizer);self._setOORInfo(self)
def _setCallbackInfo(*args, **kwargs):
"""_setCallbackInfo(self, PyObject self, PyObject _class)"""
return _core_.PySizer__setCallbackInfo(*args, **kwargs)
-
-class PySizerPtr(PySizer):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = PySizer
-_core_.PySizer_swigregister(PySizerPtr)
+_core_.PySizer_swigregister(PySizer)
#---------------------------------------------------------------------------
its items in a simple row or column, depending on the orientation
parameter passed to the constructor.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxBoxSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, int orient=HORIZONTAL) -> BoxSizer
or ``wx.HORIZONTAL`` for creating either a column sizer or a row
sizer.
"""
- newobj = _core_.new_BoxSizer(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.BoxSizer_swiginit(self,_core_.new_BoxSizer(*args, **kwargs))
self._setOORInfo(self)
def GetOrientation(*args, **kwargs):
"""
return _core_.BoxSizer_SetOrientation(*args, **kwargs)
-
-class BoxSizerPtr(BoxSizer):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = BoxSizer
-_core_.BoxSizer_swigregister(BoxSizerPtr)
+ Orientation = property(GetOrientation,SetOrientation,doc="See `GetOrientation` and `SetOrientation`")
+_core_.BoxSizer_swigregister(BoxSizer)
#---------------------------------------------------------------------------
manages. Note that this static box must be created separately and
passed to the sizer constructor.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxStaticBoxSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, StaticBox box, int orient=HORIZONTAL) -> StaticBoxSizer
*orient* as parameters - orient can be either of ``wx.VERTICAL`` or
``wx.HORIZONTAL``.
"""
- newobj = _core_.new_StaticBoxSizer(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.StaticBoxSizer_swiginit(self,_core_.new_StaticBoxSizer(*args, **kwargs))
self._setOORInfo(self)
def GetStaticBox(*args, **kwargs):
"""
return _core_.StaticBoxSizer_GetStaticBox(*args, **kwargs)
-
-class StaticBoxSizerPtr(StaticBoxSizer):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = StaticBoxSizer
-_core_.StaticBoxSizer_swigregister(StaticBoxSizerPtr)
+ StaticBox = property(GetStaticBox,doc="See `GetStaticBox`")
+_core_.StaticBoxSizer_swigregister(StaticBoxSizer)
#---------------------------------------------------------------------------
then use the `wx.GridBagSizer`.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxGridSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, int rows=1, int cols=0, int vgap=0, int hgap=0) -> GridSizer
the sizer, thus making the sizer grow dynamically. *vgap* and *hgap*
define extra space between all children.
"""
- newobj = _core_.new_GridSizer(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.GridSizer_swiginit(self,_core_.new_GridSizer(*args, **kwargs))
self._setOORInfo(self)
def SetCols(*args, **kwargs):
"""
return _core_.GridSizer_GetHGap(*args, **kwargs)
+ def CalcRowsCols(self):
+ """
+ CalcRowsCols() -> (rows, cols)
+
+ Calculates how many rows and columns will be in the sizer based
+ on the current number of items and also the rows, cols specified
+ in the constructor.
+ """
+ nitems = len(self.GetChildren())
+ rows = self.GetRows()
+ cols = self.GetCols()
+ assert rows != 0 or cols != 0, "Grid sizer must have either rows or columns fixed"
+ if cols != 0:
+ rows = (nitems + cols - 1) / cols
+ elif rows != 0:
+ cols = (nitems + rows - 1) / rows
+ return (rows, cols)
-class GridSizerPtr(GridSizer):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = GridSizer
-_core_.GridSizer_swigregister(GridSizerPtr)
+ Cols = property(GetCols,SetCols,doc="See `GetCols` and `SetCols`")
+ HGap = property(GetHGap,SetHGap,doc="See `GetHGap` and `SetHGap`")
+ Rows = property(GetRows,SetRows,doc="See `GetRows` and `SetRows`")
+ VGap = property(GetVGap,SetVGap,doc="See `GetVGap` and `SetVGap`")
+_core_.GridSizer_swigregister(GridSizer)
#---------------------------------------------------------------------------
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxFlexGridSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, int rows=1, int cols=0, int vgap=0, int hgap=0) -> FlexGridSizer
the sizer, thus making the sizer grow dynamically. *vgap* and *hgap*
define extra space between all children.
"""
- newobj = _core_.new_FlexGridSizer(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.FlexGridSizer_swiginit(self,_core_.new_FlexGridSizer(*args, **kwargs))
self._setOORInfo(self)
def AddGrowableRow(*args, **kwargs):
========================== =================================================
Note that this method does not trigger relayout.
-
-
"""
return _core_.FlexGridSizer_SetNonFlexibleGrowMode(*args, **kwargs)
"""
return _core_.FlexGridSizer_GetColWidths(*args, **kwargs)
-
-class FlexGridSizerPtr(FlexGridSizer):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = FlexGridSizer
-_core_.FlexGridSizer_swigregister(FlexGridSizerPtr)
+ ColWidths = property(GetColWidths,doc="See `GetColWidths`")
+ FlexibleDirection = property(GetFlexibleDirection,SetFlexibleDirection,doc="See `GetFlexibleDirection` and `SetFlexibleDirection`")
+ NonFlexibleGrowMode = property(GetNonFlexibleGrowMode,SetNonFlexibleGrowMode,doc="See `GetNonFlexibleGrowMode` and `SetNonFlexibleGrowMode`")
+ RowHeights = property(GetRowHeights,doc="See `GetRowHeights`")
+_core_.FlexGridSizer_swigregister(FlexGridSizer)
class StdDialogButtonSizer(BoxSizer):
"""
will take care of the rest.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxStdDialogButtonSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> StdDialogButtonSizer"""
- newobj = _core_.new_StdDialogButtonSizer(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.StdDialogButtonSizer_swiginit(self,_core_.new_StdDialogButtonSizer(*args, **kwargs))
def AddButton(*args, **kwargs):
"""
AddButton(self, wxButton button)
"""GetHelpButton(self) -> wxButton"""
return _core_.StdDialogButtonSizer_GetHelpButton(*args, **kwargs)
-
-class StdDialogButtonSizerPtr(StdDialogButtonSizer):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = StdDialogButtonSizer
-_core_.StdDialogButtonSizer_swigregister(StdDialogButtonSizerPtr)
+ AffirmativeButton = property(GetAffirmativeButton,SetAffirmativeButton,doc="See `GetAffirmativeButton` and `SetAffirmativeButton`")
+ ApplyButton = property(GetApplyButton,doc="See `GetApplyButton`")
+ CancelButton = property(GetCancelButton,SetCancelButton,doc="See `GetCancelButton` and `SetCancelButton`")
+ HelpButton = property(GetHelpButton,doc="See `GetHelpButton`")
+ NegativeButton = property(GetNegativeButton,SetNegativeButton,doc="See `GetNegativeButton` and `SetNegativeButton`")
+_core_.StdDialogButtonSizer_swigregister(StdDialogButtonSizer)
#---------------------------------------------------------------------------
integers to a wx.GBPosition, so you can use the more pythonic
representation of the position nearly transparently in Python code.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxGBPosition instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, int row=0, int col=0) -> GBPosition
integers to a wx.GBPosition, so you can use the more pythonic
representation of the position nearly transparently in Python code.
"""
- newobj = _core_.new_GBPosition(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.GBPosition_swiginit(self,_core_.new_GBPosition(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_GBPosition
+ __del__ = lambda self : None;
def GetRow(*args, **kwargs):
"""GetRow(self) -> int"""
return _core_.GBPosition_GetRow(*args, **kwargs)
return _core_.GBPosition_SetCol(*args, **kwargs)
def __eq__(*args, **kwargs):
- """__eq__(self, GBPosition other) -> bool"""
+ """
+ __eq__(self, PyObject other) -> bool
+
+ Compare GBPosition for equality.
+ """
return _core_.GBPosition___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
- """__ne__(self, GBPosition other) -> bool"""
+ """
+ __ne__(self, PyObject other) -> bool
+
+ Compare GBPosition for inequality.
+ """
return _core_.GBPosition___ne__(*args, **kwargs)
def Set(*args, **kwargs):
row = property(GetRow, SetRow)
col = property(GetCol, SetCol)
-
-class GBPositionPtr(GBPosition):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = GBPosition
-_core_.GBPosition_swigregister(GBPositionPtr)
+_core_.GBPosition_swigregister(GBPosition)
class GBSpan(object):
"""
nearly transparently in Python code.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxGBSpan instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, int rowspan=1, int colspan=1) -> GBSpan
colspan. The default is (1,1). (Meaning that the item occupies one
cell in each direction.
"""
- newobj = _core_.new_GBSpan(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.GBSpan_swiginit(self,_core_.new_GBSpan(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_GBSpan
+ __del__ = lambda self : None;
def GetRowspan(*args, **kwargs):
"""GetRowspan(self) -> int"""
return _core_.GBSpan_GetRowspan(*args, **kwargs)
return _core_.GBSpan_SetColspan(*args, **kwargs)
def __eq__(*args, **kwargs):
- """__eq__(self, GBSpan other) -> bool"""
+ """
+ __eq__(self, PyObject other) -> bool
+
+ Compare wxGBSpan for equality.
+ """
return _core_.GBSpan___eq__(*args, **kwargs)
def __ne__(*args, **kwargs):
- """__ne__(self, GBSpan other) -> bool"""
+ """
+ __ne__(self, PyObject other) -> bool
+
+ Compare GBSpan for inequality.
+ """
return _core_.GBSpan___ne__(*args, **kwargs)
def Set(*args, **kwargs):
rowspan = property(GetRowspan, SetRowspan)
colspan = property(GetColspan, SetColspan)
-
-class GBSpanPtr(GBSpan):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = GBSpan
-_core_.GBSpan_swigregister(GBSpanPtr)
+_core_.GBSpan_swigregister(GBSpan)
class GBSizerItem(SizerItem):
"""
and how many rows or columns it spans.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxGBSizerItem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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) -> GBSizerItem
You will probably never need to create a wx.GBSizerItem directly as they
are created automatically when the sizer's Add method is called.
"""
- newobj = _core_.new_GBSizerItem(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.GBSizerItem_swiginit(self,_core_.new_GBSizerItem(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_GBSizerItem
+ __del__ = lambda self : None;
def GetPos(*args, **kwargs):
"""
GetPos(self) -> GBPosition
"""
return _core_.GBSizerItem_SetGBSizer(*args, **kwargs)
-
-class GBSizerItemPtr(GBSizerItem):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = GBSizerItem
-_core_.GBSizerItem_swigregister(GBSizerItemPtr)
+ EndPos = property(GetEndPos,doc="See `GetEndPos`")
+ GBSizer = property(GetGBSizer,SetGBSizer,doc="See `GetGBSizer` and `SetGBSizer`")
+ Pos = property(GetPos,SetPos,doc="See `GetPos` and `SetPos`")
+ Span = property(GetSpan,SetSpan,doc="See `GetSpan` and `SetSpan`")
+_core_.GBSizerItem_swigregister(GBSizerItem)
DefaultSpan = cvar.DefaultSpan
def GBSizerItemWindow(*args, **kwargs):
Construct a `wx.GBSizerItem` for a window.
"""
val = _core_.new_GBSizerItemWindow(*args, **kwargs)
- val.thisown = 1
return val
def GBSizerItemSizer(*args, **kwargs):
Construct a `wx.GBSizerItem` for a sizer
"""
val = _core_.new_GBSizerItemSizer(*args, **kwargs)
- val.thisown = 1
return val
def GBSizerItemSpacer(*args, **kwargs):
Construct a `wx.GBSizerItem` for a spacer.
"""
val = _core_.new_GBSizerItemSpacer(*args, **kwargs)
- val.thisown = 1
return val
class GridBagSizer(FlexGridSizer):
positioned at, adjusted for spanning.
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxGridBagSizer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
- def __init__(self, *args, **kwargs):
+ 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, int vgap=0, int hgap=0) -> GridBagSizer
Constructor, with optional parameters to specify the gap between the
rows and columns.
"""
- newobj = _core_.new_GridBagSizer(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.GridBagSizer_swiginit(self,_core_.new_GridBagSizer(*args, **kwargs))
self._setOORInfo(self)
def Add(*args, **kwargs):
"""
return _core_.GridBagSizer_CheckForIntersectionPos(*args, **kwargs)
-
-class GridBagSizerPtr(GridBagSizer):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = GridBagSizer
-_core_.GridBagSizer_swigregister(GridBagSizerPtr)
+_core_.GridBagSizer_swigregister(GridBagSizer)
#---------------------------------------------------------------------------
`wx.LayoutConstraints` instance and use the individual contstraints
that it contains.
"""
- def __init__(self): raise RuntimeError, "No constructor defined"
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxIndividualLayoutConstraint instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ 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
def Set(*args, **kwargs):
"""
Set(self, int rel, Window otherW, int otherE, int val=0, int marg=wxLAYOUT_DEFAULT_MARGIN)
"""
return _core_.IndividualLayoutConstraint_GetEdge(*args, **kwargs)
-
-class IndividualLayoutConstraintPtr(IndividualLayoutConstraint):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = IndividualLayoutConstraint
-_core_.IndividualLayoutConstraint_swigregister(IndividualLayoutConstraintPtr)
+ Done = property(GetDone,SetDone,doc="See `GetDone` and `SetDone`")
+ Margin = property(GetMargin,SetMargin,doc="See `GetMargin` and `SetMargin`")
+ MyEdge = property(GetMyEdge,doc="See `GetMyEdge`")
+ OtherEdge = property(GetOtherEdge,doc="See `GetOtherEdge`")
+ OtherWindow = property(GetOtherWindow,doc="See `GetOtherWindow`")
+ Percent = property(GetPercent,doc="See `GetPercent`")
+ Relationship = property(GetRelationship,SetRelationship,doc="See `GetRelationship` and `SetRelationship`")
+ Value = property(GetValue,SetValue,doc="See `GetValue` and `SetValue`")
+_core_.IndividualLayoutConstraint_swigregister(IndividualLayoutConstraint)
class LayoutConstraints(Object):
"""
:see: `wx.IndividualLayoutConstraint`, `wx.Window.SetConstraints`
"""
- def __repr__(self):
- return "<%s.%s; proxy of C++ wxLayoutConstraints instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
+ thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
+ __repr__ = _swig_repr
left = property(_core_.LayoutConstraints_left_get)
top = property(_core_.LayoutConstraints_top_get)
right = property(_core_.LayoutConstraints_right_get)
height = property(_core_.LayoutConstraints_height_get)
centreX = property(_core_.LayoutConstraints_centreX_get)
centreY = property(_core_.LayoutConstraints_centreY_get)
- def __init__(self, *args, **kwargs):
+ def __init__(self, *args, **kwargs):
"""__init__(self) -> LayoutConstraints"""
- newobj = _core_.new_LayoutConstraints(*args, **kwargs)
- self.this = newobj.this
- self.thisown = 1
- del newobj.thisown
+ _core_.LayoutConstraints_swiginit(self,_core_.new_LayoutConstraints(*args, **kwargs))
+ __swig_destroy__ = _core_.delete_LayoutConstraints
+ __del__ = lambda self : None;
def SatisfyConstraints(*args, **kwargs):
"""SatisfyConstraints(Window win) -> (areSatisfied, noChanges)"""
return _core_.LayoutConstraints_SatisfyConstraints(*args, **kwargs)
"""AreSatisfied(self) -> bool"""
return _core_.LayoutConstraints_AreSatisfied(*args, **kwargs)
-
-class LayoutConstraintsPtr(LayoutConstraints):
- def __init__(self, this):
- self.this = this
- if not hasattr(self,"thisown"): self.thisown = 0
- self.__class__ = LayoutConstraints
-_core_.LayoutConstraints_swigregister(LayoutConstraintsPtr)
+_core_.LayoutConstraints_swigregister(LayoutConstraints)
#----------------------------------------------------------------------------
method calls from non-GUI threads. Any extra positional or
keyword args are passed on to the callable when it is called.
- :see: `wx.FutureCall`
+ :see: `wx.CallLater`
"""
app = wx.GetApp()
assert app is not None, 'No wx.App created yet'
#----------------------------------------------------------------------------
-class FutureCall:
+class CallLater:
"""
A convenience class for `wx.Timer`, that calls the given callable
object once after the given amount of milliseconds, passing any
then there is no need to hold a reference to this object. It will
hold a reference to itself while the timer is running (the timer
has a reference to self.Notify) but the cycle will be broken when
- the timer completes, automatically cleaning up the wx.FutureCall
+ the timer completes, automatically cleaning up the wx.CallLater
object.
:see: `wx.CallAfter`
# if it wasn't restarted, then cleanup
wx.CallAfter(self.Stop)
+ Interval = property(GetInterval)
+ Result = property(GetResult)
+class FutureCall(CallLater):
+ """A compatibility alias for `CallLater`."""
+
#----------------------------------------------------------------------------
# Control which items in this module should be documented by epydoc.
# We allow only classes and functions, which will help reduce the size
class __DocFilter:
"""
A filter for epydoc that only allows non-Ptr classes and
- fucntions, in order to reduce the clutter in the API docs.
+ functions, in order to reduce the clutter in the API docs.
"""
def __init__(self, globals):
self._globals = globals
def __call__(self, name):
import types
obj = self._globals.get(name, None)
+
+ # only document classes and function
if type(obj) not in [type, types.ClassType, types.FunctionType, types.BuiltinFunctionType]:
return False
- if name.startswith('_') or name.endswith('Ptr') or name.startswith('EVT'):
+
+ # skip other things that are private or will be documented as part of somethign else
+ if name.startswith('_') or name.startswith('EVT') or name.endswith('_swigregister') or name.endswith('Ptr') :
return False
+
+ # skip functions that are duplicates of static functions in a class
+ if name.find('_') != -1:
+ cls = self._globals.get(name.split('_')[0], None)
+ methname = name.split('_')[1]
+ if hasattr(cls, methname) and type(getattr(cls, methname)) is types.FunctionType:
+ return False
+
return True
#----------------------------------------------------------------------------
from _controls import *
from _misc import *
-
-# Fixup the stock objects since they can't be used yet. (They will be
-# restored in wx.PyApp.OnInit.)
-_core_._wxPyFixStockObjects()
-
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
+