diff --git a/wxPython/docs/xml/wxPython-metadata.xml b/wxPython/docs/xml/wxPython-metadata.xml new file mode 100644 index 0000000000..8b17a3efd3 --- /dev/null +++ b/wxPython/docs/xml/wxPython-metadata.xml @@ -0,0 +1,35562 @@ + + + + +#// Give a reference to the dictionary of this module to the C++ extension +#// code. +_core._wxPySetDictionary(vars()) + +#// A little trick to make 'wx' be a reference to this module so wx.Names can +#// be used here. +import sys as _sys +wx = _sys.modules[__name__] + + +#--------------------------------------------------------------------------- + + + The base class for most wx objects, although in wxPython not +much functionality is needed nor exposed. + + GetClassName() -> String + Returns the class name of the C++ object using wxRTTI. + + + Destroy() + Deletes the C++ object this Python object is a proxy for. + + + +#--------------------------------------------------------------------------- + + +#--------------------------------------------------------------------------- + + + 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 expected a (width,height) tuple can be used +instead. + + __init__(int w=0, int h=0) -> Size + Creates a size object. + + + + + + + __del__() + + + + + __eq__(Size sz) -> bool + Test for equality of wx.Size objects. + + + + + + __ne__(Size sz) -> bool + Test for inequality. + + + + + + __add__(Size sz) -> Size + Add sz's proprties to this and return the result. + + + + + + __sub__(Size sz) -> Size + Subtract sz's properties from this and return the result. + + + + + + IncTo(Size sz) + Increments this object so that both of its dimensions are not less +than the corresponding dimensions of the size. + + + + + + DecTo(Size sz) + Decrements this object so that both of its dimensions are not greater +than the corresponding dimensions of the size. + + + + + + Set(int w, int h) + Set both width and height. + + + + + + + SetWidth(int w) + + + + + + SetHeight(int h) + + + + + + GetWidth() -> int + + + GetHeight() -> int + + + Get() -> (width,height) + Returns the width and height properties as a tuple. + + + +#--------------------------------------------------------------------------- + + + A data structure for representing a point or position with floating point x +and y properties. In wxPython most places that expect a wx.RealPoint can also +accept a (x,y) tuple. + + __init__(double x=0.0, double y=0.0) -> RealPoint + Create a wx.RealPoint object + + + + + + + __del__() + + + + + __eq__(RealPoint pt) -> bool + Test for equality of wx.RealPoint objects. + + + + + + __ne__(RealPoint pt) -> bool + Test for inequality of wx.RealPoint objects. + + + + + + __add__(RealPoint pt) -> RealPoint + Add pt's proprties to this and return the result. + + + + + + __sub__(RealPoint pt) -> RealPoint + Subtract pt's proprties from this and return the result + + + + + + Set(double x, double y) + Set both the x and y properties + + + + + + + Get() -> (x,y) + Return the x and y properties as a tuple. + + + +#--------------------------------------------------------------------------- + + + A data structure for representing a point or position with integer x and y +properties. Most places in wxPython that expect a wx.Point can also accept a +(x,y) tuple. + + __init__(int x=0, int y=0) -> Point + Create a wx.Point object + + + + + + + __del__() + + + + + __eq__(Point pt) -> bool + Test for equality of wx.Point objects. + + + + + + __ne__(Point pt) -> bool + Test for inequality of wx.Point objects. + + + + + + __add__(Point pt) -> Point + Add pt's proprties to this and return the result. + + + + + + __sub__(Point pt) -> Point + Subtract pt's proprties from this and return the result + + + + + + __iadd__(Point pt) -> Point + Add pt to this object. + + + + + + __isub__(Point pt) -> Point + Subtract pt from this object. + + + + + + Set(long x, long y) + Set both the x and y properties + + + + + + + Get() -> (x,y) + Return the x and y properties as a tuple. + + + +#--------------------------------------------------------------------------- + + + A class for representing and manipulating rectangles. It has x, y, width and +height properties. In wxPython most palces that expect a wx.Rect can also +accept a (x,y,width,height) tuple. + + __init__(int x=0, int y=0, int width=0, int height=0) -> Rect + Create a new Rect object. + + + + + + + + + RectPP(Point topLeft, Point bottomRight) -> Rect + Create a new Rect object from Points representing two corners. + + + + + + + RectPS(Point pos, Size size) -> Rect + Create a new Rect from a position and size. + + + + + + + __del__() + + + GetX() -> int + + + SetX(int x) + + + + + + GetY() -> int + + + SetY(int y) + + + + + + GetWidth() -> int + + + SetWidth(int w) + + + + + + GetHeight() -> int + + + SetHeight(int h) + + + + + + GetPosition() -> Point + + + SetPosition(Point p) + + + + + + GetSize() -> Size + + + SetSize(Size s) + + + + + + GetTopLeft() -> Point + + + SetTopLeft(Point p) + + + + + + GetBottomRight() -> Point + + + SetBottomRight(Point p) + + + + + + GetLeft() -> int + + + GetTop() -> int + + + GetBottom() -> int + + + GetRight() -> int + + + SetLeft(int left) + + + + + + SetRight(int right) + + + + + + SetTop(int top) + + + + + + SetBottom(int bottom) + + + + + + Inflate(int dx, int dy) -> Rect + Increase the rectangle size by dx in x direction and dy in y direction. Both +(or one of) parameters may be negative to decrease the rectangle size. + + + + + + + Deflate(int dx, int dy) -> Rect + Decrease the rectangle size by dx in x direction and dy in y direction. Both +(or one of) parameters may be negative to increase the rectngle size. This +method is the opposite of Inflate. + + + + + + + OffsetXY(int dx, int dy) + Moves the rectangle by the specified offset. If dx is positive, the rectangle +is moved to the right, if dy is positive, it is moved to the bottom, otherwise +it is moved to the left or top respectively. + + + + + + + Offset(Point pt) + Same as OffsetXY but uses dx,dy from Point + + + + + + Intersect(Rect rect) -> Rect + Return the intersectsion of this rectangle and rect. + + + + + + __add__(Rect rect) -> Rect + Add the properties of rect to this rectangle and return the result. + + + + + + __iadd__(Rect rect) -> Rect + Add the properties of rect to this rectangle, updating this rectangle. + + + + + + __eq__(Rect rect) -> bool + Test for equality. + + + + + + __ne__(Rect rect) -> bool + Test for inequality. + + + + + + InsideXY(int x, int y) -> bool + Return True if the point is (not strcitly) inside the rect. + + + + + + + Inside(Point pt) -> bool + Return True if the point is (not strcitly) inside the rect. + + + + + + Intersects(Rect rect) -> bool + Returns True if the rectangles have a non empty intersection. + + + + + + + + + + Set(int x=0, int y=0, int width=0, int height=0) + Set all rectangle properties. + + + + + + + + + Get() -> (x,y,width,height) + Return the rectangle properties as a tuple. + + + + IntersectRect(Rect r1, Rect r2) -> Rect + Calculate and return the intersection of r1 and r2. + + + + + + +#--------------------------------------------------------------------------- + + + wx.Point2Ds represent a point or a vector in a 2d coordinate system with floating point values. + + __init__(double x=0.0, double y=0.0) -> Point2D + Create a w.Point2D object. + + + + + + + Point2DCopy(Point2D pt) -> Point2D + Create a w.Point2D object. + + + + + + Point2DFromPoint(Point pt) -> Point2D + Create a w.Point2D object. + + + + + + GetFloor() -> (x,y) + Convert to integer + + + + + + + GetRounded() -> (x,y) + Convert to integer + + + + + + + GetVectorLength() -> double + + + GetVectorAngle() -> double + + + SetVectorLength(double length) + + + + + + SetVectorAngle(double degrees) + + + + + + GetDistance(Point2D pt) -> double + + + + + + GetDistanceSquare(Point2D pt) -> double + + + + + + GetDotProduct(Point2D vec) -> double + + + + + + GetCrossProduct(Point2D vec) -> double + + + + + + __neg__() -> Point2D + the reflection of this point + + + __iadd__(Point2D pt) -> Point2D + + + + + + __isub__(Point2D pt) -> Point2D + + + + + + __imul__(Point2D pt) -> Point2D + + + + + + __idiv__(Point2D pt) -> Point2D + + + + + + __eq__(Point2D pt) -> bool + Test for equality + + + + + + __ne__(Point2D pt) -> bool + Test for inequality + + + + + + + + Set(double x=0, double y=0) + + + + + + + Get() -> (x,y) + Return x and y properties as a tuple. + + + +#--------------------------------------------------------------------------- + + + + __init__(PyObject p) -> InputStream + + + + + + close() + + + flush() + + + eof() -> bool + + + read(int size=-1) -> PyObject + + + + + + readline(int size=-1) -> PyObject + + + + + + readlines(int sizehint=-1) -> PyObject + + + + + + seek(int offset, int whence=0) + + + + + + + tell() -> int + + + Peek() -> char + + + GetC() -> char + + + LastRead() -> size_t + + + CanRead() -> bool + + + Eof() -> bool + + + Ungetch(char c) -> bool + + + + + + SeekI(long pos, int mode=FromStart) -> long + + + + + + + TellI() -> long + + + + + write(PyObject obj) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(InputStream stream, String loc, String mimetype, String anchor, + DateTime modif) -> FSFile + + + + + + + + + + __del__() + + + GetStream() -> InputStream + + + GetMimeType() -> String + + + GetLocation() -> String + + + GetAnchor() -> String + + + GetModificationTime() -> DateTime + + + + + + + __init__() -> FileSystemHandler + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + CanOpen(String location) -> bool + + + + + + OpenFile(FileSystem fs, String location) -> FSFile + + + + + + + FindFirst(String spec, int flags=0) -> String + + + + + + + FindNext() -> String + + + GetProtocol(String location) -> String + + + + + + GetLeftLocation(String location) -> String + + + + + + GetAnchor(String location) -> String + + + + + + GetRightLocation(String location) -> String + + + + + + GetMimeTypeFromExt(String location) -> String + + + + + + + + + __init__() -> FileSystem + + + __del__() + + + ChangePathTo(String location, bool is_dir=False) + + + + + + + GetPath() -> String + + + OpenFile(String location) -> FSFile + + + + + + FindFirst(String spec, int flags=0) -> String + + + + + + + FindNext() -> String + + + FileSystem.AddHandler(CPPFileSystemHandler handler) + + + + + + FileSystem.CleanUpHandlers() + + + FileSystem.FileNameToURL(String filename) -> String + + + + + + + FileSystem_URLToFileName(String url) -> String + + + + + + + + __init__() -> InternetFSHandler + + + CanOpen(String location) -> bool + + + + + + OpenFile(FileSystem fs, String location) -> FSFile + + + + + + + + + + __init__() -> ZipFSHandler + + + CanOpen(String location) -> bool + + + + + + OpenFile(FileSystem fs, String location) -> FSFile + + + + + + + FindFirst(String spec, int flags=0) -> String + + + + + + + FindNext() -> String + + + + __wxMemoryFSHandler_AddFile_wxImage(String filename, Image image, long type) + + + + + + + + __wxMemoryFSHandler_AddFile_wxBitmap(String filename, Bitmap bitmap, long type) + + + + + + + + __wxMemoryFSHandler_AddFile_Data(String filename, PyObject data) + + + + + + +def MemoryFSHandler_AddFile(filename, a, b=''): + if isinstance(a, wx.Image): + __wxMemoryFSHandler_AddFile_wxImage(filename, a, b) + elif isinstance(a, wx.Bitmap): + __wxMemoryFSHandler_AddFile_wxBitmap(filename, a, b) + elif type(a) == str: + __wxMemoryFSHandler_AddFile_Data(filename, a) + else: raise TypeError, 'wx.Image, wx.Bitmap or string expected' + + + + + __init__() -> MemoryFSHandler + + + MemoryFSHandler.RemoveFile(String filename) + + + + + + CanOpen(String location) -> bool + + + + + + OpenFile(FileSystem fs, String location) -> FSFile + + + + + + + FindFirst(String spec, int flags=0) -> String + + + + + + + FindNext() -> String + + + +#--------------------------------------------------------------------------- + + + + + GetName() -> String + + + GetExtension() -> String + + + GetType() -> long + + + GetMimeType() -> String + + + CanRead(String name) -> bool + + + + + + SetName(String name) + + + + + + SetExtension(String extension) + + + + + + SetType(long type) + + + + + + SetMimeType(String mimetype) + + + + + + + + __init__() -> ImageHistogram + + + ImageHistogram.MakeKey(unsigned char r, unsigned char g, unsigned char b) -> unsigned long + Get the key in the histogram for the given RGB values + + + + + + + + FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b) + Find first colour that is not used in the image and has higher RGB values than +startR, startG, startB. Returns a tuple consisting of a success flag and rgb +values. + + + + + + + + + + + + + + __init__(String name, long type=BITMAP_TYPE_ANY, int index=-1) -> Image + + + + + + + + ImageFromMime(String name, String mimetype, int index=-1) -> Image + + + + + + + + ImageFromStream(InputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> Image + + + + + + + + ImageFromStreamMime(InputStream stream, String mimetype, int index=-1) -> Image + + + + + + + + EmptyImage(int width=0, int height=0, bool clear=True) -> Image + + + + + + + + ImageFromBitmap(Bitmap bitmap) -> Image + + + + + + ImageFromData(int width, int height, unsigned char data) -> Image + + + + + + + + __del__() + + + Create(int width, int height) + + + + + + + Destroy() + Deletes the C++ object this Python object is a proxy for. + + + Scale(int width, int height) -> Image + + + + + + + ShrinkBy(int xFactor, int yFactor) -> Image + + + + + + + Rescale(int width, int height) -> Image + + + + + + + SetRGB(int x, int y, unsigned char r, unsigned char g, unsigned char b) + + + + + + + + + + GetRed(int x, int y) -> unsigned char + + + + + + + GetGreen(int x, int y) -> unsigned char + + + + + + + GetBlue(int x, int y) -> unsigned char + + + + + + + SetAlpha(int x, int y, unsigned char alpha) + + + + + + + + GetAlpha(int x, int y) -> unsigned char + + + + + + + HasAlpha() -> bool + + + FindFirstUnusedColour(int startR=1, int startG=0, int startB=0) -> (success, r, g, b) + Find first colour that is not used in the image and has higher RGB values than +startR, startG, startB. Returns a tuple consisting of a success flag and rgb +values. + + + + + + + + + + + SetMaskFromImage(Image mask, byte mr, byte mg, byte mb) -> bool + + + + + + + + + Image.CanRead(String name) -> bool + + + + + + Image.GetImageCount(String name, long type=BITMAP_TYPE_ANY) -> int + + + + + + + LoadFile(String name, long type=BITMAP_TYPE_ANY, int index=-1) -> bool + + + + + + + + LoadMimeFile(String name, String mimetype, int index=-1) -> bool + + + + + + + + SaveFile(String name, int type) -> bool + + + + + + + SaveMimeFile(String name, String mimetype) -> bool + + + + + + + Image.CanReadStream(InputStream stream) -> bool + + + + + + LoadStream(InputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> bool + + + + + + + + LoadMimeStream(InputStream stream, String mimetype, int index=-1) -> bool + + + + + + + + Ok() -> bool + + + GetWidth() -> int + + + GetHeight() -> int + + + GetSubImage(Rect rect) -> Image + + + + + + Copy() -> Image + + + Paste(Image image, int x, int y) + + + + + + + + GetData() -> PyObject + + + SetData(PyObject data) + + + + + + GetDataBuffer() -> PyObject + + + SetDataBuffer(PyObject data) + + + + + + GetAlphaData() -> PyObject + + + SetAlphaData(PyObject data) + + + + + + GetAlphaBuffer() -> PyObject + + + SetAlphaBuffer(PyObject data) + + + + + + SetMaskColour(unsigned char r, unsigned char g, unsigned char b) + + + + + + + + GetMaskRed() -> unsigned char + + + GetMaskGreen() -> unsigned char + + + GetMaskBlue() -> unsigned char + + + SetMask(bool mask=True) + + + + + + HasMask() -> bool + + + Rotate(double angle, Point centre_of_rotation, bool interpolating=True, + Point offset_after_rotation=None) -> Image + + + + + + + + + Rotate90(bool clockwise=True) -> Image + + + + + + Mirror(bool horizontally=True) -> Image + + + + + + Replace(unsigned char r1, unsigned char g1, unsigned char b1, + unsigned char r2, unsigned char g2, unsigned char b2) + + + + + + + + + + + ConvertToMono(unsigned char r, unsigned char g, unsigned char b) -> Image + + + + + + + + SetOption(String name, String value) + + + + + + + SetOptionInt(String name, int value) + + + + + + + GetOption(String name) -> String + + + + + + GetOptionInt(String name) -> int + + + + + + HasOption(String name) -> bool + + + + + + CountColours(unsigned long stopafter=(unsigned long) -1) -> unsigned long + + + + + + ComputeHistogram(ImageHistogram h) -> unsigned long + + + + + + Image.AddHandler(ImageHandler handler) + + + + + + Image.InsertHandler(ImageHandler handler) + + + + + + Image.RemoveHandler(String name) -> bool + + + + + + Image.GetImageExtWildcard() -> String + + + ConvertToBitmap() -> Bitmap + + + ConvertToMonoBitmap(unsigned char red, unsigned char green, unsigned char blue) -> Bitmap + + + + + + + + + InitAllImageHandlers() + + + + + __init__() -> BMPHandler + + + + + + __init__() -> ICOHandler + + + + + + __init__() -> CURHandler + + + + + + __init__() -> ANIHandler + + + + + + __init__() -> PNGHandler + + + + + + __init__() -> GIFHandler + + + + + + __init__() -> PCXHandler + + + + + + __init__() -> JPEGHandler + + + + + + __init__() -> PNMHandler + + + + + + __init__() -> XPMHandler + + + + + + __init__() -> TIFFHandler + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> EvtHandler + + + GetNextHandler() -> EvtHandler + + + GetPreviousHandler() -> EvtHandler + + + SetNextHandler(EvtHandler handler) + + + + + + SetPreviousHandler(EvtHandler handler) + + + + + + GetEvtHandlerEnabled() -> bool + + + SetEvtHandlerEnabled(bool enabled) + + + + + + ProcessEvent(Event event) -> bool + + + + + + AddPendingEvent(Event event) + + + + + + ProcessPendingEvents() + + + Connect(int id, int lastId, int eventType, PyObject func) + + + + + + + + + Disconnect(int id, int lastId=-1, wxEventType eventType=wxEVT_NULL) -> bool + + + + + + + + _setOORInfo(PyObject _self) + + + + + + + +#--------------------------------------------------------------------------- + +class PyEventBinder(object): + """ + Instances of this class are used to bind specific events to event + handlers. + """ + def __init__(self, evtType, expectedIDs=0): + if expectedIDs not in [0, 1, 2]: + raise ValueError, "Invalid number of expectedIDs" + self.expectedIDs = expectedIDs + + if type(evtType) == list or type(evtType) == tuple: + self.evtType = evtType + else: + self.evtType = [evtType] + + + def Bind(self, target, id1, id2, function): + """Bind this set of event types to target.""" + for et in self.evtType: + target.Connect(id1, id2, et, function) + + + def __call__(self, *args): + """ + For backwards compatibility with the old EVT_* functions. + Should be called with either (window, func), (window, ID, + func) or (window, ID1, ID2, func) parameters depending on the + type of the event. + """ + assert len(args) == 2 + self.expectedIDs + id1 = wx.ID_ANY + id2 = wx.ID_ANY + target = args[0] + if self.expectedIDs == 0: + func = args[1] + elif self.expectedIDs == 1: + id1 = args[1] + func = args[2] + elif self.expectedIDs == 2: + id1 = args[1] + id2 = args[2] + func = args[3] + else: + raise ValueError, "Unexpected number of IDs" + + self.Bind(target, id1, id2, func) + + +# These two are square pegs that don't fit the PyEventBinder hole... +def EVT_COMMAND(win, id, cmd, func): + win.Connect(id, -1, cmd, func) +def EVT_COMMAND_RANGE(win, id1, id2, cmd, func): + win.Connect(id1, id2, cmd, func) + + +#--------------------------------------------------------------------------- + + +#--------------------------------------------------------------------------- + + + NewEventType() -> wxEventType + + +# +# Create some event binders +EVT_SIZE = wx.PyEventBinder( wxEVT_SIZE ) +EVT_SIZING = wx.PyEventBinder( wxEVT_SIZING ) +EVT_MOVE = wx.PyEventBinder( wxEVT_MOVE ) +EVT_MOVING = wx.PyEventBinder( wxEVT_MOVING ) +EVT_CLOSE = wx.PyEventBinder( wxEVT_CLOSE_WINDOW ) +EVT_END_SESSION = wx.PyEventBinder( wxEVT_END_SESSION ) +EVT_QUERY_END_SESSION = wx.PyEventBinder( wxEVT_QUERY_END_SESSION ) +EVT_PAINT = wx.PyEventBinder( wxEVT_PAINT ) +EVT_NC_PAINT = wx.PyEventBinder( wxEVT_NC_PAINT ) +EVT_ERASE_BACKGROUND = wx.PyEventBinder( wxEVT_ERASE_BACKGROUND ) +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_CHAR_HOOK = wx.PyEventBinder( wxEVT_CHAR_HOOK ) +EVT_MENU_OPEN = wx.PyEventBinder( wxEVT_MENU_OPEN ) +EVT_MENU_CLOSE = wx.PyEventBinder( wxEVT_MENU_CLOSE ) +EVT_MENU_HIGHLIGHT = wx.PyEventBinder( wxEVT_MENU_HIGHLIGHT, 1) +EVT_MENU_HIGHLIGHT_ALL = wx.PyEventBinder( wxEVT_MENU_HIGHLIGHT ) +EVT_SET_FOCUS = wx.PyEventBinder( wxEVT_SET_FOCUS ) +EVT_KILL_FOCUS = wx.PyEventBinder( wxEVT_KILL_FOCUS ) +EVT_CHILD_FOCUS = wx.PyEventBinder( wxEVT_CHILD_FOCUS ) +EVT_ACTIVATE = wx.PyEventBinder( wxEVT_ACTIVATE ) +EVT_ACTIVATE_APP = wx.PyEventBinder( wxEVT_ACTIVATE_APP ) +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_INIT_DIALOG = wx.PyEventBinder( wxEVT_INIT_DIALOG ) +EVT_SYS_COLOUR_CHANGED = wx.PyEventBinder( wxEVT_SYS_COLOUR_CHANGED ) +EVT_DISPLAY_CHANGED = wx.PyEventBinder( wxEVT_DISPLAY_CHANGED ) +EVT_SHOW = wx.PyEventBinder( wxEVT_SHOW ) +EVT_MAXIMIZE = wx.PyEventBinder( wxEVT_MAXIMIZE ) +EVT_ICONIZE = wx.PyEventBinder( wxEVT_ICONIZE ) +EVT_NAVIGATION_KEY = wx.PyEventBinder( wxEVT_NAVIGATION_KEY ) +EVT_PALETTE_CHANGED = wx.PyEventBinder( wxEVT_PALETTE_CHANGED ) +EVT_QUERY_NEW_PALETTE = wx.PyEventBinder( wxEVT_QUERY_NEW_PALETTE ) +EVT_WINDOW_CREATE = wx.PyEventBinder( wxEVT_CREATE ) +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_LEFT_DOWN = wx.PyEventBinder( wxEVT_LEFT_DOWN ) +EVT_LEFT_UP = wx.PyEventBinder( wxEVT_LEFT_UP ) +EVT_MIDDLE_DOWN = wx.PyEventBinder( wxEVT_MIDDLE_DOWN ) +EVT_MIDDLE_UP = wx.PyEventBinder( wxEVT_MIDDLE_UP ) +EVT_RIGHT_DOWN = wx.PyEventBinder( wxEVT_RIGHT_DOWN ) +EVT_RIGHT_UP = wx.PyEventBinder( wxEVT_RIGHT_UP ) +EVT_MOTION = wx.PyEventBinder( wxEVT_MOTION ) +EVT_LEFT_DCLICK = wx.PyEventBinder( wxEVT_LEFT_DCLICK ) +EVT_MIDDLE_DCLICK = wx.PyEventBinder( wxEVT_MIDDLE_DCLICK ) +EVT_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_RIGHT_DCLICK ) +EVT_LEAVE_WINDOW = wx.PyEventBinder( wxEVT_LEAVE_WINDOW ) +EVT_ENTER_WINDOW = wx.PyEventBinder( wxEVT_ENTER_WINDOW ) +EVT_MOUSEWHEEL = wx.PyEventBinder( wxEVT_MOUSEWHEEL ) + +EVT_MOUSE_EVENTS = wx.PyEventBinder([ wxEVT_LEFT_DOWN, + wxEVT_LEFT_UP, + wxEVT_MIDDLE_DOWN, + wxEVT_MIDDLE_UP, + wxEVT_RIGHT_DOWN, + wxEVT_RIGHT_UP, + wxEVT_MOTION, + wxEVT_LEFT_DCLICK, + wxEVT_MIDDLE_DCLICK, + wxEVT_RIGHT_DCLICK, + wxEVT_ENTER_WINDOW, + wxEVT_LEAVE_WINDOW, + wxEVT_MOUSEWHEEL + ]) + + +# Scrolling from wxWindow (sent to wxScrolledWindow) +EVT_SCROLLWIN = wx.PyEventBinder([ wxEVT_SCROLLWIN_TOP, + wxEVT_SCROLLWIN_BOTTOM, + wxEVT_SCROLLWIN_LINEUP, + wxEVT_SCROLLWIN_LINEDOWN, + wxEVT_SCROLLWIN_PAGEUP, + wxEVT_SCROLLWIN_PAGEDOWN, + wxEVT_SCROLLWIN_THUMBTRACK, + wxEVT_SCROLLWIN_THUMBRELEASE, + ]) + +EVT_SCROLLWIN_TOP = wx.PyEventBinder( wxEVT_SCROLLWIN_TOP ) +EVT_SCROLLWIN_BOTTOM = wx.PyEventBinder( wxEVT_SCROLLWIN_BOTTOM ) +EVT_SCROLLWIN_LINEUP = wx.PyEventBinder( wxEVT_SCROLLWIN_LINEUP ) +EVT_SCROLLWIN_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLLWIN_LINEDOWN ) +EVT_SCROLLWIN_PAGEUP = wx.PyEventBinder( wxEVT_SCROLLWIN_PAGEUP ) +EVT_SCROLLWIN_PAGEDOWN = wx.PyEventBinder( wxEVT_SCROLLWIN_PAGEDOWN ) +EVT_SCROLLWIN_THUMBTRACK = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBTRACK ) +EVT_SCROLLWIN_THUMBRELEASE = wx.PyEventBinder( wxEVT_SCROLLWIN_THUMBRELEASE ) + +# Scrolling from wxSlider and wxScrollBar +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_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP ) +EVT_SCROLL_BOTTOM = wx.PyEventBinder( wxEVT_SCROLL_BOTTOM ) +EVT_SCROLL_LINEUP = wx.PyEventBinder( wxEVT_SCROLL_LINEUP ) +EVT_SCROLL_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLL_LINEDOWN ) +EVT_SCROLL_PAGEUP = wx.PyEventBinder( wxEVT_SCROLL_PAGEUP ) +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 ) + +# Scrolling from wxSlider and wxScrollBar, 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, + wxEVT_SCROLL_THUMBRELEASE, + wxEVT_SCROLL_ENDSCROLL, + ], 1) + +EVT_COMMAND_SCROLL_TOP = wx.PyEventBinder( wxEVT_SCROLL_TOP, 1) +EVT_COMMAND_SCROLL_BOTTOM = wx.PyEventBinder( wxEVT_SCROLL_BOTTOM, 1) +EVT_COMMAND_SCROLL_LINEUP = wx.PyEventBinder( wxEVT_SCROLL_LINEUP, 1) +EVT_COMMAND_SCROLL_LINEDOWN = wx.PyEventBinder( wxEVT_SCROLL_LINEDOWN, 1) +EVT_COMMAND_SCROLL_PAGEUP = wx.PyEventBinder( wxEVT_SCROLL_PAGEUP, 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_SPIN_UP = wx.PyEventBinder( wxEVT_SCROLL_LINEUP, 1) +EVT_SPIN_DOWN = wx.PyEventBinder( wxEVT_SCROLL_LINEDOWN, 1) +EVT_SPIN = wx.PyEventBinder( wxEVT_SCROLL_THUMBTRACK, 1) + +EVT_BUTTON = wx.PyEventBinder( wxEVT_COMMAND_BUTTON_CLICKED, 1) +EVT_CHECKBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKBOX_CLICKED, 1) +EVT_CHOICE = wx.PyEventBinder( wxEVT_COMMAND_CHOICE_SELECTED, 1) +EVT_LISTBOX = wx.PyEventBinder( wxEVT_COMMAND_LISTBOX_SELECTED, 1) +EVT_LISTBOX_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, 1) +EVT_MENU = wx.PyEventBinder( wxEVT_COMMAND_MENU_SELECTED, 1) +EVT_MENU_RANGE = wx.PyEventBinder( wxEVT_COMMAND_MENU_SELECTED, 2) +EVT_SLIDER = wx.PyEventBinder( wxEVT_COMMAND_SLIDER_UPDATED, 1) +EVT_RADIOBOX = wx.PyEventBinder( wxEVT_COMMAND_RADIOBOX_SELECTED, 1) +EVT_RADIOBUTTON = wx.PyEventBinder( wxEVT_COMMAND_RADIOBUTTON_SELECTED, 1) + +EVT_SCROLLBAR = wx.PyEventBinder( wxEVT_COMMAND_SCROLLBAR_UPDATED, 1) +EVT_VLBOX = wx.PyEventBinder( wxEVT_COMMAND_VLBOX_SELECTED, 1) +EVT_COMBOBOX = wx.PyEventBinder( wxEVT_COMMAND_COMBOBOX_SELECTED, 1) +EVT_TOOL = wx.PyEventBinder( wxEVT_COMMAND_TOOL_CLICKED, 1) +EVT_TOOL_RANGE = wx.PyEventBinder( wxEVT_COMMAND_TOOL_CLICKED, 2) +EVT_TOOL_RCLICKED = wx.PyEventBinder( wxEVT_COMMAND_TOOL_RCLICKED, 1) +EVT_TOOL_RCLICKED_RANGE = wx.PyEventBinder( wxEVT_COMMAND_TOOL_RCLICKED, 2) +EVT_TOOL_ENTER = wx.PyEventBinder( wxEVT_COMMAND_TOOL_ENTER, 1) +EVT_CHECKLISTBOX = wx.PyEventBinder( wxEVT_COMMAND_CHECKLISTBOX_TOGGLED, 1) + + +EVT_COMMAND_LEFT_CLICK = wx.PyEventBinder( wxEVT_COMMAND_LEFT_CLICK, 1) +EVT_COMMAND_LEFT_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_LEFT_DCLICK, 1) +EVT_COMMAND_RIGHT_CLICK = wx.PyEventBinder( wxEVT_COMMAND_RIGHT_CLICK, 1) +EVT_COMMAND_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_COMMAND_RIGHT_DCLICK, 1) +EVT_COMMAND_SET_FOCUS = wx.PyEventBinder( wxEVT_COMMAND_SET_FOCUS, 1) +EVT_COMMAND_KILL_FOCUS = wx.PyEventBinder( wxEVT_COMMAND_KILL_FOCUS, 1) +EVT_COMMAND_ENTER = wx.PyEventBinder( wxEVT_COMMAND_ENTER, 1) + +EVT_IDLE = wx.PyEventBinder( wxEVT_IDLE ) + +EVT_UPDATE_UI = wx.PyEventBinder( wxEVT_UPDATE_UI, 1) +EVT_UPDATE_UI_RANGE = wx.PyEventBinder( wxEVT_UPDATE_UI, 2) + +EVT_CONTEXT_MENU = wx.PyEventBinder( wxEVT_CONTEXT_MENU ) + + + + +#--------------------------------------------------------------------------- + + + + + __del__() + + + SetEventType(wxEventType typ) + + + + + + GetEventType() -> wxEventType + + + GetEventObject() -> Object + + + SetEventObject(Object obj) + + + + + + GetTimestamp() -> long + + + SetTimestamp(long ts=0) + + + + + + GetId() -> int + + + SetId(int Id) + + + + + + IsCommandEvent() -> bool + + + Skip(bool skip=True) + + + + + + GetSkipped() -> bool + + + ShouldPropagate() -> bool + + + StopPropagation() -> int + + + ResumePropagation(int propagationLevel) + + + + + + Clone() -> Event + + + +#--------------------------------------------------------------------------- + + + + __init__(Event event) -> PropagationDisabler + + + + + + __del__() + + + + + __init__(Event event) -> PropagateOnce + + + + + + __del__() + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxEventType commandType=wxEVT_NULL, int winid=0) -> CommandEvent + + + + + + + GetSelection() -> int + + + SetString(String s) + + + + + + GetString() -> String + + + IsChecked() -> bool + + + IsSelection() -> bool + + + SetExtraLong(long extraLong) + + + + + + GetExtraLong() -> long + + + SetInt(int i) + + + + + + GetInt() -> long + + + Clone() -> Event + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxEventType commandType=wxEVT_NULL, int winid=0) -> NotifyEvent + + + + + + + Veto() + + + Allow() + + + IsAllowed() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxEventType commandType=wxEVT_NULL, int winid=0, int pos=0, + int orient=0) -> ScrollEvent + + + + + + + + + GetOrientation() -> int + + + GetPosition() -> int + + + SetOrientation(int orient) + + + + + + SetPosition(int pos) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxEventType commandType=wxEVT_NULL, int pos=0, int orient=0) -> ScrollWinEvent + + + + + + + + GetOrientation() -> int + + + GetPosition() -> int + + + SetOrientation(int orient) + + + + + + SetPosition(int pos) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxEventType mouseType=wxEVT_NULL) -> MouseEvent + + + + + + IsButton() -> bool + + + ButtonDown(int but=MOUSE_BTN_ANY) -> bool + + + + + + ButtonDClick(int but=MOUSE_BTN_ANY) -> bool + + + + + + ButtonUp(int but=MOUSE_BTN_ANY) -> bool + + + + + + Button(int but) -> bool + + + + + + ButtonIsDown(int but) -> bool + + + + + + GetButton() -> int + + + ControlDown() -> bool + + + MetaDown() -> bool + + + AltDown() -> bool + + + ShiftDown() -> bool + + + LeftDown() -> bool + + + MiddleDown() -> bool + + + RightDown() -> bool + + + LeftUp() -> bool + + + MiddleUp() -> bool + + + RightUp() -> bool + + + LeftDClick() -> bool + + + MiddleDClick() -> bool + + + RightDClick() -> bool + + + LeftIsDown() -> bool + + + MiddleIsDown() -> bool + + + RightIsDown() -> bool + + + Dragging() -> bool + + + Moving() -> bool + + + Entering() -> bool + + + Leaving() -> bool + + + GetPosition() -> Point + Returns the position of the mouse in window coordinates when the event happened. + + + GetPositionTuple() -> (x,y) + Returns the position of the mouse in window coordinates when the event happened. + + + + + + + GetLogicalPosition(DC dc) -> Point + + + + + + GetX() -> int + + + GetY() -> int + + + GetWheelRotation() -> int + + + GetWheelDelta() -> int + + + GetLinesPerAction() -> int + + + IsPageScroll() -> bool + + + + + + + + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(int x=0, int y=0) -> SetCursorEvent + + + + + + + GetX() -> int + + + GetY() -> int + + + SetCursor(Cursor cursor) + + + + + + GetCursor() -> Cursor + + + HasCursor() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxEventType keyType=wxEVT_NULL) -> KeyEvent + + + + + + ControlDown() -> bool + + + MetaDown() -> bool + + + AltDown() -> bool + + + ShiftDown() -> bool + + + HasModifiers() -> bool + + + GetKeyCode() -> int + + + GetUniChar() -> int + + + GetRawKeyCode() -> unsigned int + + + GetRawKeyFlags() -> unsigned int + + + GetPosition() -> Point + Find the position of the event. + + + GetPositionTuple() -> (x,y) + Find the position of the event. + + + + + + + GetX() -> int + + + GetY() -> int + + + + + + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Size sz=DefaultSize, int winid=0) -> SizeEvent + + + + + + + GetSize() -> Size + + + GetRect() -> Rect + + + SetRect(Rect rect) + + + + + + SetSize(Size size) + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Point pos=DefaultPosition, int winid=0) -> MoveEvent + + + + + + + GetPosition() -> Point + + + GetRect() -> Rect + + + SetRect(Rect rect) + + + + + + SetPosition(Point pos) + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(int Id=0) -> PaintEvent + + + + + + + + + __init__(int winid=0) -> NcPaintEvent + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(int Id=0, DC dc=(wxDC *) NULL) -> EraseEvent + + + + + + + GetDC() -> DC + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxEventType type=wxEVT_NULL, int winid=0) -> FocusEvent + + + + + + + GetWindow() -> Window + + + SetWindow(Window win) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window win=None) -> ChildFocusEvent + + + + + + GetWindow() -> Window + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxEventType type=wxEVT_NULL, bool active=True, int Id=0) -> ActivateEvent + + + + + + + + GetActive() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__(int Id=0) -> InitDialogEvent + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxEventType type=wxEVT_NULL, int winid=0, Menu menu=None) -> MenuEvent + + + + + + + + GetMenuId() -> int + + + IsPopup() -> bool + + + GetMenu() -> Menu + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxEventType type=wxEVT_NULL, int winid=0) -> CloseEvent + + + + + + + SetLoggingOff(bool logOff) + + + + + + GetLoggingOff() -> bool + + + Veto(bool veto=True) + + + + + + SetCanVeto(bool canVeto) + + + + + + CanVeto() -> bool + + + GetVeto() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__(int winid=0, bool show=False) -> ShowEvent + + + + + + + SetShow(bool show) + + + + + + GetShow() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__(int id=0, bool iconized=True) -> IconizeEvent + + + + + + + Iconized() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__(int id=0) -> MaximizeEvent + + + + + + +#--------------------------------------------------------------------------- + + + + + GetPosition() -> Point + + + GetNumberOfFiles() -> int + + + GetFiles() -> PyObject + + + +#--------------------------------------------------------------------------- + + + + + __init__(int commandId=0) -> UpdateUIEvent + + + + + + GetChecked() -> bool + + + GetEnabled() -> bool + + + GetText() -> String + + + GetSetText() -> bool + + + GetSetChecked() -> bool + + + GetSetEnabled() -> bool + + + Check(bool check) + + + + + + Enable(bool enable) + + + + + + SetText(String text) + + + + + + UpdateUIEvent.SetUpdateInterval(long updateInterval) + + + + + + UpdateUIEvent.GetUpdateInterval() -> long + + + UpdateUIEvent.CanUpdate(Window win) -> bool + + + + + + UpdateUIEvent.ResetUpdateTime() + + + UpdateUIEvent.SetMode(int mode) + + + + + + UpdateUIEvent.GetMode() -> int + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> SysColourChangedEvent + + + +#--------------------------------------------------------------------------- + + + + + __init__(int winid=0, Window gainedCapture=None) -> MouseCaptureChangedEvent + + + + + + + GetCapturedWindow() -> Window + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> DisplayChangedEvent + + + +#--------------------------------------------------------------------------- + + + + + __init__(int id=0) -> PaletteChangedEvent + + + + + + SetChangedWindow(Window win) + + + + + + GetChangedWindow() -> Window + + + +#--------------------------------------------------------------------------- + + + + + __init__(int winid=0) -> QueryNewPaletteEvent + + + + + + SetPaletteRealized(bool realized) + + + + + + GetPaletteRealized() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> NavigationKeyEvent + + + GetDirection() -> bool + + + SetDirection(bool bForward) + + + + + + IsWindowChange() -> bool + + + SetWindowChange(bool bIs) + + + + + + GetCurrentFocus() -> Window + + + SetCurrentFocus(Window win) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window win=None) -> WindowCreateEvent + + + + + + GetWindow() -> Window + + + + + + __init__(Window win=None) -> WindowDestroyEvent + + + + + + GetWindow() -> Window + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxEventType type=wxEVT_NULL, int winid=0, Point pt=DefaultPosition) -> ContextMenuEvent + + + + + + + + GetPosition() -> Point + + + SetPosition(Point pos) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> IdleEvent + + + RequestMore(bool needMore=True) + + + + + + MoreRequested() -> bool + + + IdleEvent.SetMode(int mode) + + + + + + IdleEvent.GetMode() -> int + + + IdleEvent.CanSend(Window win) -> bool + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(int winid=0, wxEventType commandType=wxEVT_NULL) -> PyEvent + + + + + + + __del__() + + + SetSelf(PyObject self) + + + + + + GetSelf() -> PyObject + + + + + + __init__(wxEventType commandType=wxEVT_NULL, int id=0) -> PyCommandEvent + + + + + + + __del__() + + + SetSelf(PyObject self) + + + + + + GetSelf() -> PyObject + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> PyApp + + + __del__() + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + GetAppName() -> String + Get the application name. + + + SetAppName(String name) + Set the application name. This value may be used automatically +by wx.Config and such. + + + + + + GetClassName() -> String + Get the application's class name. + + + SetClassName(String name) + Set the application's class name. This value may be used for X-resources if +applicable for the platform + + + + + + GetVendorName() -> String + Get the application's vendor name. + + + SetVendorName(String name) + Set the application's vendor name. This value may be used automatically +by wx.Config and such. + + + + + + GetTraits() -> wxAppTraits + Create the app traits object to which we delegate for everything which either +should be configurable by the user (then he can change the default behaviour +simply by overriding CreateTraits() and returning his own traits object) or +which is GUI/console dependent as then wx.AppTraits allows us to abstract the +differences behind the common facade + + + ProcessPendingEvents() + Process all events in the Pending Events list -- it is necessary to call this +function to process posted events. This happens during each event loop +iteration. + + + Yield(bool onlyIfNeeded=False) -> bool + Process all currently pending events right now, instead of waiting until +return to the event loop. It is an error to call Yield() recursively unless +the value of onlyIfNeeded is True. + +WARNING: This function is dangerous as it can lead to unexpected + reentrancies (i.e. when called from an event handler it + may result in calling the same event handler again), use + with _extreme_ care or, better, don't use at all! + + + + + + + WakeUpIdle() + Make sure that idle events are sent again + + + MainLoop() -> int + Execute the main GUI loop, the function returns when the loop ends. + + + Exit() + Exit the main loop thus terminating the application. + + + ExitMainLoop() + Exit the main GUI loop during the next iteration (i.e. it does not +stop the program immediately!) + + + Pending() -> bool + Returns True if there are unprocessed events in the event queue. + + + Dispatch() -> bool + Process the first event in the event queue (blocks until an event +appears if there are none currently) + + + ProcessIdle() -> bool + Called from the MainLoop when the application becomes idle and sends an +IdleEvent to all interested parties. Returns True is more idle events are +needed, False if not. + + + SendIdleEvents(Window win, IdleEvent event) -> bool + Send idle event to window and all subwindows. Returns True if more idle time +is requested. + + + + + + + IsActive() -> bool + Return True if our app has focus. + + + SetTopWindow(Window win) + Set the "main" top level window + + + + + + GetTopWindow() -> Window + Return the "main" top level window (if it hadn't been set previously with +SetTopWindow(), will return just some top level window and, if there not any, +will return None) + + + SetExitOnFrameDelete(bool flag) + Control the exit behaviour: by default, the program will exit the main loop +(and so, usually, terminate) when the last top-level program window is +deleted. Beware that if you disable this behaviour (with +SetExitOnFrameDelete(False)), you'll have to call ExitMainLoop() explicitly +from somewhere. + + + + + + + GetExitOnFrameDelete() -> bool + Get the current exit behaviour setting. + + + SetUseBestVisual(bool flag) + Set whether the app should try to use the best available visual on systems +where more than one is available, (Sun, SGI, XFree86 4, etc.) + + + + + + GetUseBestVisual() -> bool + Get current UseBestVisual setting. + + + SetPrintMode(int mode) + + + + + + GetPrintMode() -> int + + + SetAssertMode(int mode) + Set the OnAssert behaviour for debug and hybrid builds. The following flags +may be or'd together: + + wx.PYAPP_ASSERT_SUPPRESS Don't do anything + wx.PYAPP_ASSERT_EXCEPTION Turn it into a Python exception if possible (default) + wx.PYAPP_ASSERT_DIALOG Display a message dialog + wx.PYAPP_ASSERT_LOG Write the assertion info to the wx.Log + + + + + + + GetAssertMode() -> int + Get the current OnAssert behaviour setting. + + + PyApp.GetMacSupportPCMenuShortcuts() -> bool + + + PyApp.GetMacAboutMenuItemId() -> long + + + PyApp.GetMacPreferencesMenuItemId() -> long + + + PyApp.GetMacExitMenuItemId() -> long + + + PyApp.GetMacHelpMenuTitleName() -> String + + + PyApp.SetMacSupportPCMenuShortcuts(bool val) + + + + + + PyApp.SetMacAboutMenuItemId(long val) + + + + + + PyApp.SetMacPreferencesMenuItemId(long val) + + + + + + PyApp.SetMacExitMenuItemId(long val) + + + + + + PyApp.SetMacHelpMenuTitleName(String val) + + + + + + _BootstrapApp() + For internal use only + + + PyApp.GetComCtl32Version() -> int + Returns 400, 470, 471 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. + + + +#--------------------------------------------------------------------------- + + + Exit() + Force an exit of the application. Convenience for wx.GetApp().Exit() + + + Yield() -> bool + Yield to other apps/messages. Convenience for wx.GetApp().Yield() + + + YieldIfNeeded() -> bool + Yield to other apps/messages. Convenience for wx.GetApp().Yield(True) + + + SafeYield(Window win=None, bool onlyIfNeeded=False) -> bool + This function is similar to wx.Yield, except that it disables the user input +to all program windows before calling wx.Yield and re-enables it again +afterwards. If win is not None, this window will remain enabled, allowing the +implementation of some limited user interaction. + +Returns the result of the call to wx.Yield. + + + + + + + WakeUpIdle() + Cause the message queue to become empty again, so idle events will be sent. + + + PostEvent(EvtHandler dest, Event event) + Send an event to a window or other wx.EvtHandler to be processed later. + + + + + + + App_CleanUp() + For internal use only, it is used to cleanup after wxWindows when Python shuts down. + + + GetApp() -> PyApp + Return a reference to the current wx.App object. + + +#---------------------------------------------------------------------- + +class PyOnDemandOutputWindow: + """ + A class that can be used for redirecting Python's stdout and + stderr streams. It will do nothing until something is wrriten to + the stream at which point it will create a Frame with a text area + and write the text there. + """ + def __init__(self, title = "wxPython: stdout/stderr"): + self.frame = None + self.title = title + self.parent = None + + def SetParent(self, parent): + """Set the window to be used as the popup Frame's parent.""" + self.parent = parent + + + def CreateOutputWindow(self, st): + self.frame = wx.Frame(self.parent, -1, self.title, + style=wx.DEFAULT_FRAME_STYLE | wx.NO_FULL_REPAINT_ON_RESIZE) + self.text = wx.TextCtrl(self.frame, -1, "", + style = wx.TE_MULTILINE | wx.TE_READONLY) + self.frame.SetSize((450, 300)) + self.frame.Show(True) + EVT_CLOSE(self.frame, self.OnCloseWindow) + + + # These methods provide the file-like output behaviour. + def write(self, text): + """ + Create the output window if needed and write the string to it. + If not called in the context of the gui thread then uses + CallAfter to do the work there. + """ + if self.frame is None: + if not wx.Thread_IsMain(): + wx.CallAfter(self.CreateOutputWindow, text) + else: + self.CreateOutputWindow(text) + else: + if not wx.Thread_IsMain(): + wx.CallAfter(self.text.AppendText, text) + else: + self.text.AppendText(text) + + + def close(self): + if self.frame is not None: + wx.CallAfter(self.frame.Close) + + + def OnCloseWindow(self, event): + if self.frame is not None: + self.frame.Destroy() + self.frame = None + self.text = None + +#---------------------------------------------------------------------- + +_defRedirect = (wx.Platform == '__WXMSW__' or wx.Platform == '__WXMAC__') + +class App(wx.PyApp): + """ + The main application class. Derive from this and implement an OnInit + method that creates a frame and then calls self.SetTopWindow(frame) + """ + outputWindowClass = PyOnDemandOutputWindow + + def __init__(self, redirect=_defRedirect, filename=None, useBestVisual=False): + 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: + pass + + # This has to be done before OnInit + self.SetUseBestVisual(useBestVisual) + + # Set the default handler for SIGINT. This fixes a problem + # where if Ctrl-C is pressed in the console that started this + # app then it will not appear to do anything, (not even send + # KeyboardInterrupt???) but will later segfault on exit. By + # setting the default handler then the app will exit, as + # expected (depending on platform.) + try: + import signal + signal.signal(signal.SIGINT, signal.SIG_DFL) + except: + pass + + # Save and redirect the stdio to a window? + self.stdioWin = None + self.saveStdio = (_sys.stdout, _sys.stderr) + if redirect: + self.RedirectStdio(filename) + + # This finishes the initialization of wxWindows and then calls + # the OnInit that should be present in the derived class + self._BootstrapApp() + + + def __del__(self): + try: + self.RestoreStdio() # Just in case the MainLoop was overridden + except: + pass + + + def SetTopWindow(self, frame): + """Set the \\"main\\" top level window""" + if self.stdioWin: + self.stdioWin.SetParent(frame) + wx.PyApp.SetTopWindow(self, frame) + + + def MainLoop(self): + """Execute the main GUI event loop""" + wx.PyApp.MainLoop(self) + self.RestoreStdio() + + + def RedirectStdio(self, filename): + """Redirect sys.stdout and sys.stderr to a file or a popup window.""" + if filename: + _sys.stdout = _sys.stderr = open(filename, 'a') + else: + self.stdioWin = self.outputWindowClass() + _sys.stdout = _sys.stderr = self.stdioWin + + + def RestoreStdio(self): + _sys.stdout, _sys.stderr = self.saveStdio + + + +# change from wxPyApp_ to wxApp_ +App_GetMacSupportPCMenuShortcuts = _core.PyApp_GetMacSupportPCMenuShortcuts +App_GetMacAboutMenuItemId = _core.PyApp_GetMacAboutMenuItemId +App_GetMacPreferencesMenuItemId = _core.PyApp_GetMacPreferencesMenuItemId +App_GetMacExitMenuItemId = _core.PyApp_GetMacExitMenuItemId +App_GetMacHelpMenuTitleName = _core.PyApp_GetMacHelpMenuTitleName +App_SetMacSupportPCMenuShortcuts = _core.PyApp_SetMacSupportPCMenuShortcuts +App_SetMacAboutMenuItemId = _core.PyApp_SetMacAboutMenuItemId +App_SetMacPreferencesMenuItemId = _core.PyApp_SetMacPreferencesMenuItemId +App_SetMacExitMenuItemId = _core.PyApp_SetMacExitMenuItemId +App_SetMacHelpMenuTitleName = _core.PyApp_SetMacHelpMenuTitleName +App_GetComCtl32Version = _core.PyApp_GetComCtl32Version + +#---------------------------------------------------------------------------- + +class PySimpleApp(wx.App): + """ + A simple application class. You can just create one of these and + then then make your top level windows later, and not have to worry + about OnInit.""" + + def __init__(self, redirect=False, filename=None, useBestVisual=False): + wx.App.__init__(self, redirect, filename, useBestVisual) + + def OnInit(self): + wx.InitAllImageHandlers() + return True + + +# Is anybody using this one? +class PyWidgetTester(wx.App): + def __init__(self, size = (250, 100)): + self.size = size + wx.App.__init__(self, 0) + + def OnInit(self): + self.frame = wx.Frame(None, -1, "Widget Tester", pos=(0,0), size=self.size) + self.SetTopWindow(self.frame) + return True + + def SetWidget(self, widgetClass, *args): + w = widgetClass(self.frame, *args) + self.frame.Show(True) + +#---------------------------------------------------------------------------- +# DO NOT hold any other references to this object. This is how we +# know when to cleanup system resources that wxWin is holding. When +# the sys module is unloaded, the refcount on sys.__wxPythonCleanup +# goes to zero and it calls the wxApp_CleanUp function. + +class __wxPyCleanup: + def __init__(self): + self.cleanup = _core.App_CleanUp + def __del__(self): + self.cleanup() + +_sys.__wxPythonCleanup = __wxPyCleanup() + +## # another possible solution, but it gets called too early... +## if sys.version[0] == '2': +## import atexit +## atexit.register(_core.wxApp_CleanUp) +## else: +## sys.exitfunc = _core.wxApp_CleanUp + + +#---------------------------------------------------------------------------- + + +#--------------------------------------------------------------------------- + + + + __init__(int flags=0, int keyCode=0, int cmd=0, MenuItem item=None) -> AcceleratorEntry + + + + + + + + + __del__() + + + Set(int flags, int keyCode, int cmd, MenuItem item=None) + + + + + + + + + SetMenuItem(MenuItem item) + + + + + + GetMenuItem() -> MenuItem + + + GetFlags() -> int + + + GetKeyCode() -> int + + + GetCommand() -> int + + + + + + __init__(entries) -> AcceleratorTable + Construct an AcceleratorTable from a list of AcceleratorEntry items or +3-tuples (flags, keyCode, cmdID) + + + + + + + __del__() + + + Ok() -> bool + + + + GetAccelFromString(String label) -> AcceleratorEntry + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, String name=PanelNameStr) -> Window + + + + + + + + + + + PreWindow() -> Window + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, String name=PanelNameStr) -> bool + + + + + + + + + + + Close(bool force=False) -> bool + + + + + + Destroy() -> bool + Deletes the C++ object this Python object is a proxy for. + + + DestroyChildren() -> bool + + + IsBeingDeleted() -> bool + + + SetTitle(String title) + + + + + + GetTitle() -> String + + + SetLabel(String label) + + + + + + GetLabel() -> String + + + SetName(String name) + + + + + + GetName() -> String + + + SetId(int winid) + + + + + + GetId() -> int + + + Window.NewControlId() -> int + + + Window.NextControlId(int winid) -> int + + + + + + Window.PrevControlId(int winid) -> int + + + + + + SetSize(Size size) + + + + + + SetDimensions(int x, int y, int width, int height, int sizeFlags=SIZE_AUTO) + + + + + + + + + + SetRect(Rect rect, int sizeFlags=SIZE_AUTO) + + + + + + + SetSizeWH(int width, int height) + + + + + + + Move(Point pt, int flags=SIZE_USE_EXISTING) + + + + + + + MoveXY(int x, int y, int flags=SIZE_USE_EXISTING) + + + + + + + + Raise() + + + Lower() + + + SetClientSize(Size size) + + + + + + SetClientSizeWH(int width, int height) + + + + + + + SetClientRect(Rect rect) + + + + + + GetPosition() -> Point + Get the window's position. + + + GetPositionTuple() -> (x,y) + Get the window's position. + + + + + + + GetSize() -> Size + Get the window size. + + + GetSizeTuple() -> (width, height) + Get the window size. + + + + + + + GetRect() -> Rect + + + GetClientSize() -> Size + Get the window's client size. + + + GetClientSizeTuple() -> (width, height) + Get the window's client size. + + + + + + + GetClientAreaOrigin() -> Point + + + GetClientRect() -> Rect + + + GetBestSize() -> Size + Get the size best suited for the window (in fact, minimal acceptable size +using which it will still look "nice") + + + GetBestSizeTuple() -> (width, height) + Get the size best suited for the window (in fact, minimal acceptable size +using which it will still look "nice") + + + + + + + GetAdjustedBestSize() -> Size + + + Center(int direction=BOTH) + + + + + + CenterOnScreen(int dir=BOTH) + + + + + + CenterOnParent(int dir=BOTH) + + + + + + Fit() + + + FitInside() + + + SetSizeHints(int minW, int minH, int maxW=-1, int maxH=-1, int incW=-1, + int incH=-1) + + + + + + + + + + + SetVirtualSizeHints(int minW, int minH, int maxW=-1, int maxH=-1) + + + + + + + + + GetMinWidth() -> int + + + GetMinHeight() -> int + + + GetMaxWidth() -> int + + + GetMaxHeight() -> int + + + GetMaxSize() -> Size + + + SetVirtualSize(Size size) + Set the the virtual size of a window. For most windows this is just the +client area of the window, but for some like scrolled windows it is more or +less independent of the screen window size. + + + + + + SetVirtualSizeWH(int w, int h) + Set the the virtual size of a window. For most windows this is just the +client area of the window, but for some like scrolled windows it is more or +less independent of the screen window size. + + + + + + + GetVirtualSize() -> Size + Get the the virtual size of the window. For most windows this is just +the client area of the window, but for some like scrolled windows it is +more or less independent of the screen window size. + + + GetVirtualSizeTuple() -> (width, height) + Get the the virtual size of the window. For most windows this is just +the client area of the window, but for some like scrolled windows it is +more or less independent of the screen window size. + + + + + + + GetBestVirtualSize() -> Size + + + Show(bool show=True) -> bool + + + + + + Hide() -> bool + + + Enable(bool enable=True) -> bool + + + + + + Disable() -> bool + + + IsShown() -> bool + + + IsEnabled() -> bool + + + SetWindowStyleFlag(long style) + + + + + + GetWindowStyleFlag() -> long + + + SetWindowStyle(long style) + + + + + + GetWindowStyle() -> long + + + HasFlag(int flag) -> bool + + + + + + IsRetained() -> bool + + + SetExtraStyle(long exStyle) + + + + + + GetExtraStyle() -> long + + + MakeModal(bool modal=True) + + + + + + SetThemeEnabled(bool enableTheme) + + + + + + GetThemeEnabled() -> bool + + + ShouldInheritColours() -> bool + + + SetFocus() + + + SetFocusFromKbd() + + + Window.FindFocus() -> Window + + + AcceptsFocus() -> bool + + + AcceptsFocusFromKeyboard() -> bool + + + GetDefaultItem() -> Window + + + SetDefaultItem(Window child) -> Window + + + + + + SetTmpDefaultItem(Window win) + + + + + + GetChildren() -> PyObject + + + GetParent() -> Window + + + GetGrandParent() -> Window + + + IsTopLevel() -> bool + + + Reparent(Window newParent) -> bool + + + + + + AddChild(Window child) + + + + + + RemoveChild(Window child) + + + + + + FindWindowById(long winid) -> Window + + + + + + FindWindowByName(String name) -> Window + + + + + + GetEventHandler() -> EvtHandler + + + SetEventHandler(EvtHandler handler) + + + + + + PushEventHandler(EvtHandler handler) + + + + + + PopEventHandler(bool deleteHandler=False) -> EvtHandler + + + + + + RemoveEventHandler(EvtHandler handler) -> bool + + + + + + SetValidator(Validator validator) + + + + + + GetValidator() -> Validator + + + SetAcceleratorTable(AcceleratorTable accel) + + + + + + GetAcceleratorTable() -> AcceleratorTable + + + RegisterHotKey(int hotkeyId, int modifiers, int keycode) -> bool + + + + + + + + UnregisterHotKey(int hotkeyId) -> bool + + + + + + ConvertDialogPointToPixels(Point pt) -> Point + + + + + + ConvertDialogSizeToPixels(Size sz) -> Size + + + + + + DLG_PNT(Point pt) -> Point + + + + + + DLG_SZE(Size sz) -> Size + + + + + + ConvertPixelPointToDialog(Point pt) -> Point + + + + + + ConvertPixelSizeToDialog(Size sz) -> Size + + + + + + WarpPointer(int x, int y) + + + + + + + CaptureMouse() + + + ReleaseMouse() + + + Window.GetCapture() -> Window + + + HasCapture() -> bool + + + Refresh(bool eraseBackground=True, Rect rect=None) + + + + + + + RefreshRect(Rect rect) + + + + + + Update() + + + ClearBackground() + + + Freeze() + + + Thaw() + + + PrepareDC(DC dc) + + + + + + GetUpdateRegion() -> Region + + + GetUpdateClientRect() -> Rect + + + IsExposed(int x, int y, int w=1, int h=1) -> bool + + + + + + + + + IsExposedPoint(Point pt) -> bool + + + + + + isExposedRect(Rect rect) -> bool + + + + + + SetBackgroundColour(Colour colour) -> bool + + + + + + SetForegroundColour(Colour colour) -> bool + + + + + + GetBackgroundColour() -> Colour + + + GetForegroundColour() -> Colour + + + SetCursor(Cursor cursor) -> bool + + + + + + GetCursor() -> Cursor + + + SetFont(Font font) -> bool + + + + + + GetFont() -> Font + + + SetCaret(Caret caret) + + + + + + GetCaret() -> Caret + + + GetCharHeight() -> int + + + GetCharWidth() -> int + + + GetTextExtent(String string) -> (width, height) + Get the width and height of the text using the current font. + + + + + + + + GetFullTextExtent(String string, Font font=None) -> + (width, height, descent, externalLeading) + Get the width, height, decent and leading of the text using the current or specified font. + + + + + + + + + + + ClientToScreenXY(int x, int y) + + + + + + + ScreenToClientXY(int x, int y) + + + + + + + ClientToScreen(Point pt) -> Point + + + + + + ScreenToClient(Point pt) -> Point + + + + + + HitTestXY(int x, int y) -> int + + + + + + + HitTest(Point pt) -> int + + + + + + GetBorderFlags(long flags) -> int + + + + + + GetBorder() -> int + + + UpdateWindowUI(long flags=UPDATE_UI_NONE) + + + + + + PopupMenuXY(Menu menu, int x, int y) -> bool + + + + + + + + PopupMenu(Menu menu, Point pos) -> bool + + + + + + + GetHandle() -> long + + + HasScrollbar(int orient) -> bool + + + + + + SetScrollbar(int orient, int pos, int thumbvisible, int range, bool refresh=True) + + + + + + + + + + SetScrollPos(int orient, int pos, bool refresh=True) + + + + + + + + GetScrollPos(int orient) -> int + + + + + + GetScrollThumb(int orient) -> int + + + + + + GetScrollRange(int orient) -> int + + + + + + ScrollWindow(int dx, int dy, Rect rect=None) + + + + + + + + ScrollLines(int lines) -> bool + + + + + + ScrollPages(int pages) -> bool + + + + + + LineUp() -> bool + + + LineDown() -> bool + + + PageUp() -> bool + + + PageDown() -> bool + + + SetHelpText(String text) + + + + + + SetHelpTextForId(String text) + + + + + + GetHelpText() -> String + + + SetToolTipString(String tip) + + + + + + SetToolTip(ToolTip tip) + + + + + + GetToolTip() -> ToolTip + + + SetDropTarget(PyDropTarget dropTarget) + + + + + + GetDropTarget() -> PyDropTarget + + + SetConstraints(LayoutConstraints constraints) + + + + + + GetConstraints() -> LayoutConstraints + + + SetAutoLayout(bool autoLayout) + + + + + + GetAutoLayout() -> bool + + + Layout() -> bool + + + SetSizer(Sizer sizer, bool deleteOld=True) + + + + + + + SetSizerAndFit(Sizer sizer, bool deleteOld=True) + + + + + + + GetSizer() -> Sizer + + + SetContainingSizer(Sizer sizer) + + + + + + GetContainingSizer() -> Sizer + + + +def DLG_PNT(win, point_or_x, y=None): + if y is None: + return win.ConvertDialogPointToPixels(point_or_x) + else: + return win.ConvertDialogPointToPixels(wx.Point(point_or_x, y)) + +def DLG_SZE(win, size_width, height=None): + if height is None: + return win.ConvertDialogSizeToPixels(size_width) + else: + return win.ConvertDialogSizeToPixels(wx.Size(size_width, height)) + + + FindWindowById(long id, Window parent=None) -> Window + + + + + + + FindWindowByName(String name, Window parent=None) -> Window + + + + + + + FindWindowByLabel(String label, Window parent=None) -> Window + + + + + + + Window_FromHWND(unsigned long hWnd) -> Window + + + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> Validator + + + Clone() -> Validator + + + Validate(Window parent) -> bool + + + + + + TransferToWindow() -> bool + + + TransferFromWindow() -> bool + + + GetWindow() -> Window + + + SetWindow(Window window) + + + + + + Validator.IsSilent() -> bool + + + Validator.SetBellOnError(int doIt=True) + + + + + + + + + __init__() -> PyValidator + + + _setCallbackInfo(PyObject self, PyObject _class, int incref=True) + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(String title=EmptyString, long style=0) -> Menu + + + + + + + Append(int id, String text, String help=EmptyString, int kind=ITEM_NORMAL) + + + + + + + + + AppendSeparator() + + + AppendCheckItem(int id, String text, String help=EmptyString) + + + + + + + + AppendRadioItem(int id, String text, String help=EmptyString) + + + + + + + + AppendMenu(int id, String text, Menu submenu, String help=EmptyString) + + + + + + + + + AppendItem(MenuItem item) + + + + + + Break() + + + InsertItem(size_t pos, MenuItem item) -> bool + + + + + + + Insert(size_t pos, int id, String text, String help=EmptyString, + int kind=ITEM_NORMAL) + + + + + + + + + + InsertSeparator(size_t pos) + + + + + + InsertCheckItem(size_t pos, int id, String text, String help=EmptyString) + + + + + + + + + InsertRadioItem(size_t pos, int id, String text, String help=EmptyString) + + + + + + + + + InsertMenu(size_t pos, int id, String text, Menu submenu, String help=EmptyString) + + + + + + + + + + PrependItem(MenuItem item) + + + + + + Prepend(int id, String text, String help=EmptyString, int kind=ITEM_NORMAL) + + + + + + + + + PrependSeparator() + + + PrependCheckItem(int id, String text, String help=EmptyString) + + + + + + + + PrependRadioItem(int id, String text, String help=EmptyString) + + + + + + + + PrependMenu(int id, String text, Menu submenu, String help=EmptyString) + + + + + + + + + Remove(int id) -> MenuItem + + + + + + RemoveItem(MenuItem item) -> MenuItem + + + + + + Delete(int id) -> bool + + + + + + DeleteItem(MenuItem item) -> bool + + + + + + Destroy() + Deletes the C++ object this Python object is a proxy for. + + + DestroyId(int id) -> bool + Deletes the C++ object this Python object is a proxy for. + + + + + + DestroyItem(MenuItem item) -> bool + Deletes the C++ object this Python object is a proxy for. + + + + + + GetMenuItemCount() -> size_t + + + GetMenuItems() -> PyObject + + + FindItem(String item) -> int + + + + + + FindItemById(int id) -> MenuItem + + + + + + FindItemByPosition(size_t position) -> MenuItem + + + + + + Enable(int id, bool enable) + + + + + + + IsEnabled(int id) -> bool + + + + + + Check(int id, bool check) + + + + + + + IsChecked(int id) -> bool + + + + + + SetLabel(int id, String label) + + + + + + + GetLabel(int id) -> String + + + + + + SetHelpString(int id, String helpString) + + + + + + + GetHelpString(int id) -> String + + + + + + SetTitle(String title) + + + + + + GetTitle() -> String + + + SetEventHandler(EvtHandler handler) + + + + + + GetEventHandler() -> EvtHandler + + + SetInvokingWindow(Window win) + + + + + + GetInvokingWindow() -> Window + + + GetStyle() -> long + + + UpdateUI(EvtHandler source=None) + + + + + + GetMenuBar() -> MenuBar + + + Attach(wxMenuBarBase menubar) + + + + + + Detach() + + + IsAttached() -> bool + + + SetParent(Menu parent) + + + + + + GetParent() -> Menu + + + +#--------------------------------------------------------------------------- + + + + + __init__(long style=0) -> MenuBar + + + + + + Append(Menu menu, String title) -> bool + + + + + + + Insert(size_t pos, Menu menu, String title) -> bool + + + + + + + + GetMenuCount() -> size_t + + + GetMenu(size_t pos) -> Menu + + + + + + Replace(size_t pos, Menu menu, String title) -> Menu + + + + + + + + Remove(size_t pos) -> Menu + + + + + + EnableTop(size_t pos, bool enable) + + + + + + + IsEnabledTop(size_t pos) -> bool + + + + + + SetLabelTop(size_t pos, String label) + + + + + + + GetLabelTop(size_t pos) -> String + + + + + + FindMenuItem(String menu, String item) -> int + + + + + + + FindItemById(int id) -> MenuItem + + + + + + FindMenu(String title) -> int + + + + + + Enable(int id, bool enable) + + + + + + + Check(int id, bool check) + + + + + + + IsChecked(int id) -> bool + + + + + + IsEnabled(int id) -> bool + + + + + + SetLabel(int id, String label) + + + + + + + GetLabel(int id) -> String + + + + + + SetHelpString(int id, String helpString) + + + + + + + GetHelpString(int id) -> String + + + + + + GetFrame() -> wxFrame + + + IsAttached() -> bool + + + Attach(wxFrame frame) + + + + + + Detach() + + + +#--------------------------------------------------------------------------- + + + + + __init__(Menu parentMenu=None, int id=ID_SEPARATOR, String text=EmptyString, + String help=EmptyString, int kind=ITEM_NORMAL, + Menu subMenu=None) -> MenuItem + + + + + + + + + + + GetMenu() -> Menu + + + SetMenu(Menu menu) + + + + + + SetId(int id) + + + + + + GetId() -> int + + + IsSeparator() -> bool + + + SetText(String str) + + + + + + GetLabel() -> String + + + GetText() -> String + + + MenuItem.GetLabelFromText(String text) -> String + + + + + + GetKind() -> int + + + SetCheckable(bool checkable) + + + + + + IsCheckable() -> bool + + + IsSubMenu() -> bool + + + SetSubMenu(Menu menu) + + + + + + GetSubMenu() -> Menu + + + Enable(bool enable=True) + + + + + + IsEnabled() -> bool + + + Check(bool check=True) + + + + + + IsChecked() -> bool + + + Toggle() + + + SetHelp(String str) + + + + + + GetHelp() -> String + + + GetAccel() -> AcceleratorEntry + + + SetAccel(AcceleratorEntry accel) + + + + + + MenuItem.GetDefaultMarginWidth() -> int + + + SetBitmap(Bitmap bitmap) + + + + + + GetBitmap() -> Bitmap + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, Validator validator=DefaultValidator, + String name=ControlNameStr) -> Control + + + + + + + + + + + + PreControl() -> Control + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, Validator validator=DefaultValidator, + String name=ControlNameStr) -> bool + + + + + + + + + + + + Command(CommandEvent event) + + + + + + GetLabel() -> String + + + SetLabel(String label) + + + + + + +#--------------------------------------------------------------------------- + + + + Append(String item, PyObject clientData=None) -> int + + + + + + + AppendItems(wxArrayString strings) + + + + + + Insert(String item, int pos, PyObject clientData=None) -> int + + + + + + + + Clear() + + + Delete(int n) + + + + + + GetCount() -> int + + + IsEmpty() -> bool + + + GetString(int n) -> String + + + + + + GetStrings() -> wxArrayString + + + SetString(int n, String s) + + + + + + + FindString(String s) -> int + + + + + + Select(int n) + + + + + + GetSelection() -> int + + + GetStringSelection() -> String + + + GetClientData(int n) -> PyObject + + + + + + SetClientData(int n, PyObject clientData) + + + + + + + +#--------------------------------------------------------------------------- + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> SizerItem + + + SizerItemSpacer(int width, int height, int proportion, int flag, int border, + Object userData) -> SizerItem + + + + + + + + + + + SizerItemWindow(Window window, int proportion, int flag, int border, + Object userData) -> SizerItem + + + + + + + + + + SizerItemSizer(Sizer sizer, int proportion, int flag, int border, + Object userData) -> SizerItem + + + + + + + + + + DeleteWindows() + + + DetachSizer() + + + GetSize() -> Size + + + CalcMin() -> Size + + + SetDimension(Point pos, Size size) + + + + + + + GetMinSize() -> Size + + + SetInitSize(int x, int y) + + + + + + + SetRatioWH(int width, int height) + + + + + + + SetRatioSize(Size size) + + + + + + SetRatio(float ratio) + + + + + + GetRatio() -> float + + + IsWindow() -> bool + + + IsSizer() -> bool + + + IsSpacer() -> bool + + + SetProportion(int proportion) + + + + + + GetProportion() -> int + + + SetFlag(int flag) + + + + + + GetFlag() -> int + + + SetBorder(int border) + + + + + + GetBorder() -> int + + + GetWindow() -> Window + + + SetWindow(Window window) + + + + + + GetSizer() -> Sizer + + + SetSizer(Sizer sizer) + + + + + + GetSpacer() -> Size + + + SetSpacer(Size size) + + + + + + Show(bool show) + + + + + + IsShown() -> bool + + + GetPosition() -> Point + + + GetUserData() -> PyObject + + + + + + _setOORInfo(PyObject _self) + + + + + + Add(PyObject item, int proportion=0, int flag=0, int border=0, + PyObject userData=None) + + + + + + + + + + Insert(int before, PyObject item, int proportion=0, int flag=0, + int border=0, PyObject userData=None) + + + + + + + + + + + Prepend(PyObject item, int proportion=0, int flag=0, int border=0, + PyObject userData=None) + + + + + + + + + + Remove(PyObject item) -> bool + + + + + + _SetItemMinSize(PyObject item, Size size) + + + + + + + AddItem(SizerItem item) + + + + + + InsertItem(size_t index, SizerItem item) + + + + + + + PrependItem(SizerItem item) + + + + + + SetDimension(int x, int y, int width, int height) + + + + + + + + + SetMinSize(Size size) + + + + + + GetSize() -> Size + + + GetPosition() -> Point + + + GetMinSize() -> Size + + + RecalcSizes() + + + CalcMin() -> Size + + + Layout() + + + Fit(Window window) -> Size + + + + + + FitInside(Window window) + + + + + + SetSizeHints(Window window) + + + + + + SetVirtualSizeHints(Window window) + + + + + + Clear(bool delete_windows=False) + + + + + + DeleteWindows() + + + GetChildren() -> PyObject + + + Show(PyObject item, bool show=True) + + + + + + + Hide(PyObject item) + + + + + + IsShown(PyObject item) -> bool + + + + + + ShowItems(bool show) + + + + + + + + + __init__() -> PySizer + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(int orient=HORIZONTAL) -> BoxSizer + + + + + + GetOrientation() -> int + + + SetOrientation(int orient) + + + + + + RecalcSizes() + + + CalcMin() -> Size + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxStaticBox box, int orient=HORIZONTAL) -> StaticBoxSizer + + + + + + + GetStaticBox() -> wxStaticBox + + + RecalcSizes() + + + CalcMin() -> Size + + + +#--------------------------------------------------------------------------- + + + + + __init__(int rows=1, int cols=0, int vgap=0, int hgap=0) -> GridSizer + + + + + + + + + RecalcSizes() + + + CalcMin() -> Size + + + SetCols(int cols) + + + + + + SetRows(int rows) + + + + + + SetVGap(int gap) + + + + + + SetHGap(int gap) + + + + + + GetCols() -> int + + + GetRows() -> int + + + GetVGap() -> int + + + GetHGap() -> int + + + +#--------------------------------------------------------------------------- + + + + + __init__(int rows=1, int cols=0, int vgap=0, int hgap=0) -> FlexGridSizer + + + + + + + + + RecalcSizes() + + + CalcMin() -> Size + + + AddGrowableRow(size_t idx, int proportion=0) + + + + + + + RemoveGrowableRow(size_t idx) + + + + + + AddGrowableCol(size_t idx, int proportion=0) + + + + + + + RemoveGrowableCol(size_t idx) + + + + + + SetFlexibleDirection(int direction) + + + + + + GetFlexibleDirection() -> int + + + SetNonFlexibleGrowMode(int mode) + + + + + + GetNonFlexibleGrowMode() -> int + + + GetRowHeights() -> wxArrayInt + + + GetColWidths() -> wxArrayInt + + + +#--------------------------------------------------------------------------- + + + + __init__(int row=0, int col=0) -> GBPosition + + + + + + + GetRow() -> int + + + GetCol() -> int + + + SetRow(int row) + + + + + + SetCol(int col) + + + + + + __eq__(GBPosition p) -> bool + + + + + + __ne__(GBPosition p) -> bool + + + + + + Set(int row=0, int col=0) + + + + + + + Get() -> PyObject + + + + + __init__(int rowspan=1, int colspan=1) -> GBSpan + + + + + + + GetRowspan() -> int + + + GetColspan() -> int + + + SetRowspan(int rowspan) + + + + + + SetColspan(int colspan) + + + + + + __eq__(GBSpan o) -> bool + + + + + + __ne__(GBSpan o) -> bool + + + + + + Set(int rowspan=1, int colspan=1) + + + + + + + Get() -> PyObject + + + + + + __init__() -> GBSizerItem + + + GBSizerItemWindow(Window window, GBPosition pos, GBSpan span, int flag, + int border, Object userData) -> GBSizerItem + + + + + + + + + + + GBSizerItemSizer(Sizer sizer, GBPosition pos, GBSpan span, int flag, + int border, Object userData) -> GBSizerItem + + + + + + + + + + + GBSizerItemSpacer(int width, int height, GBPosition pos, GBSpan span, + int flag, int border, Object userData) -> GBSizerItem + + + + + + + + + + + + GetPos() -> GBPosition + + + GetSpan() -> GBSpan + + + SetPos(GBPosition pos) -> bool + + + + + + SetSpan(GBSpan span) -> bool + + + + + + + + + + + Intersects(GBSizerItem other) -> bool +Intersects(GBPosition pos, GBSpan span) -> bool + + + + + + + GetEndPos(int row, int col) + + + + + + + GetGBSizer() -> GridBagSizer + + + SetGBSizer(GridBagSizer sizer) + + + + + + + + + __init__(int vgap=0, int hgap=0) -> GridBagSizer + + + + + + + Add(PyObject item, GBPosition pos, GBSpan span=DefaultSpan, + int flag=0, int border=0, PyObject userData=None) -> bool + + + + + + + + + + + AddItem(GBSizerItem item) -> bool + + + + + + GetEmptyCellSize() -> Size + + + SetEmptyCellSize(Size sz) + + + + + + + + + + + + + + + + GetItemPosition(Window window) -> GBPosition +GetItemPosition(Sizer sizer) -> GBPosition +GetItemPosition(size_t index) -> GBPosition + + + + + + + + + + + + + + + + + + SetItemPosition(Window window, GBPosition pos) -> bool +SetItemPosition(Sizer sizer, GBPosition pos) -> bool +SetItemPosition(size_t index, GBPosition pos) -> bool + + + + + + + + + + + + + + + + + GetItemSpan(Window window) -> GBSpan +GetItemSpan(Sizer sizer) -> GBSpan +GetItemSpan(size_t index) -> GBSpan + + + + + + + + + + + + + + + + + + SetItemSpan(Window window, GBSpan span) -> bool +SetItemSpan(Sizer sizer, GBSpan span) -> bool +SetItemSpan(size_t index, GBSpan span) -> bool + + + + + + + + + + + + FindItem(Window window) -> GBSizerItem +FindItem(Sizer sizer) -> GBSizerItem + + + + + + FindItemAtPosition(GBPosition pos) -> GBSizerItem + + + + + + FindItemAtPoint(Point pt) -> GBSizerItem + + + + + + FindItemWithData(Object userData) -> GBSizerItem + + + + + + RecalcSizes() + + + CalcMin() -> Size + + + + + + + + + CheckForIntersection(GBSizerItem item, GBSizerItem excludeItem=None) -> bool +CheckForIntersection(GBPosition pos, GBSpan span, GBSizerItem excludeItem=None) -> bool + + + + + + + + +#--------------------------------------------------------------------------- + + + + + Set(int rel, Window otherW, int otherE, int val=0, int marg=wxLAYOUT_DEFAULT_MARGIN) + + + + + + + + + + LeftOf(Window sibling, int marg=0) + + + + + + + RightOf(Window sibling, int marg=0) + + + + + + + Above(Window sibling, int marg=0) + + + + + + + Below(Window sibling, int marg=0) + + + + + + + SameAs(Window otherW, int edge, int marg=0) + + + + + + + + PercentOf(Window otherW, int wh, int per) + + + + + + + + Absolute(int val) + + + + + + Unconstrained() + + + AsIs() + + + GetOtherWindow() -> Window + + + GetMyEdge() -> int + + + SetEdge(int which) + + + + + + SetValue(int v) + + + + + + GetMargin() -> int + + + SetMargin(int m) + + + + + + GetValue() -> int + + + GetPercent() -> int + + + GetOtherEdge() -> int + + + GetDone() -> bool + + + SetDone(bool d) + + + + + + GetRelationship() -> int + + + SetRelationship(int r) + + + + + + ResetIfWin(Window otherW) -> bool + + + + + + SatisfyConstraint(LayoutConstraints constraints, Window win) -> bool + + + + + + + GetEdge(int which, Window thisWin, Window other) -> int + + + + + + + + + + + __init__() -> LayoutConstraints + + + + + + + + + + + SatisfyConstraints(Window win) -> (areSatisfied, noChanges) + + + + + + + AreSatisfied() -> bool + + + #---------------------------------------------------------------------------- + +# Use Python's bool constants if available, make some if not +try: + True +except NameError: + __builtins__.True = 1==1 + __builtins__.False = 1==0 + + + +# workarounds for bad wxRTTI names +__wxPyPtrTypeMap['wxGauge95'] = 'wxGauge' +__wxPyPtrTypeMap['wxSlider95'] = 'wxSlider' +__wxPyPtrTypeMap['wxStatusBar95'] = 'wxStatusBar' + + +#---------------------------------------------------------------------------- +# Load version numbers from __version__... Ensure that major and minor +# versions are the same for both wxPython and wxWindows. + +from __version__ import * +__version__ = VERSION_STRING + +assert MAJOR_VERSION == _core.MAJOR_VERSION, "wxPython/wxWindows version mismatch" +assert MINOR_VERSION == _core.MINOR_VERSION, "wxPython/wxWindows version mismatch" +if RELEASE_VERSION != _core.RELEASE_VERSION: + import warnings + warnings.warn("wxPython/wxWindows release number mismatch") + +#---------------------------------------------------------------------------- + +class PyDeadObjectError(AttributeError): + pass + +class _wxPyDeadObject(object): + """ + Instances of wx objects that are OOR capable will have their __class__ + changed to this class when the C++ object is deleted. This should help + prevent crashes due to referencing a bogus C++ pointer. + """ + reprStr = "wxPython wrapper for DELETED %s object! (The C++ object no longer exists.)" + attrStr = "The C++ part of the %s object has been deleted, attribute access no longer allowed." + + def __repr__(self): + if not hasattr(self, "_name"): + self._name = "[unknown]" + return self.reprStr % self._name + + def __getattr__(self, *args): + if not hasattr(self, "_name"): + self._name = "[unknown]" + raise PyDeadObjectError(self.attrStr % self._name) + + def __nonzero__(self): + return 0 + + + +class PyUnbornObjectError(AttributeError): + pass + +class _wxPyUnbornObject(object): + """ + Some stock objects are created when the wx.core module is + imported, but their C++ instance is not created until the wx.App + object is created and initialized. These object instances will + temporarily have their __class__ changed to this class so an + exception will be raised if they are used before the C++ instance + is ready. + """ + + reprStr = "wxPython wrapper for UNBORN object! (The C++ object is not initialized yet.)" + attrStr = "The C++ part of this object has not been initialized, attribute access not allowed." + + def __repr__(self): + #if not hasattr(self, "_name"): + # self._name = "[unknown]" + return self.reprStr #% self._name + + def __getattr__(self, *args): + #if not hasattr(self, "_name"): + # self._name = "[unknown]" + raise PyUnbornObjectError(self.attrStr) # % self._name ) + + def __nonzero__(self): + return 0 + + +#---------------------------------------------------------------------------- +_wxPyCallAfterId = None + +def CallAfter(callable, *args, **kw): + """ + Call the specified function after the current and pending event + handlers have been completed. This is also good for making GUI + method calls from non-GUI threads. + """ + app = wx.GetApp() + assert app, 'No wxApp created yet' + + global _wxPyCallAfterId + if _wxPyCallAfterId is None: + _wxPyCallAfterId = wx.NewEventType() + app.Connect(-1, -1, _wxPyCallAfterId, + lambda event: event.callable(*event.args, **event.kw) ) + evt = wx.PyEvent() + evt.SetEventType(_wxPyCallAfterId) + evt.callable = callable + evt.args = args + evt.kw = kw + wx.PostEvent(app, evt) + + +#---------------------------------------------------------------------------- + + +class FutureCall: + """ + A convenience class for wxTimer, that calls the given callable + object once after the given amount of milliseconds, passing any + positional or keyword args. The return value of the callable is + availbale after it has been run with the GetResult method. + + If you don't need to get the return value or restart the timer + 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 + object. + """ + def __init__(self, millis, callable, *args, **kwargs): + self.millis = millis + self.callable = callable + self.SetArgs(*args, **kwargs) + self.runCount = 0 + self.hasRun = False + self.result = None + self.timer = None + self.Start() + + def __del__(self): + self.Stop() + + + def Start(self, millis=None, *args, **kwargs): + """ + (Re)start the timer + """ + self.hasRun = False + if millis is not None: + self.millis = millis + if args or kwargs: + self.SetArgs(*args, **kwargs) + self.Stop() + self.timer = wx.PyTimer(self.Notify) + self.timer.Start(self.millis, wx.TIMER_ONE_SHOT) + Restart = Start + + + def Stop(self): + """ + Stop and destroy the timer. + """ + if self.timer is not None: + self.timer.Stop() + self.timer = None + + + def GetInterval(self): + if self.timer is not None: + return self.timer.GetInterval() + else: + return 0 + + + def IsRunning(self): + return self.timer is not None and self.timer.IsRunning() + + + def SetArgs(self, *args, **kwargs): + """ + (Re)set the args passed to the callable object. This is + useful in conjunction with Restart if you want to schedule a + new call to the same callable object but with different + parameters. + """ + self.args = args + self.kwargs = kwargs + + + def HasRun(self): + return self.hasRun + + def GetResult(self): + return self.result + + def Notify(self): + """ + The timer has expired so call the callable. + """ + if self.callable and getattr(self.callable, 'im_self', True): + self.runCount += 1 + self.result = self.callable(*self.args, **self.kwargs) + self.hasRun = True + wx.CallAfter(self.Stop) + + +#---------------------------------------------------------------------------- +#---------------------------------------------------------------------------- + +# Import other modules in this package that should show up in the +# "core" wx namespace +from gdi import * +from windows import * +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() + +#---------------------------------------------------------------------------- +#---------------------------------------------------------------------------- + + + + wx = core + +#--------------------------------------------------------------------------- + + + + + __init__() -> GDIObject + + + __del__() + + + GetVisible() -> bool + + + SetVisible(bool visible) + + + + + + IsNull() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__(unsigned char red=0, unsigned char green=0, unsigned char blue=0) -> Colour + + + + + + + + NamedColour(String colorName) -> Colour + + + + + + ColourRGB(unsigned long colRGB) -> Colour + + + + + + __del__() + + + Red() -> unsigned char + + + Green() -> unsigned char + + + Blue() -> unsigned char + + + Ok() -> bool + + + Set(unsigned char red, unsigned char green, unsigned char blue) + + + + + + + + SetRGB(unsigned long colRGB) + + + + + + __eq__(Colour colour) -> bool + + + + + + __ne__(Colour colour) -> bool + + + + + + InitFromName(String colourName) + + + + + + Get() -> PyObject + + + + Color = Colour + NamedColor = NamedColour + + + + + __init__(int n, unsigned char red, unsigned char green, unsigned char blue) -> Palette + + + + + + + + + __del__() + + + GetPixel(byte red, byte green, byte blue) -> int + + + + + + + + GetRGB(int pixel) -> (R,G,B) + + + + + + + + + Ok() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__(Colour colour, int width=1, int style=SOLID) -> Pen + + + + + + + + __del__() + + + GetCap() -> int + + + GetColour() -> Colour + + + GetJoin() -> int + + + GetStyle() -> int + + + GetWidth() -> int + + + Ok() -> bool + + + SetCap(int cap_style) + + + + + + SetColour(Colour colour) + + + + + + SetJoin(int join_style) + + + + + + SetStyle(int style) + + + + + + SetWidth(int width) + + + + + + SetDashes(int dashes, wxDash dashes_array) + + + + + + + GetDashes() -> PyObject + + + GetDashCount() -> int + + + + + + __init__(Colour colour, int width=1, int style=SOLID) -> PyPen + + + + + + + + __del__() + + + SetDashes(int dashes, wxDash dashes_array) + + + + + + + Pen = PyPen + +#--------------------------------------------------------------------------- + + + A brush is a drawing tool for filling in areas. It is used for painting the +background of rectangles, ellipses, etc. It has a colour and a style. + + + __init__(Colour colour, int style=SOLID) -> Brush + Constructs a brush from a colour object and style. + + + + + + + __del__() + + + SetColour(Colour col) + + + + + + SetStyle(int style) + + + + + + SetStipple(Bitmap stipple) + + + + + + GetColour() -> Colour + + + GetStyle() -> int + + + GetStipple() -> Bitmap + + + Ok() -> bool + + + + + + __init__(String name, int type=BITMAP_TYPE_ANY) -> Bitmap + Loads a bitmap from a file. + + + + + + + EmptyBitmap(int width, int height, int depth=-1) -> Bitmap + Creates a new bitmap of the given size. A depth of -1 indicates the depth of +the current screen or visual. Some platforms only support 1 for monochrome and +-1 for the current colour setting. + + + + + + + + BitmapFromIcon(Icon icon) -> Bitmap + Create a new bitmap from an Icon object. + + + + + + BitmapFromImage(Image image, int depth=-1) -> Bitmap + Creates bitmap object from the image. This has to be done to actually display +an image as you cannot draw an image directly on a window. The resulting +bitmap will use the provided colour depth (or that of the current system if +depth is -1) which entails that a colour reduction has to take place. + + + + + + + BitmapFromXPMData(PyObject listOfStrings) -> Bitmap + Construct a Bitmap from a list of strings formatted as XPM data. + + + + + + BitmapFromBits(PyObject bits, int width, int height, int depth=1) -> Bitmap + Creates a bitmap from an array of bits. You should only use this function for +monochrome bitmaps (depth 1) in portable programs: in this case the bits +parameter should contain an XBM image. For other bit depths, the behaviour is +platform dependent. + + + + + + + + + __del__() + + + Ok() -> bool + + + GetWidth() -> int + Gets the width of the bitmap in pixels. + + + GetHeight() -> int + Gets the height of the bitmap in pixels. + + + GetDepth() -> int + Gets the colour depth of the bitmap. A value of 1 indicates a +monochrome bitmap. + + + ConvertToImage() -> Image + Creates a platform-independent image from a platform-dependent bitmap. This +preserves mask information so that bitmaps and images can be converted back +and forth without loss in that respect. + + + GetMask() -> Mask + Gets the associated mask (if any) which may have been loaded from a file +or explpicitly set for the bitmap. + + + SetMask(Mask mask) + Sets the mask for this bitmap. + + + + + + SetMaskColour(Colour colour) + Create a Mask based on a specified colour in the Bitmap. + + + + + + GetSubBitmap(Rect rect) -> Bitmap + Returns a sub bitmap of the current one as long as the rect belongs entirely +to the bitmap. This function preserves bit depth and mask information. + + + + + + SaveFile(String name, int type, Palette palette=(wxPalette *) NULL) -> bool + Saves a bitmap in the named file. + + + + + + + + LoadFile(String name, int type) -> bool + Loads a bitmap from a file + + + + + + + CopyFromIcon(Icon icon) -> bool + + + + + + SetHeight(int height) + Set the height property (does not affect the bitmap data). + + + + + + SetWidth(int width) + Set the width property (does not affect the bitmap data). + + + + + + SetDepth(int depth) + Set the depth property (does not affect the bitmap data). + + + + + + + This class encapsulates a monochrome mask bitmap, where the masked area is +black and the unmasked area is white. When associated with a bitmap and drawn +in a device context, the unmasked area of the bitmap will be drawn, and the +masked area will not be drawn. + + + __init__(Bitmap bitmap) -> Mask + Constructs a mask from a monochrome bitmap. + + + + + + MaskColour(Bitmap bitmap, Colour colour) -> Mask + Constructs a mask from a bitmap and a colour in that bitmap that indicates the +background. + + + + + + + + + + __init__(String name, long flags, int desiredWidth=-1, int desiredHeight=-1) -> Icon + + + + + + + + + EmptyIcon() -> Icon + + + IconFromLocation(IconLocation loc) -> Icon + + + + + + IconFromBitmap(Bitmap bmp) -> Icon + + + + + + IconFromXPMData(PyObject listOfStrings) -> Icon + + + + + + __del__() + + + LoadFile(String name, long flags) -> bool + + + + + + + Ok() -> bool + + + GetWidth() -> int + + + GetHeight() -> int + + + GetDepth() -> int + + + SetWidth(int w) + + + + + + SetHeight(int h) + + + + + + SetDepth(int d) + + + + + + CopyFromBitmap(Bitmap bmp) + + + + + + + + __init__(String filename=&wxPyEmptyString, int num=0) -> IconLocation + + + + + + + __del__() + + + IsOk() -> bool + + + SetFileName(String filename) + + + + + + GetFileName() -> String + + + SetIndex(int num) + + + + + + GetIndex() -> int + + + + + __init__() -> IconBundle + + + IconBundleFromFile(String file, long type) -> IconBundle + + + + + + + IconBundleFromIcon(Icon icon) -> IconBundle + + + + + + __del__() + + + AddIcon(Icon icon) + + + + + + AddIconFromFile(String file, long type) + + + + + + + GetIcon(Size size) -> Icon + + + + + + + + + __init__(String cursorName, long flags, int hotSpotX=0, int hotSpotY=0) -> Cursor + + + + + + + + + StockCursor(int id) -> Cursor + + + + + + CursorFromImage(Image image) -> Cursor + + + + + + CursorFromBits(PyObject bits, int width, int height, int hotSpotX=-1, + int hotSpotY=-1, PyObject maskBits=0) -> Cursor + + + + + + + + + + + __del__() + + + Ok() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__(int x=0, int y=0, int width=0, int height=0) -> Region + + + + + + + + + RegionFromBitmap(Bitmap bmp, Colour transColour=NullColour, int tolerance=0) -> Region + + + + + + + + RegionFromPoints(int points, Point points_array, int fillStyle=WINDING_RULE) -> Region + + + + + + + + __del__() + + + Clear() + + + Offset(int x, int y) -> bool + + + + + + + Contains(int x, int y) -> int + + + + + + + ContainsPoint(Point pt) -> int + + + + + + ContainsRect(Rect rect) -> int + + + + + + ContainsRectDim(int x, int y, int w, int h) -> int + + + + + + + + + GetBox() -> Rect + + + Intersect(int x, int y, int width, int height) -> bool + + + + + + + + + IntersectRect(Rect rect) -> bool + + + + + + IntersectRegion(Region region) -> bool + + + + + + IsEmpty() -> bool + + + Union(int x, int y, int width, int height) -> bool + + + + + + + + + UnionRect(Rect rect) -> bool + + + + + + UnionRegion(Region region) -> bool + + + + + + Subtract(int x, int y, int width, int height) -> bool + + + + + + + + + SubtractRect(Rect rect) -> bool + + + + + + SubtractRegion(Region region) -> bool + + + + + + Xor(int x, int y, int width, int height) -> bool + + + + + + + + + XorRect(Rect rect) -> bool + + + + + + XorRegion(Region region) -> bool + + + + + + ConvertToBitmap() -> Bitmap + + + UnionBitmap(Bitmap bmp, Colour transColour=NullColour, int tolerance=0) -> bool + + + + + + + + + + + __init__(Region region) -> RegionIterator + + + + + + __del__() + + + GetX() -> int + + + GetY() -> int + + + GetW() -> int + + + GetWidth() -> int + + + GetH() -> int + + + GetHeight() -> int + + + GetRect() -> Rect + + + HaveRects() -> bool + + + Reset() + + + Next() + + + __nonzero__() -> bool + + + +#--------------------------------------------------------------------------- + + +#--------------------------------------------------------------------------- + + + + __init__() -> NativeFontInfo + + + __del__() + + + Init() + + + InitFromFont(Font font) + + + + + + GetPointSize() -> int + + + GetStyle() -> int + + + GetWeight() -> int + + + GetUnderlined() -> bool + + + GetFaceName() -> String + + + GetFamily() -> int + + + GetEncoding() -> int + + + SetPointSize(int pointsize) + + + + + + SetStyle(int style) + + + + + + SetWeight(int weight) + + + + + + SetUnderlined(bool underlined) + + + + + + SetFaceName(String facename) + + + + + + SetFamily(int family) + + + + + + SetEncoding(int encoding) + + + + + + FromString(String s) -> bool + + + + + + ToString() -> String + + + __str__() -> String + + + FromUserString(String s) -> bool + + + + + + ToUserString() -> String + + + + + __init__() -> NativeEncodingInfo + + + __del__() + + + + + FromString(String s) -> bool + + + + + + ToString() -> String + + + + GetNativeFontEncoding(int encoding) -> NativeEncodingInfo + + + + + + TestFontEncoding(NativeEncodingInfo info) -> bool + + + + + +#--------------------------------------------------------------------------- + + + + __init__() -> FontMapper + + + __del__() + + + FontMapper.Get() -> FontMapper + + + FontMapper.Set(FontMapper mapper) -> FontMapper + + + + + + CharsetToEncoding(String charset, bool interactive=True) -> int + + + + + + + FontMapper.GetSupportedEncodingsCount() -> size_t + + + FontMapper.GetEncoding(size_t n) -> int + + + + + + FontMapper.GetEncodingName(int encoding) -> String + + + + + + FontMapper.GetEncodingDescription(int encoding) -> String + + + + + + SetConfig(ConfigBase config) + + + + + + SetConfigPath(String prefix) + + + + + + FontMapper.GetDefaultConfigPath() -> String + + + GetAltForEncoding(int encoding, String facename=EmptyString, bool interactive=True) -> PyObject + + + + + + + + IsEncodingAvailable(int encoding, String facename=EmptyString) -> bool + + + + + + + SetDialogParent(Window parent) + + + + + + SetDialogTitle(String title) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(int pointSize, int family, int style, int weight, bool underline=False, + String face=EmptyString, + int encoding=FONTENCODING_DEFAULT) -> Font + + + + + + + + + + + + FontFromNativeInfo(NativeFontInfo info) -> Font + + + + + + FontFromNativeInfoString(String info) -> Font + + + + + + Font2(int pointSize, int family, int flags=FONTFLAG_DEFAULT, + String face=EmptyString, int encoding=FONTENCODING_DEFAULT) -> Font + + + + + + + + + + __del__() + + + Ok() -> bool + + + __eq__(Font font) -> bool + + + + + + __ne__(Font font) -> bool + + + + + + GetPointSize() -> int + + + GetFamily() -> int + + + GetStyle() -> int + + + GetWeight() -> int + + + GetUnderlined() -> bool + + + GetFaceName() -> String + + + GetEncoding() -> int + + + GetNativeFontInfo() -> NativeFontInfo + + + IsFixedWidth() -> bool + + + GetNativeFontInfoDesc() -> String + + + GetNativeFontInfoUserDesc() -> String + + + SetPointSize(int pointSize) + + + + + + SetFamily(int family) + + + + + + SetStyle(int style) + + + + + + SetWeight(int weight) + + + + + + SetFaceName(String faceName) + + + + + + SetUnderlined(bool underlined) + + + + + + SetEncoding(int encoding) + + + + + + SetNativeFontInfo(NativeFontInfo info) + + + + + + SetNativeFontInfoFromString(String info) + + + + + + SetNativeFontInfoUserDesc(String info) + + + + + + GetFamilyString() -> String + + + GetStyleString() -> String + + + GetWeightString() -> String + + + SetNoAntiAliasing(bool no=True) + + + + + + GetNoAntiAliasing() -> bool + + + Font.GetDefaultEncoding() -> int + + + Font.SetDefaultEncoding(int encoding) + + + + + + +#--------------------------------------------------------------------------- + + + + __init__() -> FontEnumerator + + + __del__() + + + _setCallbackInfo(PyObject self, PyObject _class, bool incref) + + + + + + + + EnumerateFacenames(int encoding=FONTENCODING_SYSTEM, bool fixedWidthOnly=False) -> bool + + + + + + + EnumerateEncodings(String facename=EmptyString) -> bool + + + + + + GetEncodings() -> PyObject + + + GetFacenames() -> PyObject + + + +#--------------------------------------------------------------------------- + + + + + + + + + __init__(int language=LANGUAGE_DEFAULT, int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING) -> Locale + + + + + + + __del__() + + + Init1(String szName, String szShort=EmptyString, String szLocale=EmptyString, + bool bLoadDefault=True, + bool bConvertEncoding=False) -> bool + + + + + + + + + + Init2(int language=LANGUAGE_DEFAULT, int flags=wxLOCALE_LOAD_DEFAULT|wxLOCALE_CONV_ENCODING) -> bool + + + + + + + Locale.GetSystemLanguage() -> int + + + Locale.GetSystemEncoding() -> int + + + Locale.GetSystemEncodingName() -> String + + + IsOk() -> bool + + + GetLocale() -> String + + + GetLanguage() -> int + + + GetSysName() -> String + + + GetCanonicalName() -> String + + + Locale.AddCatalogLookupPathPrefix(String prefix) + + + + + + AddCatalog(String szDomain) -> bool + + + + + + IsLoaded(String szDomain) -> bool + + + + + + Locale.GetLanguageInfo(int lang) -> LanguageInfo + + + + + + Locale.GetLanguageName(int lang) -> String + + + + + + Locale.FindLanguageInfo(String locale) -> LanguageInfo + + + + + + Locale.AddLanguage(LanguageInfo info) + + + + + + GetString(String szOrigString, String szDomain=EmptyString) -> String + + + + + + + GetName() -> String + + + + GetLocale() -> Locale + + + + + + + + GetTranslation(String sz) -> String +GetTranslation(String sz1, String sz2, size_t n) -> String + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> EncodingConverter + + + __del__() + + + Init(int input_enc, int output_enc, int method=CONVERT_STRICT) -> bool + + + + + + + + Convert(String input) -> String + + + + + + EncodingConverter.GetPlatformEquivalents(int enc, int platform=PLATFORM_CURRENT) -> wxFontEncodingArray + + + + + + + EncodingConverter.GetAllEquivalents(int enc) -> wxFontEncodingArray + + + + + + EncodingConverter.CanConvert(int encIn, int encOut) -> bool + + + + + + + #---------------------------------------------------------------------------- +# wxGTK sets the locale when initialized. Doing this at the Python +# level should set it up to match what GTK is doing at the C level. +if wx.Platform == "__WXGTK__": + try: + import locale + locale.setlocale(locale.LC_ALL, "") + except: + pass + +# On MSW add the directory where the wxWindows catalogs were installed +# to the default catalog path. +if wx.Platform == "__WXMSW__": + import os + localedir = os.path.join(os.path.split(__file__)[0], "locale") + Locale_AddCatalogLookupPathPrefix(localedir) + del os + +#---------------------------------------------------------------------------- + + +#--------------------------------------------------------------------------- + + + + + __del__() + + + BeginDrawing() + + + EndDrawing() + + + FloodFillXY(int x, int y, Colour col, int style=FLOOD_SURFACE) -> bool + + + + + + + + + FloodFill(Point pt, Colour col, int style=FLOOD_SURFACE) -> bool + + + + + + + + GetPixelXY(int x, int y) -> Colour + + + + + + + GetPixel(Point pt) -> Colour + + + + + + DrawLineXY(int x1, int y1, int x2, int y2) + + + + + + + + + DrawLine(Point pt1, Point pt2) + + + + + + + CrossHairXY(int x, int y) + + + + + + + CrossHair(Point pt) + + + + + + DrawArcXY(int x1, int y1, int x2, int y2, int xc, int yc) + + + + + + + + + + + DrawArc(Point pt1, Point pt2, Point centre) + + + + + + + + DrawCheckMarkXY(int x, int y, int width, int height) + + + + + + + + + DrawCheckMark(Rect rect) + + + + + + DrawEllipticArcXY(int x, int y, int w, int h, double sa, double ea) + + + + + + + + + + + DrawEllipticArc(Point pt, Size sz, double sa, double ea) + + + + + + + + + DrawPointXY(int x, int y) + + + + + + + DrawPoint(Point pt) + + + + + + DrawRectangleXY(int x, int y, int width, int height) + + + + + + + + + DrawRectangle(Point pt, Size sz) + + + + + + + DrawRectangleRect(Rect rect) + + + + + + DrawRoundedRectangleXY(int x, int y, int width, int height, double radius) + + + + + + + + + + DrawRoundedRectangle(Point pt, Size sz, double radius) + + + + + + + + DrawRoundedRectangleRect(Rect r, double radius) + + + + + + + DrawCircleXY(int x, int y, int radius) + + + + + + + + DrawCircle(Point pt, int radius) + + + + + + + DrawEllipseXY(int x, int y, int width, int height) + + + + + + + + + DrawEllipse(Point pt, Size sz) + + + + + + + DrawEllipseRect(Rect rect) + + + + + + DrawIconXY(Icon icon, int x, int y) + + + + + + + + DrawIcon(Icon icon, Point pt) + + + + + + + DrawBitmapXY(Bitmap bmp, int x, int y, bool useMask=False) + + + + + + + + + DrawBitmap(Bitmap bmp, Point pt, bool useMask=False) + + + + + + + + DrawTextXY(String text, int x, int y) + + + + + + + + DrawText(String text, Point pt) + + + + + + + DrawRotatedTextXY(String text, int x, int y, double angle) + + + + + + + + + DrawRotatedText(String text, Point pt, double angle) + + + + + + + + BlitXY(int xdest, int ydest, int width, int height, DC source, + int xsrc, int ysrc, int rop=COPY, bool useMask=False, + int xsrcMask=-1, int ysrcMask=-1) -> bool + + + + + + + + + + + + + + + + Blit(Point destPt, Size sz, DC source, Point srcPt, int rop=COPY, + bool useMask=False, Point srcPtMask=DefaultPosition) -> bool + + + + + + + + + + + + DrawLines(int points, Point points_array, int xoffset=0, int yoffset=0) + + + + + + + + + DrawPolygon(int points, Point points_array, int xoffset=0, int yoffset=0, + int fillStyle=ODDEVEN_RULE) + + + + + + + + + + DrawLabel(String text, Rect rect, int alignment=wxALIGN_LEFT|wxALIGN_TOP, + int indexAccel=-1) + + + + + + + + + DrawImageLabel(String text, Bitmap image, Rect rect, int alignment=wxALIGN_LEFT|wxALIGN_TOP, + int indexAccel=-1) -> Rect + + + + + + + + + + DrawSpline(int points, Point points_array) + + + + + + + Clear() + + + StartDoc(String message) -> bool + + + + + + EndDoc() + + + StartPage() + + + EndPage() + + + SetFont(Font font) + + + + + + SetPen(Pen pen) + + + + + + SetBrush(Brush brush) + + + + + + SetBackground(Brush brush) + + + + + + SetBackgroundMode(int mode) + + + + + + SetPalette(Palette palette) + + + + + + SetClippingRegionXY(int x, int y, int width, int height) + + + + + + + + + SetClippingRegion(Point pt, Size sz) + + + + + + + SetClippingRect(Rect rect) + + + + + + SetClippingRegionAsRegion(Region region) + + + + + + DestroyClippingRegion() + + + GetClippingBox() -> (x, y, width, height) + + + + + + + + + GetClippingRect() -> Rect + + + GetCharHeight() -> int + + + GetCharWidth() -> int + + + GetTextExtent(wxString string) -> (width, height) + Get the width and height of the text using the current font. +Only works for single line strings. + + + + + + + + GetFullTextExtent(wxString string, Font font=None) -> + (width, height, descent, externalLeading) + Get the width, height, decent and leading of the text using the current or specified font. +Only works for single line strings. + + + + + + + + + + + GetMultiLineTextExtent(wxString string, Font font=None) -> + (width, height, descent, externalLeading) + Get the width, height, decent and leading of the text using the current or specified font. +Works for single as well as multi-line strings. + + + + + + + + + + GetSize() -> Size + Get the DC size in device units. + + + GetSizeTuple() -> (width, height) + Get the DC size in device units. + + + + + + + GetSizeMM() -> Size + Get the DC size in milimeters. + + + GetSizeMMTuple() -> (width, height) + Get the DC size in milimeters. + + + + + + + DeviceToLogicalX(int x) -> int + + + + + + DeviceToLogicalY(int y) -> int + + + + + + DeviceToLogicalXRel(int x) -> int + + + + + + DeviceToLogicalYRel(int y) -> int + + + + + + LogicalToDeviceX(int x) -> int + + + + + + LogicalToDeviceY(int y) -> int + + + + + + LogicalToDeviceXRel(int x) -> int + + + + + + LogicalToDeviceYRel(int y) -> int + + + + + + CanDrawBitmap() -> bool + + + CanGetTextExtent() -> bool + + + GetDepth() -> int + + + GetPPI() -> Size + + + Ok() -> bool + + + GetBackgroundMode() -> int + + + GetBackground() -> Brush + + + GetBrush() -> Brush + + + GetFont() -> Font + + + GetPen() -> Pen + + + GetTextBackground() -> Colour + + + GetTextForeground() -> Colour + + + SetTextForeground(Colour colour) + + + + + + SetTextBackground(Colour colour) + + + + + + GetMapMode() -> int + + + SetMapMode(int mode) + + + + + + GetUserScale() -> (xScale, yScale) + + + + + + + SetUserScale(double x, double y) + + + + + + + GetLogicalScale() -> (xScale, yScale) + + + + + + + SetLogicalScale(double x, double y) + + + + + + + GetLogicalOrigin() -> Point + + + GetLogicalOriginTuple() -> (x,y) + + + + + + + SetLogicalOrigin(int x, int y) + + + + + + + GetDeviceOrigin() -> Point + + + GetDeviceOriginTuple() -> (x,y) + + + + + + + SetDeviceOrigin(int x, int y) + + + + + + + SetAxisOrientation(bool xLeftRight, bool yBottomUp) + + + + + + + GetLogicalFunction() -> int + + + SetLogicalFunction(int function) + + + + + + SetOptimization(bool opt) + + + + + + GetOptimization() -> bool + + + CalcBoundingBox(int x, int y) + + + + + + + ResetBoundingBox() + + + MinX() -> int + + + MaxX() -> int + + + MinY() -> int + + + MaxY() -> int + + + GetBoundingBox() -> (x1,y1, x2,y2) + + + + + + + + + _DrawPointList(PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject + + + + + + + + _DrawLineList(PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject + + + + + + + + _DrawRectangleList(PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject + + + + + + + + _DrawEllipseList(PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject + + + + + + + + _DrawPolygonList(PyObject pyCoords, PyObject pyPens, PyObject pyBrushes) -> PyObject + + + + + + + + _DrawTextList(PyObject textList, PyObject pyPoints, PyObject foregroundList, + PyObject backgroundList) -> PyObject + + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> MemoryDC + + + MemoryDCFromDC(DC oldDC) -> MemoryDC + + + + + + SelectObject(Bitmap bitmap) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(DC dc, Bitmap buffer) -> BufferedDC + + + + + + + BufferedDCInternalBuffer(DC dc, Size area) -> BufferedDC + + + + + + + UnMask() + + + + + + __init__(Window window, Bitmap buffer=NullBitmap) -> BufferedPaintDC + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> ScreenDC + + + StartDrawingOnTopWin(Window window) -> bool + + + + + + StartDrawingOnTop(Rect rect=None) -> bool + + + + + + EndDrawingOnTop() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window win) -> ClientDC + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window win) -> PaintDC + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window win) -> WindowDC + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(DC dc, bool mirror) -> MirrorDC + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxPrintData printData) -> PostScriptDC + + + + + + GetPrintData() -> wxPrintData + + + SetPrintData(wxPrintData data) + + + + + + PostScriptDC.SetResolution(int ppi) + + + + + + PostScriptDC.GetResolution() -> int + + + +#--------------------------------------------------------------------------- + + + + + __init__(String filename=EmptyString) -> MetaFile + + + + + + + + + __init__(String filename=EmptyString, int width=0, int height=0, + String description=EmptyString) -> MetaFileDC + + + + + + + + + + + + __init__(wxPrintData printData) -> PrinterDC + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(int width, int height, int mask=True, int initialCount=1) -> ImageList + + + + + + + + + __del__() + + + Add(Bitmap bitmap, Bitmap mask=NullBitmap) -> int + + + + + + + AddWithColourMask(Bitmap bitmap, Colour maskColour) -> int + + + + + + + AddIcon(Icon icon) -> int + + + + + + Replace(int index, Bitmap bitmap) -> bool + + + + + + + Draw(int index, DC dc, int x, int x, int flags=IMAGELIST_DRAW_NORMAL, + bool solidBackground=False) -> bool + + + + + + + + + + + GetImageCount() -> int + + + Remove(int index) -> bool + + + + + + RemoveAll() -> bool + + + GetSize() -> (width,height) + + + + + + + + +#--------------------------------------------------------------------------- + + + + + AddPen(Pen pen) + + + + + + FindOrCreatePen(Colour colour, int width, int style) -> Pen + + + + + + + + RemovePen(Pen pen) + + + + + + GetCount() -> int + + + + + + AddBrush(Brush brush) + + + + + + FindOrCreateBrush(Colour colour, int style) -> Brush + + + + + + + RemoveBrush(Brush brush) + + + + + + GetCount() -> int + + + + + + __init__() -> ColourDatabase + + + __del__() + + + Find(String name) -> Colour + + + + + + FindName(Colour colour) -> String + + + + + + AddColour(String name, Colour colour) + + + + + + + Append(String name, int red, int green, int blue) + + + + + + + + + + + + AddFont(Font font) + + + + + + FindOrCreateFont(int point_size, int family, int style, int weight, + bool underline=False, String facename=EmptyString, + int encoding=FONTENCODING_DEFAULT) -> Font + + + + + + + + + + + + RemoveFont(Font font) + + + + + + GetCount() -> int + + + +#--------------------------------------------------------------------------- + + +#--------------------------------------------------------------------------- + + + + + __init__() -> Effects + + + GetHighlightColour() -> Colour + + + GetLightShadow() -> Colour + + + GetFaceColour() -> Colour + + + GetMediumShadow() -> Colour + + + GetDarkShadow() -> Colour + + + SetHighlightColour(Colour c) + + + + + + SetLightShadow(Colour c) + + + + + + SetFaceColour(Colour c) + + + + + + SetMediumShadow(Colour c) + + + + + + SetDarkShadow(Colour c) + + + + + + Set(Colour highlightColour, Colour lightShadow, Colour faceColour, + Colour mediumShadow, Colour darkShadow) + + + + + + + + + + DrawSunkenEdge(DC dc, Rect rect, int borderSize=1) + + + + + + + + TileBitmap(Rect rect, DC dc, Bitmap bitmap) -> bool + + + + + + + + + + wx = core + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=wxTAB_TRAVERSAL|wxNO_BORDER, + String name=PanelNameStr) -> Panel + + + + + + + + + + + PrePanel() -> Panel + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=wxTAB_TRAVERSAL|wxNO_BORDER, + String name=PanelNameStr) -> bool + + + + + + + + + + + InitDialog() + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=wxHSCROLL|wxVSCROLL, + String name=PanelNameStr) -> ScrolledWindow + + + + + + + + + + + PreScrolledWindow() -> ScrolledWindow + + + Create(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=wxHSCROLL|wxVSCROLL, + String name=PanelNameStr) -> bool + + + + + + + + + + + SetScrollbars(int pixelsPerUnitX, int pixelsPerUnitY, int noUnitsX, + int noUnitsY, int xPos=0, int yPos=0, bool noRefresh=False) + + + + + + + + + + + + Scroll(int x, int y) + + + + + + + GetScrollPageSize(int orient) -> int + + + + + + SetScrollPageSize(int orient, int pageSize) + + + + + + + SetScrollRate(int xstep, int ystep) + + + + + + + GetScrollPixelsPerUnit() -> (xUnit, yUnit) + Get the size of one logical unit in physical units. + + + + + + + EnableScrolling(bool x_scrolling, bool y_scrolling) + + + + + + + GetViewStart() -> (x,y) + Get the view start + + + + + + + SetScale(double xs, double ys) + + + + + + + GetScaleX() -> double + + + GetScaleY() -> double + + + Translate between scrolled and unscrolled coordinates. + + + + + + CalcScrolledPosition(Point pt) -> Point +CalcScrolledPosition(int x, int y) -> (sx, sy) + Translate between scrolled and unscrolled coordinates. + + + + + + + + + Translate between scrolled and unscrolled coordinates. + + + + + + CalcUnscrolledPosition(Point pt) -> Point +CalcUnscrolledPosition(int x, int y) -> (ux, uy) + Translate between scrolled and unscrolled coordinates. + + + + + + + + + AdjustScrollbars() + + + CalcScrollInc(ScrollWinEvent event) -> int + + + + + + SetTargetWindow(Window target) + + + + + + GetTargetWindow() -> Window + + + +#--------------------------------------------------------------------------- + + + + + Maximize(bool maximize=True) + + + + + + Restore() + + + Iconize(bool iconize=True) + + + + + + IsMaximized() -> bool + + + IsIconized() -> bool + + + GetIcon() -> Icon + + + SetIcon(Icon icon) + + + + + + SetIcons(wxIconBundle icons) + + + + + + ShowFullScreen(bool show, long style=FULLSCREEN_ALL) -> bool + + + + + + + IsFullScreen() -> bool + + + SetTitle(String title) + + + + + + GetTitle() -> String + + + SetShape(Region region) -> bool + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, String title, Point pos=DefaultPosition, + Size size=DefaultSize, long style=DEFAULT_FRAME_STYLE, + String name=FrameNameStr) -> Frame + + + + + + + + + + + + PreFrame() -> Frame + + + Create(Window parent, int id, String title, Point pos=DefaultPosition, + Size size=DefaultSize, long style=DEFAULT_FRAME_STYLE, + String name=FrameNameStr) -> bool + + + + + + + + + + + + GetClientAreaOrigin() -> Point + + + SendSizeEvent() + + + SetMenuBar(MenuBar menubar) + + + + + + GetMenuBar() -> MenuBar + + + ProcessCommand(int winid) -> bool + + + + + + CreateStatusBar(int number=1, long style=ST_SIZEGRIP, int winid=0, + String name=StatusLineNameStr) -> StatusBar + + + + + + + + + GetStatusBar() -> StatusBar + + + SetStatusBar(StatusBar statBar) + + + + + + SetStatusText(String text, int number=0) + + + + + + + SetStatusWidths(int widths, int widths_field) + + + + + + + PushStatusText(String text, int number=0) + + + + + + + PopStatusText(int number=0) + + + + + + SetStatusBarPane(int n) + + + + + + GetStatusBarPane() -> int + + + CreateToolBar(long style=-1, int winid=-1, String name=ToolBarNameStr) -> wxToolBar + + + + + + + + GetToolBar() -> wxToolBar + + + SetToolBar(wxToolBar toolbar) + + + + + + DoGiveHelp(String text, bool show) + + + + + + + DoMenuUpdates(Menu menu=None) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, String title, Point pos=DefaultPosition, + Size size=DefaultSize, long style=DEFAULT_DIALOG_STYLE, + String name=DialogNameStr) -> Dialog + + + + + + + + + + + + PreDialog() -> Dialog + + + Create(Window parent, int id, String title, Point pos=DefaultPosition, + Size size=DefaultSize, long style=DEFAULT_DIALOG_STYLE, + String name=DialogNameStr) -> bool + + + + + + + + + + + + SetReturnCode(int returnCode) + + + + + + GetReturnCode() -> int + + + CreateTextSizer(String message) -> Sizer + + + + + + CreateButtonSizer(long flags) -> Sizer + + + + + + SetModal(bool flag) + + + + + + IsModal() -> bool + + + ShowModal() -> int + + + EndModal(int retCode) + + + + + + IsModalShowing() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, String title, Point pos=DefaultPosition, + Size size=DefaultSize, long style=DEFAULT_FRAME_STYLE, + String name=FrameNameStr) -> MiniFrame + + + + + + + + + + + + PreMiniFrame() -> MiniFrame + + + Create(Window parent, int id, String title, Point pos=DefaultPosition, + Size size=DefaultSize, long style=DEFAULT_FRAME_STYLE, + String name=FrameNameStr) -> bool + + + + + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Bitmap bitmap, Window parent, int id, Point pos=DefaultPosition, + Size size=DefaultSize, long style=NO_BORDER) -> SplashScreenWindow + + + + + + + + + + + SetBitmap(Bitmap bitmap) + + + + + + GetBitmap() -> Bitmap + + + + + + __init__(Bitmap bitmap, long splashStyle, int milliseconds, + Window parent, int id, Point pos=DefaultPosition, + Size size=DefaultSize, long style=wxSIMPLE_BORDER|wxFRAME_NO_TASKBAR|wxSTAY_ON_TOP) -> SplashScreen + + + + + + + + + + + + + GetSplashStyle() -> long + + + GetSplashWindow() -> SplashScreenWindow + + + GetTimeout() -> int + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id=-1, long style=ST_SIZEGRIP, String name=StatusLineNameStr) -> StatusBar + + + + + + + + + PreStatusBar() -> StatusBar + + + Create(Window parent, int id, long style=ST_SIZEGRIP, String name=StatusLineNameStr) -> bool + + + + + + + + + SetFieldsCount(int number=1) + + + + + + GetFieldsCount() -> int + + + SetStatusText(String text, int number=0) + + + + + + + GetStatusText(int number=0) -> String + + + + + + PushStatusText(String text, int number=0) + + + + + + + PopStatusText(int number=0) + + + + + + SetStatusWidths(int widths, int widths_field) + + + + + + + GetFieldRect(int i) -> Rect + + + + + + SetMinHeight(int height) + + + + + + GetBorderX() -> int + + + GetBorderY() -> int + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, Point point=DefaultPosition, + Size size=DefaultSize, long style=SP_3D, String name=SplitterNameStr) -> SplitterWindow + + + + + + + + + + + PreSplitterWindow() -> SplitterWindow + + + Create(Window parent, int id, Point point=DefaultPosition, + Size size=DefaultSize, long style=SP_3D, String name=SplitterNameStr) -> bool + + + + + + + + + + + GetWindow1() -> Window + + + GetWindow2() -> Window + + + SetSplitMode(int mode) + + + + + + GetSplitMode() -> int + + + Initialize(Window window) + + + + + + SplitVertically(Window window1, Window window2, int sashPosition=0) -> bool + + + + + + + + SplitHorizontally(Window window1, Window window2, int sashPosition=0) -> bool + + + + + + + + Unsplit(Window toRemove=None) -> bool + + + + + + ReplaceWindow(Window winOld, Window winNew) -> bool + + + + + + + IsSplit() -> bool + + + SetSashSize(int width) + + + + + + SetBorderSize(int width) + + + + + + GetSashSize() -> int + + + GetBorderSize() -> int + + + SetSashPosition(int position, bool redraw=True) + + + + + + + GetSashPosition() -> int + + + SetMinimumPaneSize(int min) + + + + + + GetMinimumPaneSize() -> int + + + SashHitTest(int x, int y, int tolerance=5) -> bool + + + + + + + + SizeWindows() + + + SetNeedUpdating(bool needUpdating) + + + + + + GetNeedUpdating() -> bool + + + + + + __init__(wxEventType type=wxEVT_NULL, SplitterWindow splitter=(wxSplitterWindow *) NULL) -> SplitterEvent + + + + + + + SetSashPosition(int pos) + + + + + + GetSashPosition() -> int + + + GetWindowBeingRemoved() -> Window + + + GetX() -> int + + + GetY() -> int + + + +EVT_SPLITTER_SASH_POS_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED, 1 ) +EVT_SPLITTER_SASH_POS_CHANGING = wx.PyEventBinder( wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING, 1 ) +EVT_SPLITTER_DOUBLECLICKED = wx.PyEventBinder( wxEVT_COMMAND_SPLITTER_DOUBLECLICKED, 1 ) +EVT_SPLITTER_UNSPLIT = wx.PyEventBinder( wxEVT_COMMAND_SPLITTER_UNSPLIT, 1 ) + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=wxCLIP_CHILDREN|wxSW_3D, + String name=SashNameStr) -> SashWindow + + + + + + + + + + + PreSashWindow() -> SashWindow + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=wxCLIP_CHILDREN|wxSW_3D, + String name=SashNameStr) -> bool + + + + + + + + + + + SetSashVisible(int edge, bool sash) + + + + + + + GetSashVisible(int edge) -> bool + + + + + + SetSashBorder(int edge, bool border) + + + + + + + HasBorder(int edge) -> bool + + + + + + GetEdgeMargin(int edge) -> int + + + + + + SetDefaultBorderSize(int width) + + + + + + GetDefaultBorderSize() -> int + + + SetExtraBorderSize(int width) + + + + + + GetExtraBorderSize() -> int + + + SetMinimumSizeX(int min) + + + + + + SetMinimumSizeY(int min) + + + + + + GetMinimumSizeX() -> int + + + GetMinimumSizeY() -> int + + + SetMaximumSizeX(int max) + + + + + + SetMaximumSizeY(int max) + + + + + + GetMaximumSizeX() -> int + + + GetMaximumSizeY() -> int + + + SashHitTest(int x, int y, int tolerance=2) -> int + + + + + + + + SizeWindows() + + + + + + __init__(int id=0, int edge=SASH_NONE) -> SashEvent + + + + + + + SetEdge(int edge) + + + + + + GetEdge() -> int + + + SetDragRect(Rect rect) + + + + + + GetDragRect() -> Rect + + + SetDragStatus(int status) + + + + + + GetDragStatus() -> int + + + + EVT_SASH_DRAGGED = wx.PyEventBinder( wxEVT_SASH_DRAGGED, 1 ) + EVT_SASH_DRAGGED_RANGE = wx.PyEventBinder( wxEVT_SASH_DRAGGED, 2 ) + + +#--------------------------------------------------------------------------- + + + + + __init__(int id=0) -> QueryLayoutInfoEvent + + + + + + SetRequestedLength(int length) + + + + + + GetRequestedLength() -> int + + + SetFlags(int flags) + + + + + + GetFlags() -> int + + + SetSize(Size size) + + + + + + GetSize() -> Size + + + SetOrientation(int orient) + + + + + + GetOrientation() -> int + + + SetAlignment(int align) + + + + + + GetAlignment() -> int + + + + + + __init__(int id=0) -> CalculateLayoutEvent + + + + + + SetFlags(int flags) + + + + + + GetFlags() -> int + + + SetRect(Rect rect) + + + + + + GetRect() -> Rect + + + + EVT_QUERY_LAYOUT_INFO = wx.PyEventBinder( wxEVT_QUERY_LAYOUT_INFO ) + EVT_CALCULATE_LAYOUT = wx.PyEventBinder( wxEVT_CALCULATE_LAYOUT ) + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=wxCLIP_CHILDREN|wxSW_3D, + String name=SashLayoutNameStr) -> SashLayoutWindow + + + + + + + + + + + PreSashLayoutWindow() -> SashLayoutWindow + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=wxCLIP_CHILDREN|wxSW_3D, + String name=SashLayoutNameStr) -> bool + + + + + + + + + + + GetAlignment() -> int + + + GetOrientation() -> int + + + SetAlignment(int alignment) + + + + + + SetDefaultSize(Size size) + + + + + + SetOrientation(int orientation) + + + + + + + + + __init__() -> LayoutAlgorithm + + + __del__() + + + LayoutMDIFrame(MDIParentFrame frame, Rect rect=None) -> bool + + + + + + + LayoutFrame(Frame frame, Window mainWindow=None) -> bool + + + + + + + LayoutWindow(Window parent, Window mainWindow=None) -> bool + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int flags=BORDER_NONE) -> PopupWindow + + + + + + + PrePopupWindow() -> PopupWindow + + + Create(Window parent, int flags=BORDER_NONE) -> bool + + + + + + + Position(Point ptOrigin, Size size) + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int style=BORDER_NONE) -> PopupTransientWindow + + + + + + + PrePopupTransientWindow() -> PopupTransientWindow + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + Popup(Window focus=None) + + + + + + Dismiss() + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, String text, int maxLength=100, Rect rectBound=None) -> TipWindow + + + + + + + + + SetBoundingRect(Rect rectBound) + + + + + + Close() + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id=ID_ANY, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, String name=PanelNameStr) -> VScrolledWindow + + + + + + + + + + + PreVScrolledWindow() -> VScrolledWindow + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + Create(Window parent, int id=ID_ANY, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, String name=PanelNameStr) -> bool + + + + + + + + + + + SetLineCount(size_t count) + + + + + + ScrollToLine(size_t line) -> bool + + + + + + ScrollLines(int lines) -> bool + + + + + + ScrollPages(int pages) -> bool + + + + + + RefreshLine(size_t line) + + + + + + RefreshLines(size_t from, size_t to) + + + + + + + HitTestXT(int x, int y) -> int + + + + + + + HitTest(Point pt) -> int + + + + + + RefreshAll() + + + GetLineCount() -> size_t + + + GetFirstVisibleLine() -> size_t + + + GetLastVisibleLine() -> size_t + + + IsVisible(size_t line) -> bool + + + + + + + + + __init__(Window parent, int id=ID_ANY, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, String name=VListBoxNameStr) -> VListBox + + + + + + + + + + + PreVListBox() -> VListBox + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + Create(Window parent, int id=ID_ANY, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, String name=VListBoxNameStr) -> bool + + + + + + + + + + + GetItemCount() -> size_t + + + HasMultipleSelection() -> bool + + + GetSelection() -> int + + + IsCurrent(size_t item) -> bool + + + + + + IsSelected(size_t item) -> bool + + + + + + GetSelectedCount() -> size_t + + + GetFirstSelected(unsigned long cookie) -> int + + + + + + GetNextSelected(unsigned long cookie) -> int + + + + + + GetMargins() -> Point + + + GetSelectionBackground() -> Colour + + + SetItemCount(size_t count) + + + + + + Clear() + + + SetSelection(int selection) + + + + + + Select(size_t item, bool select=True) -> bool + + + + + + + SelectRange(size_t from, size_t to) -> bool + + + + + + + Toggle(size_t item) + + + + + + SelectAll() -> bool + + + DeselectAll() -> bool + + + SetMargins(Point pt) + + + + + + SetMarginsXY(int x, int y) + + + + + + + SetSelectionBackground(Colour col) + + + + + + + + + __init__(Window parent, int id=ID_ANY, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, String name=VListBoxNameStr) -> HtmlListBox + + + + + + + + + + + PreHtmlListBox() -> HtmlListBox + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + Create(Window parent, int id=ID_ANY, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, String name=VListBoxNameStr) -> bool + + + + + + + + + + + RefreshAll() + + + SetItemCount(size_t count) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> TaskBarIcon + + + __del__() + + + IsOk() -> bool + + + IsIconInstalled() -> bool + + + SetIcon(Icon icon, String tooltip=EmptyString) -> bool + + + + + + + RemoveIcon() -> bool + + + PopupMenu(Menu menu) -> bool + + + + + + + + + __init__(wxEventType evtType, TaskBarIcon tbIcon) -> TaskBarIconEvent + + + + + + + +EVT_TASKBAR_MOVE = wx.PyEventBinder ( wxEVT_TASKBAR_MOVE ) +EVT_TASKBAR_LEFT_DOWN = wx.PyEventBinder ( wxEVT_TASKBAR_LEFT_DOWN ) +EVT_TASKBAR_LEFT_UP = wx.PyEventBinder ( wxEVT_TASKBAR_LEFT_UP ) +EVT_TASKBAR_RIGHT_DOWN = wx.PyEventBinder ( wxEVT_TASKBAR_RIGHT_DOWN ) +EVT_TASKBAR_RIGHT_UP = wx.PyEventBinder ( wxEVT_TASKBAR_RIGHT_UP ) +EVT_TASKBAR_LEFT_DCLICK = wx.PyEventBinder ( wxEVT_TASKBAR_LEFT_DCLICK ) +EVT_TASKBAR_RIGHT_DCLICK = wx.PyEventBinder ( wxEVT_TASKBAR_RIGHT_DCLICK ) + + +#--------------------------------------------------------------------------- + + + + + __init__() -> ColourData + + + __del__() + + + GetChooseFull() -> bool + + + GetColour() -> Colour + + + GetCustomColour(int i) -> Colour + + + + + + SetChooseFull(int flag) + + + + + + SetColour(Colour colour) + + + + + + SetCustomColour(int i, Colour colour) + + + + + + + + + + __init__(Window parent, ColourData data=None) -> ColourDialog + + + + + + + GetColourData() -> ColourData + + + ShowModal() -> int + + + + + + __init__(Window parent, String message=DirSelectorPromptStr, + String defaultPath=EmptyString, long style=0, + Point pos=DefaultPosition, Size size=DefaultSize, + String name=DirDialogNameStr) -> DirDialog + + + + + + + + + + + + GetPath() -> String + + + GetMessage() -> String + + + GetStyle() -> long + + + SetMessage(String message) + + + + + + SetPath(String path) + + + + + + ShowModal() -> int + + + + + + __init__(Window parent, String message=FileSelectorPromptStr, + String defaultDir=EmptyString, String defaultFile=EmptyString, + String wildcard=FileSelectorDefaultWildcardStr, + long style=0, Point pos=DefaultPosition) -> FileDialog + + + + + + + + + + + + SetMessage(String message) + + + + + + SetPath(String path) + + + + + + SetDirectory(String dir) + + + + + + SetFilename(String name) + + + + + + SetWildcard(String wildCard) + + + + + + SetStyle(long style) + + + + + + SetFilterIndex(int filterIndex) + + + + + + GetMessage() -> String + + + GetPath() -> String + + + GetDirectory() -> String + + + GetFilename() -> String + + + GetWildcard() -> String + + + GetStyle() -> long + + + GetFilterIndex() -> int + + + GetFilenames() -> PyObject + + + GetPaths() -> PyObject + + + + + + __init__(Window parent, String message, String caption, int LCOUNT, + String choices, long style=CHOICEDLG_STYLE, + Point pos=DefaultPosition) -> MultiChoiceDialog + + + + + + + + + + + + SetSelections(wxArrayInt selections) + + + + + + GetSelections() -> PyObject + + + + + + __init__(Window parent, String message, String caption, int choices, + String choices_array, long style=CHOICEDLG_STYLE, + Point pos=DefaultPosition) -> SingleChoiceDialog + + + + + + + + + + + + GetSelection() -> int + + + GetStringSelection() -> String + + + SetSelection(int sel) + + + + + + ShowModal() -> int + + + + + + __init__(Window parent, String message, String caption=GetTextFromUserPromptStr, + String defaultValue=EmptyString, + long style=wxOK|wxCANCEL|wxCENTRE, Point pos=DefaultPosition) -> TextEntryDialog + + + + + + + + + + + GetValue() -> String + + + SetValue(String value) + + + + + + ShowModal() -> int + + + + + + __init__() -> FontData + + + __del__() + + + EnableEffects(bool enable) + + + + + + GetAllowSymbols() -> bool + + + GetColour() -> Colour + + + GetChosenFont() -> Font + + + GetEnableEffects() -> bool + + + GetInitialFont() -> Font + + + GetShowHelp() -> bool + + + SetAllowSymbols(bool allowSymbols) + + + + + + SetChosenFont(Font font) + + + + + + SetColour(Colour colour) + + + + + + SetInitialFont(Font font) + + + + + + SetRange(int min, int max) + + + + + + + SetShowHelp(bool showHelp) + + + + + + + + + __init__(Window parent, FontData data) -> FontDialog + + + + + + + GetFontData() -> FontData + + + ShowModal() -> int + + + + + + __init__(Window parent, String message, String caption=MessageBoxCaptionStr, + long style=wxOK|wxCANCEL|wxCENTRE, + Point pos=DefaultPosition) -> MessageDialog + + + + + + + + + + ShowModal() -> int + + + + + + __init__(String title, String message, int maximum=100, Window parent=None, + int style=wxPD_AUTO_HIDE|wxPD_APP_MODAL) -> ProgressDialog + + + + + + + + + + Update(int value, String newmsg=EmptyString) -> bool + + + + + + + Resume() + + + +EVT_FIND = wx.PyEventBinder( wxEVT_COMMAND_FIND, 1 ) +EVT_FIND_NEXT = wx.PyEventBinder( wxEVT_COMMAND_FIND_NEXT, 1 ) +EVT_FIND_REPLACE = wx.PyEventBinder( wxEVT_COMMAND_FIND_REPLACE, 1 ) +EVT_FIND_REPLACE_ALL = wx.PyEventBinder( wxEVT_COMMAND_FIND_REPLACE_ALL, 1 ) +EVT_FIND_CLOSE = wx.PyEventBinder( wxEVT_COMMAND_FIND_CLOSE, 1 ) + +# For backwards compatibility. Should they be removed? +EVT_COMMAND_FIND = EVT_FIND +EVT_COMMAND_FIND_NEXT = EVT_FIND_NEXT +EVT_COMMAND_FIND_REPLACE = EVT_FIND_REPLACE +EVT_COMMAND_FIND_REPLACE_ALL = EVT_FIND_REPLACE_ALL +EVT_COMMAND_FIND_CLOSE = EVT_FIND_CLOSE + + + + + __init__(wxEventType commandType=wxEVT_NULL, int id=0) -> FindDialogEvent + + + + + + + GetFlags() -> int + + + GetFindString() -> String + + + GetReplaceString() -> String + + + GetDialog() -> FindReplaceDialog + + + SetFlags(int flags) + + + + + + SetFindString(String str) + + + + + + SetReplaceString(String str) + + + + + + + + + __init__(int flags=0) -> FindReplaceData + + + + + + __del__() + + + GetFindString() -> String + + + GetReplaceString() -> String + + + GetFlags() -> int + + + SetFlags(int flags) + + + + + + SetFindString(String str) + + + + + + SetReplaceString(String str) + + + + + + + + + __init__(Window parent, FindReplaceData data, String title, + int style=0) -> FindReplaceDialog + + + + + + + + + PreFindReplaceDialog() -> FindReplaceDialog + + + Create(Window parent, FindReplaceData data, String title, + int style=0) -> bool + + + + + + + + + GetData() -> FindReplaceData + + + SetData(FindReplaceData data) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, String title, Point pos=DefaultPosition, + Size size=DefaultSize, long style=wxDEFAULT_FRAME_STYLE|wxVSCROLL|wxHSCROLL, + String name=FrameNameStr) -> MDIParentFrame + + + + + + + + + + + + PreMDIParentFrame() -> MDIParentFrame + + + Create(Window parent, int id, String title, Point pos=DefaultPosition, + Size size=DefaultSize, long style=wxDEFAULT_FRAME_STYLE|wxVSCROLL|wxHSCROLL, + String name=FrameNameStr) -> bool + + + + + + + + + + + + ActivateNext() + + + ActivatePrevious() + + + ArrangeIcons() + + + Cascade() + + + GetActiveChild() -> MDIChildFrame + + + GetClientWindow() -> MDIClientWindow + + + GetToolBar() -> Window + + + Tile() + + + + + + __init__(MDIParentFrame parent, int id, String title, Point pos=DefaultPosition, + Size size=DefaultSize, long style=DEFAULT_FRAME_STYLE, + String name=FrameNameStr) -> MDIChildFrame + + + + + + + + + + + + PreMDIChildFrame() -> MDIChildFrame + + + Create(MDIParentFrame parent, int id, String title, Point pos=DefaultPosition, + Size size=DefaultSize, long style=DEFAULT_FRAME_STYLE, + String name=FrameNameStr) -> bool + + + + + + + + + + + + Activate() + + + Maximize(bool maximize) + + + + + + Restore() + + + + + + __init__(MDIParentFrame parent, long style=0) -> MDIClientWindow + + + + + + + PreMDIClientWindow() -> MDIClientWindow + + + Create(MDIParentFrame parent, long style=0) -> bool + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, String name=PanelNameStr) -> PyWindow + + + + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_DoMoveWindow(int x, int y, int width, int height) + + + + + + + + + base_DoSetSize(int x, int y, int width, int height, int sizeFlags=SIZE_AUTO) + + + + + + + + + + base_DoSetClientSize(int width, int height) + + + + + + + base_DoSetVirtualSize(int x, int y) + + + + + + + base_DoGetSize() -> (width, height) + + + + + + + base_DoGetClientSize() -> (width, height) + + + + + + + base_DoGetPosition() -> (x,y) + + + + + + + base_DoGetVirtualSize() -> Size + + + base_DoGetBestSize() -> Size + + + base_InitDialog() + + + base_TransferDataToWindow() -> bool + + + base_TransferDataFromWindow() -> bool + + + base_Validate() -> bool + + + base_AcceptsFocus() -> bool + + + base_AcceptsFocusFromKeyboard() -> bool + + + base_GetMaxSize() -> Size + + + base_AddChild(Window child) + + + + + + base_RemoveChild(Window child) + + + + + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, String name=PanelNameStr) -> PyPanel + + + + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_DoMoveWindow(int x, int y, int width, int height) + + + + + + + + + base_DoSetSize(int x, int y, int width, int height, int sizeFlags=SIZE_AUTO) + + + + + + + + + + base_DoSetClientSize(int width, int height) + + + + + + + base_DoSetVirtualSize(int x, int y) + + + + + + + base_DoGetSize() -> (width, height) + + + + + + + base_DoGetClientSize() -> (width, height) + + + + + + + base_DoGetPosition() -> (x,y) + + + + + + + base_DoGetVirtualSize() -> Size + + + base_DoGetBestSize() -> Size + + + base_InitDialog() + + + base_TransferDataToWindow() -> bool + + + base_TransferDataFromWindow() -> bool + + + base_Validate() -> bool + + + base_AcceptsFocus() -> bool + + + base_AcceptsFocusFromKeyboard() -> bool + + + base_GetMaxSize() -> Size + + + base_AddChild(Window child) + + + + + + base_RemoveChild(Window child) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> PrintData + + + __del__() + + + GetNoCopies() -> int + + + GetCollate() -> bool + + + GetOrientation() -> int + + + Ok() -> bool + + + GetPrinterName() -> String + + + GetColour() -> bool + + + GetDuplex() -> int + + + GetPaperId() -> int + + + GetPaperSize() -> Size + + + GetQuality() -> int + + + SetNoCopies(int v) + + + + + + SetCollate(bool flag) + + + + + + SetOrientation(int orient) + + + + + + SetPrinterName(String name) + + + + + + SetColour(bool colour) + + + + + + SetDuplex(int duplex) + + + + + + SetPaperId(int sizeId) + + + + + + SetPaperSize(Size sz) + + + + + + SetQuality(int quality) + + + + + + GetPrinterCommand() -> String + + + GetPrinterOptions() -> String + + + GetPreviewCommand() -> String + + + GetFilename() -> String + + + GetFontMetricPath() -> String + + + GetPrinterScaleX() -> double + + + GetPrinterScaleY() -> double + + + GetPrinterTranslateX() -> long + + + GetPrinterTranslateY() -> long + + + GetPrintMode() -> int + + + SetPrinterCommand(String command) + + + + + + SetPrinterOptions(String options) + + + + + + SetPreviewCommand(String command) + + + + + + SetFilename(String filename) + + + + + + SetFontMetricPath(String path) + + + + + + SetPrinterScaleX(double x) + + + + + + SetPrinterScaleY(double y) + + + + + + SetPrinterScaling(double x, double y) + + + + + + + SetPrinterTranslateX(long x) + + + + + + SetPrinterTranslateY(long y) + + + + + + SetPrinterTranslation(long x, long y) + + + + + + + SetPrintMode(int printMode) + + + + + + + + + __init__() -> PageSetupDialogData + + + __del__() + + + EnableHelp(bool flag) + + + + + + EnableMargins(bool flag) + + + + + + EnableOrientation(bool flag) + + + + + + EnablePaper(bool flag) + + + + + + EnablePrinter(bool flag) + + + + + + GetDefaultMinMargins() -> bool + + + GetEnableMargins() -> bool + + + GetEnableOrientation() -> bool + + + GetEnablePaper() -> bool + + + GetEnablePrinter() -> bool + + + GetEnableHelp() -> bool + + + GetDefaultInfo() -> bool + + + GetMarginTopLeft() -> Point + + + GetMarginBottomRight() -> Point + + + GetMinMarginTopLeft() -> Point + + + GetMinMarginBottomRight() -> Point + + + GetPaperId() -> int + + + GetPaperSize() -> Size + + + GetPrintData() -> PrintData + + + Ok() -> bool + + + SetDefaultInfo(bool flag) + + + + + + SetDefaultMinMargins(bool flag) + + + + + + SetMarginTopLeft(Point pt) + + + + + + SetMarginBottomRight(Point pt) + + + + + + SetMinMarginTopLeft(Point pt) + + + + + + SetMinMarginBottomRight(Point pt) + + + + + + SetPaperId(int id) + + + + + + SetPaperSize(Size size) + + + + + + SetPrintData(PrintData printData) + + + + + + + + + __init__(Window parent, PageSetupDialogData data=None) -> PageSetupDialog + + + + + + + GetPageSetupData() -> PageSetupDialogData + + + ShowModal() -> int + + + + + + __init__() -> PrintDialogData + + + __del__() + + + GetFromPage() -> int + + + GetToPage() -> int + + + GetMinPage() -> int + + + GetMaxPage() -> int + + + GetNoCopies() -> int + + + GetAllPages() -> bool + + + GetSelection() -> bool + + + GetCollate() -> bool + + + GetPrintToFile() -> bool + + + GetSetupDialog() -> bool + + + SetFromPage(int v) + + + + + + SetToPage(int v) + + + + + + SetMinPage(int v) + + + + + + SetMaxPage(int v) + + + + + + SetNoCopies(int v) + + + + + + SetAllPages(bool flag) + + + + + + SetSelection(bool flag) + + + + + + SetCollate(bool flag) + + + + + + SetPrintToFile(bool flag) + + + + + + SetSetupDialog(bool flag) + + + + + + EnablePrintToFile(bool flag) + + + + + + EnableSelection(bool flag) + + + + + + EnablePageNumbers(bool flag) + + + + + + EnableHelp(bool flag) + + + + + + GetEnablePrintToFile() -> bool + + + GetEnableSelection() -> bool + + + GetEnablePageNumbers() -> bool + + + GetEnableHelp() -> bool + + + Ok() -> bool + + + GetPrintData() -> PrintData + + + SetPrintData(PrintData printData) + + + + + + + + + __init__(Window parent, PrintDialogData data=None) -> PrintDialog + + + + + + + GetPrintDialogData() -> PrintDialogData + + + GetPrintDC() -> DC + + + ShowModal() -> int + + + + + + __init__(PrintDialogData data=None) -> Printer + + + + + + __del__() + + + CreateAbortWindow(Window parent, Printout printout) + + + + + + + GetPrintDialogData() -> PrintDialogData + + + Print(Window parent, Printout printout, int prompt=True) -> bool + + + + + + + + PrintDialog(Window parent) -> DC + + + + + + ReportError(Window parent, Printout printout, String message) + + + + + + + + Setup(Window parent) -> bool + + + + + + GetAbort() -> bool + + + Printer.GetLastError() -> int + + + + + + __init__(String title=PrintoutTitleStr) -> Printout + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + GetTitle() -> String + + + GetDC() -> DC + + + SetDC(DC dc) + + + + + + SetPageSizePixels(int w, int h) + + + + + + + GetPageSizePixels() -> (w, h) + + + + + + + SetPageSizeMM(int w, int h) + + + + + + + GetPageSizeMM() -> (w, h) + + + + + + + SetPPIScreen(int x, int y) + + + + + + + GetPPIScreen() -> (x,y) + + + + + + + SetPPIPrinter(int x, int y) + + + + + + + GetPPIPrinter() -> (x,y) + + + + + + + IsPreview() -> bool + + + SetIsPreview(bool p) + + + + + + base_OnBeginDocument(int startPage, int endPage) -> bool + + + + + + + base_OnEndDocument() + + + base_OnBeginPrinting() + + + base_OnEndPrinting() + + + base_OnPreparePrinting() + + + base_HasPage(int page) -> bool + + + + + + base_GetPageInfo() -> (minPage, maxPage, pageFrom, pageTo) + + + + + + + + + + + + __init__(PrintPreview preview, Window parent, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + String name=PreviewCanvasNameStr) -> PreviewCanvas + + + + + + + + + + + + + + __init__(PrintPreview preview, Frame parent, String title, Point pos=DefaultPosition, + Size size=DefaultSize, + long style=DEFAULT_FRAME_STYLE, String name=FrameNameStr) -> PreviewFrame + + + + + + + + + + + + Initialize() + + + CreateControlBar() + + + CreateCanvas() + + + GetControlBar() -> PreviewControlBar + + + + + + __init__(PrintPreview preview, long buttons, Window parent, + Point pos=DefaultPosition, Size size=DefaultSize, + long style=TAB_TRAVERSAL, String name=PanelNameStr) -> PreviewControlBar + + + + + + + + + + + + GetZoomControl() -> int + + + SetZoomControl(int zoom) + + + + + + GetPrintPreview() -> PrintPreview + + + OnNext() + + + OnPrevious() + + + OnFirst() + + + OnLast() + + + OnGoto() + + + + + + __init__(Printout printout, Printout printoutForPrinting, PrintData data=None) -> PrintPreview + + + + + + + + SetCurrentPage(int pageNum) -> bool + + + + + + GetCurrentPage() -> int + + + SetPrintout(Printout printout) + + + + + + GetPrintout() -> Printout + + + GetPrintoutForPrinting() -> Printout + + + SetFrame(Frame frame) + + + + + + SetCanvas(PreviewCanvas canvas) + + + + + + GetFrame() -> Frame + + + GetCanvas() -> PreviewCanvas + + + PaintPage(PreviewCanvas canvas, DC dc) -> bool + + + + + + + DrawBlankPage(PreviewCanvas canvas, DC dc) -> bool + + + + + + + RenderPage(int pageNum) -> bool + + + + + + AdjustScrollbars(PreviewCanvas canvas) + + + + + + GetPrintDialogData() -> PrintDialogData + + + SetZoom(int percent) + + + + + + GetZoom() -> int + + + GetMaxPage() -> int + + + GetMinPage() -> int + + + Ok() -> bool + + + SetOk(bool ok) + + + + + + Print(bool interactive) -> bool + + + + + + DetermineScaling() + + + + + + __init__(Printout printout, Printout printoutForPrinting, PrintData data=None) -> PyPrintPreview + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_SetCurrentPage(int pageNum) -> bool + + + + + + base_PaintPage(PreviewCanvas canvas, DC dc) -> bool + + + + + + + base_DrawBlankPage(PreviewCanvas canvas, DC dc) -> bool + + + + + + + base_RenderPage(int pageNum) -> bool + + + + + + base_SetZoom(int percent) + + + + + + base_Print(bool interactive) -> bool + + + + + + base_DetermineScaling() + + + + + + __init__(PrintPreview preview, Frame parent, String title, Point pos=DefaultPosition, + Size size=DefaultSize, + long style=DEFAULT_FRAME_STYLE, String name=FrameNameStr) -> PyPreviewFrame + + + + + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + SetPreviewCanvas(PreviewCanvas canvas) + + + + + + SetControlBar(PreviewControlBar bar) + + + + + + base_Initialize() + + + base_CreateCanvas() + + + base_CreateControlBar() + + + + + + __init__(PrintPreview preview, long buttons, Window parent, + Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, String name=PanelNameStr) -> PyPreviewControlBar + + + + + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + SetPrintPreview(PrintPreview preview) + + + + + + base_CreateButtons() + + + base_SetZoomControl(int zoom) + + + + + + + + wx = core + +#--------------------------------------------------------------------------- + + + A button is a control that contains a text string, and is one of the most +common elements of a GUI. It may be placed on a dialog box or panel, or +indeed almost any other window. + + Styles + wx.BU_LEFT: Left-justifies the label. WIN32 only. + wx.BU_TOP: Aligns the label to the top of the button. WIN32 only. + wx.BU_RIGHT: Right-justifies the bitmap label. WIN32 only. + wx.BU_BOTTOM: Aligns the label to the bottom of the button. WIN32 only. + wx.BU_EXACTFIT: Creates the button as small as possible instead of making + it of the standard size (which is the default behaviour.) + + Events + EVT_BUTTON: Sent when the button is clicked. + + + + __init__(Window parent, int id, String label, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + Validator validator=DefaultValidator, String name=ButtonNameStr) -> Button + Create and show a button. + + + + + + + + + + + + + PreButton() -> Button + Precreate a Button for 2-phase creation. + + + Create(Window parent, int id, String label, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + Validator validator=DefaultValidator, String name=ButtonNameStr) -> bool + Acutally create the GUI Button for 2-phase creation. + + + + + + + + + + + + + SetDefault() + This sets the button to be the default item for the panel or dialog box. + + + Button.GetDefaultSize() -> Size + + + + A Buttont that contains a bitmap. + + + __init__(Window parent, int id, Bitmap bitmap, Point pos=DefaultPosition, + Size size=DefaultSize, long style=BU_AUTODRAW, + Validator validator=DefaultValidator, + String name=ButtonNameStr) -> BitmapButton + Create and show a button. + + + + + + + + + + + + + PreBitmapButton() -> BitmapButton + Precreate a BitmapButton for 2-phase creation. + + + Create(Window parent, int id, Bitmap bitmap, Point pos=DefaultPosition, + Size size=DefaultSize, long style=BU_AUTODRAW, + Validator validator=DefaultValidator, + String name=ButtonNameStr) -> bool + Acutally create the GUI BitmapButton for 2-phase creation. + + + + + + + + + + + + + GetBitmapLabel() -> Bitmap + Returns the label bitmap (the one passed to the constructor). + + + GetBitmapDisabled() -> Bitmap + Returns the bitmap for the disabled state. + + + GetBitmapFocus() -> Bitmap + Returns the bitmap for the focused state. + + + GetBitmapSelected() -> Bitmap + Returns the bitmap for the selected state. + + + SetBitmapDisabled(Bitmap bitmap) + Sets the bitmap for the disabled button appearance. + + + + + + SetBitmapFocus(Bitmap bitmap) + Sets the bitmap for the button appearance when it has the keyboard focus. + + + + + + SetBitmapSelected(Bitmap bitmap) + Sets the bitmap for the selected (depressed) button appearance. + + + + + + SetBitmapLabel(Bitmap bitmap) + Sets the bitmap label for the button. This is the bitmap used for the +unselected state, and for all other states if no other bitmaps are provided. + + + + + + SetMargins(int x, int y) + + + + + + + GetMarginX() -> int + + + GetMarginY() -> int + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, String label, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + Validator validator=DefaultValidator, String name=CheckBoxNameStr) -> CheckBox + + + + + + + + + + + + + PreCheckBox() -> CheckBox + + + Create(Window parent, int id, String label, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + Validator validator=DefaultValidator, String name=CheckBoxNameStr) -> bool + + + + + + + + + + + + + GetValue() -> bool + + + IsChecked() -> bool + + + SetValue(bool state) + + + + + + Get3StateValue() -> int + + + Set3StateValue(int state) + + + + + + Is3State() -> bool + + + Is3rdStateAllowedForUser() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + int choices=0, String choices_array=None, + long style=0, Validator validator=DefaultValidator, + String name=ChoiceNameStr) -> Choice + + + + + + + + + + + + + + PreChoice() -> Choice + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + int choices=0, String choices_array=None, + long style=0, Validator validator=DefaultValidator, + String name=ChoiceNameStr) -> bool + + + + + + + + + + + + + + GetColumns() -> int + + + SetColumns(int n=1) + + + + + + SetSelection(int n) + + + + + + SetStringSelection(String string) + + + + + + SetString(int n, String s) + + + + + + + +#--------------------------------------------------------------------------- + + + + + + __init__(Window parent, int id, String value=EmptyString, Point pos=DefaultPosition, + Size size=DefaultSize, + int choices=0, String choices_array=None, + long style=0, Validator validator=DefaultValidator, + String name=ComboBoxNameStr) -> ComboBox + + + + + + + + + + + + + + + PreComboBox() -> ComboBox + + + Create(Window parent, int id, String value=EmptyString, Point pos=DefaultPosition, + Size size=DefaultSize, + int choices=0, String choices_array=None, + long style=0, Validator validator=DefaultValidator, + String name=ComboBoxNameStr) -> bool + + + + + + + + + + + + + + + GetValue() -> String + + + SetValue(String value) + + + + + + Copy() + + + Cut() + + + Paste() + + + SetInsertionPoint(long pos) + + + + + + GetInsertionPoint() -> long + + + GetLastPosition() -> long + + + Replace(long from, long to, String value) + + + + + + + + SetSelection(int n) + + + + + + SetMark(long from, long to) + + + + + + + SetEditable(bool editable) + + + + + + SetInsertionPointEnd() + + + Remove(long from, long to) + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, int range, Point pos=DefaultPosition, + Size size=DefaultSize, long style=GA_HORIZONTAL, + Validator validator=DefaultValidator, + String name=GaugeNameStr) -> Gauge + + + + + + + + + + + + + PreGauge() -> Gauge + + + Create(Window parent, int id, int range, Point pos=DefaultPosition, + Size size=DefaultSize, long style=GA_HORIZONTAL, + Validator validator=DefaultValidator, + String name=GaugeNameStr) -> bool + + + + + + + + + + + + + SetRange(int range) + + + + + + GetRange() -> int + + + SetValue(int pos) + + + + + + GetValue() -> int + + + IsVertical() -> bool + + + SetShadowWidth(int w) + + + + + + GetShadowWidth() -> int + + + SetBezelFace(int w) + + + + + + GetBezelFace() -> int + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, String label, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + String name=StaticBoxNameStr) -> StaticBox + + + + + + + + + + + + PreStaticBox() -> StaticBox + + + Create(Window parent, int id, String label, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + String name=StaticBoxNameStr) -> bool + + + + + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=LI_HORIZONTAL, + String name=StaticTextNameStr) -> StaticLine + + + + + + + + + + + PreStaticLine() -> StaticLine + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=LI_HORIZONTAL, + String name=StaticTextNameStr) -> bool + + + + + + + + + + + IsVertical() -> bool + + + StaticLine.GetDefaultSize() -> int + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, String label, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + String name=StaticTextNameStr) -> StaticText + + + + + + + + + + + + PreStaticText() -> StaticText + + + Create(Window parent, int id, String label, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + String name=StaticTextNameStr) -> bool + + + + + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, Bitmap bitmap, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + String name=StaticBitmapNameStr) -> StaticBitmap + + + + + + + + + + + + PreStaticBitmap() -> StaticBitmap + + + Create(Window parent, int id, Bitmap bitmap, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + String name=StaticBitmapNameStr) -> bool + + + + + + + + + + + + GetBitmap() -> Bitmap + + + SetBitmap(Bitmap bitmap) + + + + + + SetIcon(Icon icon) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + int choices=0, String choices_array=None, + long style=0, Validator validator=DefaultValidator, + String name=ListBoxNameStr) -> ListBox + + + + + + + + + + + + + + PreListBox() -> ListBox + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + int choices=0, String choices_array=None, + long style=0, Validator validator=DefaultValidator, + String name=ListBoxNameStr) -> bool + + + + + + + + + + + + + + Insert(String item, int pos, PyObject clientData=None) + + + + + + + + InsertItems(wxArrayString items, int pos) + + + + + + + Set(wxArrayString items) + + + + + + IsSelected(int n) -> bool + + + + + + SetSelection(int n, bool select=True) + + + + + + + Select(int n) + + + + + + Deselect(int n) + + + + + + DeselectAll(int itemToLeaveSelected=-1) + + + + + + SetStringSelection(String s, bool select=True) -> bool + + + + + + + GetSelections() -> PyObject + + + SetFirstItem(int n) + + + + + + SetFirstItemStr(String s) + + + + + + EnsureVisible(int n) + + + + + + AppendAndEnsureVisible(String s) + + + + + + IsSorted() -> bool + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + int choices=0, String choices_array=None, + long style=0, Validator validator=DefaultValidator, + String name=ListBoxNameStr) -> CheckListBox + + + + + + + + + + + + + + PreCheckListBox() -> CheckListBox + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + int choices=0, String choices_array=None, + long style=0, Validator validator=DefaultValidator, + String name=ListBoxNameStr) -> bool + + + + + + + + + + + + + + IsChecked(int index) -> bool + + + + + + Check(int index, int check=True) + + + + + + + GetItemHeight() -> int + + + HitTest(Point pt) -> int + + + + + + HitTestXY(int x, int y) -> int + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> TextAttr +__init__(Colour colText, Colour colBack=wxNullColour, Font font=wxNullFont, + int alignment=TEXT_ALIGNMENT_DEFAULT) -> TextAttr + + + + + + + + + Init() + + + SetTextColour(Colour colText) + + + + + + SetBackgroundColour(Colour colBack) + + + + + + SetFont(Font font, long flags=TEXT_ATTR_FONT) + + + + + + + SetAlignment(int alignment) + + + + + + SetTabs(wxArrayInt tabs) + + + + + + SetLeftIndent(int indent) + + + + + + SetRightIndent(int indent) + + + + + + SetFlags(long flags) + + + + + + HasTextColour() -> bool + + + HasBackgroundColour() -> bool + + + HasFont() -> bool + + + HasAlignment() -> bool + + + HasTabs() -> bool + + + HasLeftIndent() -> bool + + + HasRightIndent() -> bool + + + HasFlag(long flag) -> bool + + + + + + GetTextColour() -> Colour + + + GetBackgroundColour() -> Colour + + + GetFont() -> Font + + + GetAlignment() -> int + + + GetTabs() -> wxArrayInt + + + GetLeftIndent() -> long + + + GetRightIndent() -> long + + + GetFlags() -> long + + + IsDefault() -> bool + + + TextAttr.Combine(TextAttr attr, TextAttr attrDef, TextCtrl text) -> TextAttr + + + + + + + + + + + __init__(Window parent, int id, String value=EmptyString, Point pos=DefaultPosition, + Size size=DefaultSize, + long style=0, Validator validator=DefaultValidator, + String name=TextCtrlNameStr) -> TextCtrl + + + + + + + + + + + + + PreTextCtrl() -> TextCtrl + + + Create(Window parent, int id, String value=EmptyString, Point pos=DefaultPosition, + Size size=DefaultSize, + long style=0, Validator validator=DefaultValidator, + String name=TextCtrlNameStr) -> bool + + + + + + + + + + + + + GetValue() -> String + + + SetValue(String value) + + + + + + GetRange(long from, long to) -> String + + + + + + + GetLineLength(long lineNo) -> int + + + + + + GetLineText(long lineNo) -> String + + + + + + GetNumberOfLines() -> int + + + IsModified() -> bool + + + IsEditable() -> bool + + + IsSingleLine() -> bool + + + IsMultiLine() -> bool + + + GetSelection() -> (from, to) + If the return values from and to are the same, there is no selection. + + + + + + + GetStringSelection() -> String + + + Clear() + + + Replace(long from, long to, String value) + + + + + + + + Remove(long from, long to) + + + + + + + LoadFile(String file) -> bool + + + + + + SaveFile(String file=EmptyString) -> bool + + + + + + MarkDirty() + + + DiscardEdits() + + + SetMaxLength(unsigned long len) + + + + + + WriteText(String text) + + + + + + AppendText(String text) + + + + + + EmulateKeyPress(KeyEvent event) -> bool + + + + + + SetStyle(long start, long end, TextAttr style) -> bool + + + + + + + + GetStyle(long position, TextAttr style) -> bool + + + + + + + SetDefaultStyle(TextAttr style) -> bool + + + + + + GetDefaultStyle() -> TextAttr + + + XYToPosition(long x, long y) -> long + + + + + + + PositionToXY(long pos) -> (x, y) + + + + + + + + ShowPosition(long pos) + + + + + + Copy() + + + Cut() + + + Paste() + + + CanCopy() -> bool + + + CanCut() -> bool + + + CanPaste() -> bool + + + Undo() + + + Redo() + + + CanUndo() -> bool + + + CanRedo() -> bool + + + SetInsertionPoint(long pos) + + + + + + SetInsertionPointEnd() + + + GetInsertionPoint() -> long + + + GetLastPosition() -> long + + + SetSelection(long from, long to) + + + + + + + SelectAll() + + + SetEditable(bool editable) + + + + + + write(String text) + + + + + + GetString(long from, long to) -> String + + + + + + + + + + __init__(int winid, MouseEvent evtMouse, long start, long end) -> TextUrlEvent + + + + + + + + + GetMouseEvent() -> MouseEvent + + + GetURLStart() -> long + + + GetURLEnd() -> long + + + +EVT_TEXT = wx.PyEventBinder( wxEVT_COMMAND_TEXT_UPDATED, 1) +EVT_TEXT_ENTER = wx.PyEventBinder( wxEVT_COMMAND_TEXT_ENTER, 1) +EVT_TEXT_URL = wx.PyEventBinder( wxEVT_COMMAND_TEXT_URL, 1) +EVT_TEXT_MAXLEN = wx.PyEventBinder( wxEVT_COMMAND_TEXT_MAXLEN, 1) + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=SB_HORIZONTAL, + Validator validator=DefaultValidator, String name=ScrollBarNameStr) -> ScrollBar + + + + + + + + + + + + PreScrollBar() -> ScrollBar + + + Create(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=SB_HORIZONTAL, + Validator validator=DefaultValidator, String name=ScrollBarNameStr) -> bool + + + + + + + + + + + + GetThumbPosition() -> int + + + GetThumbSize() -> int + + + GetPageSize() -> int + + + GetRange() -> int + + + IsVertical() -> bool + + + SetThumbPosition(int viewStart) + + + + + + SetScrollbar(int position, int thumbSize, int range, int pageSize, + bool refresh=True) + + + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=SP_HORIZONTAL, + String name=SPIN_BUTTON_NAME) -> SpinButton + + + + + + + + + + + PreSpinButton() -> SpinButton + + + Create(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=SP_HORIZONTAL, + String name=SPIN_BUTTON_NAME) -> bool + + + + + + + + + + + GetValue() -> int + + + GetMin() -> int + + + GetMax() -> int + + + SetValue(int val) + + + + + + SetMin(int minVal) + + + + + + SetMax(int maxVal) + + + + + + SetRange(int minVal, int maxVal) + + + + + + + IsVertical() -> bool + + + + + + __init__(Window parent, int id=-1, String value=EmptyString, + Point pos=DefaultPosition, Size size=DefaultSize, + long style=SP_ARROW_KEYS, int min=0, int max=100, + int initial=0, String name=SpinCtrlNameStr) -> SpinCtrl + + + + + + + + + + + + + + + PreSpinCtrl() -> SpinCtrl + + + Create(Window parent, int id=-1, String value=EmptyString, + Point pos=DefaultPosition, Size size=DefaultSize, + long style=SP_ARROW_KEYS, int min=0, int max=100, + int initial=0, String name=SpinCtrlNameStr) -> bool + + + + + + + + + + + + + + + GetValue() -> int + + + SetValue(int value) + + + + + + SetValueString(String text) + + + + + + SetRange(int minVal, int maxVal) + + + + + + + GetMin() -> int + + + GetMax() -> int + + + SetSelection(long from, long to) + + + + + + + +EVT_SPINCTRL = wx.PyEventBinder( wxEVT_COMMAND_SPINCTRL_UPDATED, 1) + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, String label, Point point=DefaultPosition, + Size size=DefaultSize, int choices=0, + String choices_array=None, int majorDimension=0, + long style=RA_HORIZONTAL, Validator validator=DefaultValidator, + String name=RadioBoxNameStr) -> RadioBox + + + + + + + + + + + + + + + + PreRadioBox() -> RadioBox + + + Create(Window parent, int id, String label, Point point=DefaultPosition, + Size size=DefaultSize, int choices=0, + String choices_array=None, int majorDimension=0, + long style=RA_HORIZONTAL, Validator validator=DefaultValidator, + String name=RadioBoxNameStr) -> bool + + + + + + + + + + + + + + + + SetSelection(int n) + + + + + + GetSelection() -> int + + + GetStringSelection() -> String + + + SetStringSelection(String s) -> bool + + + + + + GetCount() -> int + + + FindString(String s) -> int + + + + + + GetString(int n) -> String + + + + + + SetString(int n, String label) + + + + + + + EnableItem(int n, bool enable=True) + + + + + + + ShowItem(int n, bool show=True) + + + + + + + GetColumnCount() -> int + + + GetRowCount() -> int + + + GetNextItem(int item, int dir, long style) -> int + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, String label, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + Validator validator=DefaultValidator, String name=RadioButtonNameStr) -> RadioButton + + + + + + + + + + + + + PreRadioButton() -> RadioButton + + + Create(Window parent, int id, String label, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + Validator validator=DefaultValidator, String name=RadioButtonNameStr) -> bool + + + + + + + + + + + + + GetValue() -> bool + + + SetValue(bool value) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, int value, int minValue, int maxValue, + Point point=DefaultPosition, Size size=DefaultSize, + long style=SL_HORIZONTAL, Validator validator=DefaultValidator, + String name=SliderNameStr) -> Slider + + + + + + + + + + + + + + + PreSlider() -> Slider + + + Create(Window parent, int id, int value, int minValue, int maxValue, + Point point=DefaultPosition, Size size=DefaultSize, + long style=SL_HORIZONTAL, Validator validator=DefaultValidator, + String name=SliderNameStr) -> bool + + + + + + + + + + + + + + + GetValue() -> int + + + SetValue(int value) + + + + + + SetRange(int minValue, int maxValue) + + + + + + + GetMin() -> int + + + GetMax() -> int + + + SetMin(int minValue) + + + + + + SetMax(int maxValue) + + + + + + SetLineSize(int lineSize) + + + + + + SetPageSize(int pageSize) + + + + + + GetLineSize() -> int + + + GetPageSize() -> int + + + SetThumbLength(int lenPixels) + + + + + + GetThumbLength() -> int + + + SetTickFreq(int n, int pos) + + + + + + + GetTickFreq() -> int + + + ClearTicks() + + + SetTick(int tickPos) + + + + + + ClearSel() + + + GetSelEnd() -> int + + + GetSelStart() -> int + + + SetSelection(int min, int max) + + + + + + + +#--------------------------------------------------------------------------- + + + EVT_TOGGLEBUTTON = wx.PyEventBinder( wxEVT_COMMAND_TOGGLEBUTTON_CLICKED, 1) + + + + + __init__(Window parent, int id, String label, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + Validator validator=DefaultValidator, String name=ToggleButtonNameStr) -> ToggleButton + + + + + + + + + + + + + PreToggleButton() -> ToggleButton + + + Create(Window parent, int id, String label, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, + Validator validator=DefaultValidator, String name=ToggleButtonNameStr) -> bool + + + + + + + + + + + + + SetValue(bool value) + + + + + + GetValue() -> bool + + + SetLabel(String label) + + + + + + +#--------------------------------------------------------------------------- + + + + + GetPageCount() -> size_t + + + GetPage(size_t n) -> Window + + + + + + GetSelection() -> int + + + SetPageText(size_t n, String strText) -> bool + + + + + + + GetPageText(size_t n) -> String + + + + + + SetImageList(ImageList imageList) + + + + + + AssignImageList(ImageList imageList) + + + + + + GetImageList() -> ImageList + + + GetPageImage(size_t n) -> int + + + + + + SetPageImage(size_t n, int imageId) -> bool + + + + + + + SetPageSize(Size size) + + + + + + CalcSizeFromPage(Size sizePage) -> Size + + + + + + DeletePage(size_t n) -> bool + + + + + + RemovePage(size_t n) -> bool + + + + + + DeleteAllPages() -> bool + + + AddPage(Window page, String text, bool select=False, int imageId=-1) -> bool + + + + + + + + + InsertPage(size_t n, Window page, String text, bool select=False, + int imageId=-1) -> bool + + + + + + + + + + SetSelection(size_t n) -> int + + + + + + AdvanceSelection(bool forward=True) + + + + + + + + + __init__(wxEventType commandType=wxEVT_NULL, int id=0, int nSel=-1, + int nOldSel=-1) -> BookCtrlEvent + + + + + + + + + GetSelection() -> int + + + SetSelection(int nSel) + + + + + + GetOldSelection() -> int + + + SetOldSelection(int nOldSel) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, String name=NOTEBOOK_NAME) -> Notebook + + + + + + + + + + + PreNotebook() -> Notebook + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, String name=NOTEBOOK_NAME) -> bool + + + + + + + + + + + GetRowCount() -> int + + + SetPadding(Size padding) + + + + + + SetTabSize(Size sz) + + + + + + HitTest(Point pt) -> (tab, where) + Returns the tab which is hit, and flags indicating where using wxNB_HITTEST_ flags. + + + + + + + CalcSizeFromPage(Size sizePage) -> Size + + + + + + + + + __init__(wxEventType commandType=wxEVT_NULL, int id=0, int nSel=-1, + int nOldSel=-1) -> NotebookEvent + + + + + + + + + + # wxNotebook events + EVT_NOTEBOOK_PAGE_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED, 1 ) + EVT_NOTEBOOK_PAGE_CHANGING = wx.PyEventBinder( wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING, 1 ) + + +#---------------------------------------------------------------------------- + +class NotebookPage(wx.Panel): + """ + There is an old (and apparently unsolvable) bug when placing a + window with a nonstandard background colour in a wxNotebook on + wxGTK, as the notbooks's background colour would always be used + when the window is refreshed. The solution is to place a panel in + the notbook and the coloured window on the panel, sized to cover + the panel. This simple class does that for you, just put an + instance of this in the notebook and make your regular window a + child of this one and it will handle the resize for you. + """ + def __init__(self, parent, id=-1, + pos=wx.DefaultPosition, size=wx.DefaultSize, + style=wx.TAB_TRAVERSAL, name="panel"): + wx.Panel.__init__(self, parent, id, pos, size, style, name) + self.child = None + EVT_SIZE(self, self.OnSize) + + def OnSize(self, evt): + if self.child is None: + children = self.GetChildren() + if len(children): + self.child = children[0] + if self.child: + self.child.SetPosition((0,0)) + self.child.SetSize(self.GetSize()) + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, String name=EmptyString) -> Listbook + + + + + + + + + + + PreListbook() -> Listbook + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, String name=EmptyString) -> bool + + + + + + + + + + + IsVertical() -> bool + + + + + + __init__(wxEventType commandType=wxEVT_NULL, int id=0, int nSel=-1, + int nOldSel=-1) -> ListbookEvent + + + + + + + + + + EVT_LISTBOOK_PAGE_CHANGED = wx.PyEventBinder( wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED, 1 ) + EVT_LISTBOOK_PAGE_CHANGING = wx.PyEventBinder( wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING, 1 ) + + +#--------------------------------------------------------------------------- + + + + + __init__(BookCtrl nb) -> BookCtrlSizer + + + + + + RecalcSizes() + + + CalcMin() -> Size + + + GetControl() -> BookCtrl + + + + + + __init__(Notebook nb) -> NotebookSizer + + + + + + RecalcSizes() + + + CalcMin() -> Size + + + GetNotebook() -> Notebook + + + +#--------------------------------------------------------------------------- + + + + + GetId() -> int + + + GetControl() -> Control + + + GetToolBar() -> ToolBarBase + + + IsButton() -> int + + + IsControl() -> int + + + IsSeparator() -> int + + + GetStyle() -> int + + + GetKind() -> int + + + IsEnabled() -> bool + + + IsToggled() -> bool + + + CanBeToggled() -> bool + + + GetNormalBitmap() -> Bitmap + + + GetDisabledBitmap() -> Bitmap + + + GetBitmap() -> Bitmap + + + GetLabel() -> String + + + GetShortHelp() -> String + + + GetLongHelp() -> String + + + Enable(bool enable) -> bool + + + + + + Toggle() + + + SetToggle(bool toggle) -> bool + + + + + + SetShortHelp(String help) -> bool + + + + + + SetLongHelp(String help) -> bool + + + + + + SetNormalBitmap(Bitmap bmp) + + + + + + SetDisabledBitmap(Bitmap bmp) + + + + + + SetLabel(String label) + + + + + + Detach() + + + Attach(ToolBarBase tbar) + + + + + + GetClientData() -> PyObject + + + SetClientData(PyObject clientData) + + + + + + + + + DoAddTool(int id, String label, Bitmap bitmap, Bitmap bmpDisabled=wxNullBitmap, + int kind=ITEM_NORMAL, String shortHelp=EmptyString, + String longHelp=EmptyString, + PyObject clientData=None) -> ToolBarToolBase + + + + + + + + + + + + + DoInsertTool(size_t pos, int id, String label, Bitmap bitmap, Bitmap bmpDisabled=wxNullBitmap, + int kind=ITEM_NORMAL, + String shortHelp=EmptyString, String longHelp=EmptyString, + PyObject clientData=None) -> ToolBarToolBase + + + + + + + + + + + + + + AddToolItem(ToolBarToolBase tool) -> ToolBarToolBase + + + + + + InsertToolItem(size_t pos, ToolBarToolBase tool) -> ToolBarToolBase + + + + + + + AddControl(Control control) -> ToolBarToolBase + + + + + + InsertControl(size_t pos, Control control) -> ToolBarToolBase + + + + + + + FindControl(int id) -> Control + + + + + + AddSeparator() -> ToolBarToolBase + + + InsertSeparator(size_t pos) -> ToolBarToolBase + + + + + + RemoveTool(int id) -> ToolBarToolBase + + + + + + DeleteToolByPos(size_t pos) -> bool + + + + + + DeleteTool(int id) -> bool + + + + + + ClearTools() + + + Realize() -> bool + + + EnableTool(int id, bool enable) + + + + + + + ToggleTool(int id, bool toggle) + + + + + + + SetToggle(int id, bool toggle) + + + + + + + GetToolClientData(int id) -> PyObject + + + + + + SetToolClientData(int id, PyObject clientData) + + + + + + + GetToolPos(int id) -> int + + + + + + GetToolState(int id) -> bool + + + + + + GetToolEnabled(int id) -> bool + + + + + + SetToolShortHelp(int id, String helpString) + + + + + + + GetToolShortHelp(int id) -> String + + + + + + SetToolLongHelp(int id, String helpString) + + + + + + + GetToolLongHelp(int id) -> String + + + + + + SetMarginsXY(int x, int y) + + + + + + + SetMargins(Size size) + + + + + + SetToolPacking(int packing) + + + + + + SetToolSeparation(int separation) + + + + + + GetToolMargins() -> Size + + + GetMargins() -> Size + + + GetToolPacking() -> int + + + GetToolSeparation() -> int + + + SetRows(int nRows) + + + + + + SetMaxRowsCols(int rows, int cols) + + + + + + + GetMaxRows() -> int + + + GetMaxCols() -> int + + + SetToolBitmapSize(Size size) + + + + + + GetToolBitmapSize() -> Size + + + GetToolSize() -> Size + + + FindToolForPosition(int x, int y) -> ToolBarToolBase + + + + + + + FindById(int toolid) -> ToolBarToolBase + + + + + + IsVertical() -> bool + + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=wxNO_BORDER|wxTB_HORIZONTAL, + String name=wxPyToolBarNameStr) -> ToolBar + + + + + + + + + + + PreToolBar() -> ToolBar + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=wxNO_BORDER|wxTB_HORIZONTAL, + String name=wxPyToolBarNameStr) -> bool + + + + + + + + + + + FindToolForPosition(int x, int y) -> ToolBarToolBase + + + + + + + +#--------------------------------------------------------------------------- + + +#--------------------------------------------------------------------------- + + + + __init__(Colour colText=wxNullColour, Colour colBack=wxNullColour, + Font font=wxNullFont) -> ListItemAttr + + + + + + + + SetTextColour(Colour colText) + + + + + + SetBackgroundColour(Colour colBack) + + + + + + SetFont(Font font) + + + + + + HasTextColour() -> bool + + + HasBackgroundColour() -> bool + + + HasFont() -> bool + + + GetTextColour() -> Colour + + + GetBackgroundColour() -> Colour + + + GetFont() -> Font + + + Destroy() + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> ListItem + + + __del__() + + + Clear() + + + ClearAttributes() + + + SetMask(long mask) + + + + + + SetId(long id) + + + + + + SetColumn(int col) + + + + + + SetState(long state) + + + + + + SetStateMask(long stateMask) + + + + + + SetText(String text) + + + + + + SetImage(int image) + + + + + + SetData(long data) + + + + + + SetWidth(int width) + + + + + + SetAlign(int align) + + + + + + SetTextColour(Colour colText) + + + + + + SetBackgroundColour(Colour colBack) + + + + + + SetFont(Font font) + + + + + + GetMask() -> long + + + GetId() -> long + + + GetColumn() -> int + + + GetState() -> long + + + GetText() -> String + + + GetImage() -> int + + + GetData() -> long + + + GetWidth() -> int + + + GetAlign() -> int + + + GetAttributes() -> ListItemAttr + + + HasAttributes() -> bool + + + GetTextColour() -> Colour + + + GetBackgroundColour() -> Colour + + + GetFont() -> Font + + + + + + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(wxEventType commandType=wxEVT_NULL, int id=0) -> ListEvent + + + + + + + + + + + + + GetKeyCode() -> int + + + GetIndex() -> long + + + GetColumn() -> int + + + GetPoint() -> Point + + + GetLabel() -> String + + + GetText() -> String + + + GetImage() -> int + + + GetData() -> long + + + GetMask() -> long + + + GetItem() -> ListItem + + + GetCacheFrom() -> long + + + GetCacheTo() -> long + + + IsEditCancelled() -> bool + + + SetEditCanceled(bool editCancelled) + + + + + + + +EVT_LIST_BEGIN_DRAG = wx.PyEventBinder(wxEVT_COMMAND_LIST_BEGIN_DRAG , 1) +EVT_LIST_BEGIN_RDRAG = wx.PyEventBinder(wxEVT_COMMAND_LIST_BEGIN_RDRAG , 1) +EVT_LIST_BEGIN_LABEL_EDIT = wx.PyEventBinder(wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT , 1) +EVT_LIST_END_LABEL_EDIT = wx.PyEventBinder(wxEVT_COMMAND_LIST_END_LABEL_EDIT , 1) +EVT_LIST_DELETE_ITEM = wx.PyEventBinder(wxEVT_COMMAND_LIST_DELETE_ITEM , 1) +EVT_LIST_DELETE_ALL_ITEMS = wx.PyEventBinder(wxEVT_COMMAND_LIST_DELETE_ALL_ITEMS , 1) +EVT_LIST_GET_INFO = wx.PyEventBinder(wxEVT_COMMAND_LIST_GET_INFO , 1) +EVT_LIST_SET_INFO = wx.PyEventBinder(wxEVT_COMMAND_LIST_SET_INFO , 1) +EVT_LIST_ITEM_SELECTED = wx.PyEventBinder(wxEVT_COMMAND_LIST_ITEM_SELECTED , 1) +EVT_LIST_ITEM_DESELECTED = wx.PyEventBinder(wxEVT_COMMAND_LIST_ITEM_DESELECTED , 1) +EVT_LIST_KEY_DOWN = wx.PyEventBinder(wxEVT_COMMAND_LIST_KEY_DOWN , 1) +EVT_LIST_INSERT_ITEM = wx.PyEventBinder(wxEVT_COMMAND_LIST_INSERT_ITEM , 1) +EVT_LIST_COL_CLICK = wx.PyEventBinder(wxEVT_COMMAND_LIST_COL_CLICK , 1) +EVT_LIST_ITEM_RIGHT_CLICK = wx.PyEventBinder(wxEVT_COMMAND_LIST_ITEM_RIGHT_CLICK , 1) +EVT_LIST_ITEM_MIDDLE_CLICK = wx.PyEventBinder(wxEVT_COMMAND_LIST_ITEM_MIDDLE_CLICK, 1) +EVT_LIST_ITEM_ACTIVATED = wx.PyEventBinder(wxEVT_COMMAND_LIST_ITEM_ACTIVATED , 1) +EVT_LIST_CACHE_HINT = wx.PyEventBinder(wxEVT_COMMAND_LIST_CACHE_HINT , 1) +EVT_LIST_COL_RIGHT_CLICK = wx.PyEventBinder(wxEVT_COMMAND_LIST_COL_RIGHT_CLICK , 1) +EVT_LIST_COL_BEGIN_DRAG = wx.PyEventBinder(wxEVT_COMMAND_LIST_COL_BEGIN_DRAG , 1) +EVT_LIST_COL_DRAGGING = wx.PyEventBinder(wxEVT_COMMAND_LIST_COL_DRAGGING , 1) +EVT_LIST_COL_END_DRAG = wx.PyEventBinder(wxEVT_COMMAND_LIST_COL_END_DRAG , 1) +EVT_LIST_ITEM_FOCUSED = wx.PyEventBinder(wxEVT_COMMAND_LIST_ITEM_FOCUSED , 1) + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=LC_ICON, + Validator validator=DefaultValidator, String name=ListCtrlNameStr) -> ListCtrl + + + + + + + + + + + + PreListCtrl() -> ListCtrl + + + Create(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=LC_ICON, + Validator validator=DefaultValidator, String name=ListCtrlNameStr) -> bool + + + + + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + SetForegroundColour(Colour col) -> bool + + + + + + SetBackgroundColour(Colour col) -> bool + + + + + + GetColumn(int col) -> ListItem + + + + + + SetColumn(int col, ListItem item) -> bool + + + + + + + GetColumnWidth(int col) -> int + + + + + + SetColumnWidth(int col, int width) -> bool + + + + + + + GetCountPerPage() -> int + + + GetViewRect() -> Rect + + + GetItem(long itemId, int col=0) -> ListItem + + + + + + + SetItem(ListItem info) -> bool + + + + + + SetStringItem(long index, int col, String label, int imageId=-1) -> long + + + + + + + + + GetItemState(long item, long stateMask) -> int + + + + + + + SetItemState(long item, long state, long stateMask) -> bool + + + + + + + + SetItemImage(long item, int image, int selImage) -> bool + + + + + + + + GetItemText(long item) -> String + + + + + + SetItemText(long item, String str) + + + + + + + GetItemData(long item) -> long + + + + + + SetItemData(long item, long data) -> bool + + + + + + + GetItemPosition(long item) -> Point + + + + + + GetItemRect(long item, int code=LIST_RECT_BOUNDS) -> Rect + + + + + + + SetItemPosition(long item, Point pos) -> bool + + + + + + + GetItemCount() -> int + + + GetColumnCount() -> int + + + GetItemSpacing() -> Size + + + SetItemSpacing(int spacing, bool isSmall=False) + + + + + + + GetSelectedItemCount() -> int + + + GetTextColour() -> Colour + + + SetTextColour(Colour col) + + + + + + GetTopItem() -> long + + + SetSingleStyle(long style, bool add=True) + + + + + + + SetWindowStyleFlag(long style) + + + + + + GetNextItem(long item, int geometry=LIST_NEXT_ALL, int state=LIST_STATE_DONTCARE) -> long + + + + + + + + GetImageList(int which) -> ImageList + + + + + + SetImageList(ImageList imageList, int which) + + + + + + + AssignImageList(ImageList imageList, int which) + + + + + + + IsVirtual() -> bool + + + RefreshItem(long item) + + + + + + RefreshItems(long itemFrom, long itemTo) + + + + + + + Arrange(int flag=LIST_ALIGN_DEFAULT) -> bool + + + + + + DeleteItem(long item) -> bool + + + + + + DeleteAllItems() -> bool + + + DeleteColumn(int col) -> bool + + + + + + DeleteAllColumns() -> bool + + + ClearAll() + + + EditLabel(long item) + + + + + + EnsureVisible(long item) -> bool + + + + + + FindItem(long start, String str, bool partial=False) -> long + + + + + + + + FindItemData(long start, long data) -> long + + + + + + + FindItemAtPos(long start, Point pt, int direction) -> long + + + + + + + + HitTest(Point point) -> (item, where) + Determines which item (if any) is at the specified point, +giving details in the second return value (see wxLIST_HITTEST_... flags.) + + + + + + + InsertItem(ListItem info) -> long + + + + + + InsertStringItem(long index, String label) -> long + + + + + + + InsertImageItem(long index, int imageIndex) -> long + + + + + + + InsertImageStringItem(long index, String label, int imageIndex) -> long + + + + + + + + InsertColumnInfo(long col, ListItem info) -> long + + + + + + + InsertColumn(long col, String heading, int format=LIST_FORMAT_LEFT, + int width=-1) -> long + + + + + + + + + SetItemCount(long count) + + + + + + ScrollList(int dx, int dy) -> bool + + + + + + + SetItemTextColour(long item, Colour col) + + + + + + + GetItemTextColour(long item) -> Colour + + + + + + SetItemBackgroundColour(long item, Colour col) + + + + + + + GetItemBackgroundColour(long item) -> Colour + + + + + + SortItems(PyObject func) -> bool + + + + + + GetMainWindow() -> Window + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=LC_REPORT, + Validator validator=DefaultValidator, String name=ListCtrlNameStr) -> ListView + + + + + + + + + + + + PreListView() -> ListView + + + Create(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=LC_REPORT, + Validator validator=DefaultValidator, String name=ListCtrlNameStr) -> bool + + + + + + + + + + + + Select(long n, bool on=True) + + + + + + + Focus(long index) + + + + + + GetFocusedItem() -> long + + + GetNextSelected(long item) -> long + + + + + + GetFirstSelected() -> long + + + IsSelected(long index) -> bool + + + + + + SetColumnImage(int col, int image) + + + + + + + ClearColumnImage(int col) + + + + + + +#--------------------------------------------------------------------------- + + +#--------------------------------------------------------------------------- + + + + __init__() -> TreeItemId + + + __del__() + + + IsOk() -> bool + + + __eq__(TreeItemId other) -> bool + + + + + + __ne__(TreeItemId other) -> bool + + + + + + + + + __init__(PyObject obj=None) -> TreeItemData + + + + + + GetData() -> PyObject + + + SetData(PyObject obj) + + + + + + GetId() -> TreeItemId + + + SetId(TreeItemId id) + + + + + + Destroy() + + + +#--------------------------------------------------------------------------- + + + +EVT_TREE_BEGIN_DRAG = wx.PyEventBinder(wxEVT_COMMAND_TREE_BEGIN_DRAG , 1) +EVT_TREE_BEGIN_RDRAG = wx.PyEventBinder(wxEVT_COMMAND_TREE_BEGIN_RDRAG , 1) +EVT_TREE_BEGIN_LABEL_EDIT = wx.PyEventBinder(wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT , 1) +EVT_TREE_END_LABEL_EDIT = wx.PyEventBinder(wxEVT_COMMAND_TREE_END_LABEL_EDIT , 1) +EVT_TREE_DELETE_ITEM = wx.PyEventBinder(wxEVT_COMMAND_TREE_DELETE_ITEM , 1) +EVT_TREE_GET_INFO = wx.PyEventBinder(wxEVT_COMMAND_TREE_GET_INFO , 1) +EVT_TREE_SET_INFO = wx.PyEventBinder(wxEVT_COMMAND_TREE_SET_INFO , 1) +EVT_TREE_ITEM_EXPANDED = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_EXPANDED , 1) +EVT_TREE_ITEM_EXPANDING = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_EXPANDING , 1) +EVT_TREE_ITEM_COLLAPSED = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_COLLAPSED , 1) +EVT_TREE_ITEM_COLLAPSING = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_COLLAPSING , 1) +EVT_TREE_SEL_CHANGED = wx.PyEventBinder(wxEVT_COMMAND_TREE_SEL_CHANGED , 1) +EVT_TREE_SEL_CHANGING = wx.PyEventBinder(wxEVT_COMMAND_TREE_SEL_CHANGING , 1) +EVT_TREE_KEY_DOWN = wx.PyEventBinder(wxEVT_COMMAND_TREE_KEY_DOWN , 1) +EVT_TREE_ITEM_ACTIVATED = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_ACTIVATED , 1) +EVT_TREE_ITEM_RIGHT_CLICK = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_RIGHT_CLICK , 1) +EVT_TREE_ITEM_MIDDLE_CLICK = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_MIDDLE_CLICK, 1) +EVT_TREE_END_DRAG = wx.PyEventBinder(wxEVT_COMMAND_TREE_END_DRAG , 1) +EVT_TREE_STATE_IMAGE_CLICK = wx.PyEventBinder(wxEVT_COMMAND_TREE_STATE_IMAGE_CLICK, 1) +EVT_TREE_ITEM_GETTOOLTIP = wx.PyEventBinder(wxEVT_COMMAND_TREE_ITEM_GETTOOLTIP, 1) + + + + + __init__(wxEventType commandType=wxEVT_NULL, int id=0) -> TreeEvent + + + + + + + GetItem() -> TreeItemId + + + SetItem(TreeItemId item) + + + + + + GetOldItem() -> TreeItemId + + + SetOldItem(TreeItemId item) + + + + + + GetPoint() -> Point + + + SetPoint(Point pt) + + + + + + GetKeyEvent() -> KeyEvent + + + GetKeyCode() -> int + + + SetKeyEvent(KeyEvent evt) + + + + + + GetLabel() -> String + + + SetLabel(String label) + + + + + + IsEditCancelled() -> bool + + + SetEditCanceled(bool editCancelled) + + + + + + SetToolTip(String toolTip) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=TR_DEFAULT_STYLE, + Validator validator=DefaultValidator, + String name=TreeCtrlNameStr) -> TreeCtrl + + + + + + + + + + + + PreTreeCtrl() -> TreeCtrl + + + Create(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=TR_DEFAULT_STYLE, + Validator validator=DefaultValidator, + String name=TreeCtrlNameStr) -> bool + + + + + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + GetCount() -> size_t + + + GetIndent() -> unsigned int + + + SetIndent(unsigned int indent) + + + + + + GetSpacing() -> unsigned int + + + SetSpacing(unsigned int spacing) + + + + + + GetImageList() -> ImageList + + + GetStateImageList() -> ImageList + + + SetImageList(ImageList imageList) + + + + + + SetStateImageList(ImageList imageList) + + + + + + AssignImageList(ImageList imageList) + + + + + + AssignStateImageList(ImageList imageList) + + + + + + GetItemText(TreeItemId item) -> String + + + + + + GetItemImage(TreeItemId item, int which=TreeItemIcon_Normal) -> int + + + + + + + GetItemData(TreeItemId item) -> TreeItemData + + + + + + GetItemPyData(TreeItemId item) -> PyObject + + + + + + GetItemTextColour(TreeItemId item) -> Colour + + + + + + GetItemBackgroundColour(TreeItemId item) -> Colour + + + + + + GetItemFont(TreeItemId item) -> Font + + + + + + SetItemText(TreeItemId item, String text) + + + + + + + SetItemImage(TreeItemId item, int image, int which=TreeItemIcon_Normal) + + + + + + + + SetItemData(TreeItemId item, TreeItemData data) + + + + + + + SetItemPyData(TreeItemId item, PyObject obj) + + + + + + + SetItemHasChildren(TreeItemId item, bool has=True) + + + + + + + SetItemBold(TreeItemId item, bool bold=True) + + + + + + + SetItemTextColour(TreeItemId item, Colour col) + + + + + + + SetItemBackgroundColour(TreeItemId item, Colour col) + + + + + + + SetItemFont(TreeItemId item, Font font) + + + + + + + IsVisible(TreeItemId item) -> bool + + + + + + ItemHasChildren(TreeItemId item) -> bool + + + + + + IsExpanded(TreeItemId item) -> bool + + + + + + IsSelected(TreeItemId item) -> bool + + + + + + IsBold(TreeItemId item) -> bool + + + + + + GetChildrenCount(TreeItemId item, bool recursively=True) -> size_t + + + + + + + GetRootItem() -> TreeItemId + + + GetSelection() -> TreeItemId + + + GetSelections() -> PyObject + + + GetItemParent(TreeItemId item) -> TreeItemId + + + + + + GetFirstChild(TreeItemId item) -> PyObject + + + + + + GetNextChild(TreeItemId item, wxTreeItemIdValue cookie) -> PyObject + + + + + + + GetLastChild(TreeItemId item) -> TreeItemId + + + + + + GetNextSibling(TreeItemId item) -> TreeItemId + + + + + + GetPrevSibling(TreeItemId item) -> TreeItemId + + + + + + GetFirstVisibleItem() -> TreeItemId + + + GetNextVisible(TreeItemId item) -> TreeItemId + + + + + + GetPrevVisible(TreeItemId item) -> TreeItemId + + + + + + AddRoot(String text, int image=-1, int selectedImage=-1, TreeItemData data=None) -> TreeItemId + + + + + + + + + PrependItem(TreeItemId parent, String text, int image=-1, int selectedImage=-1, + TreeItemData data=None) -> TreeItemId + + + + + + + + + + InsertItem(TreeItemId parent, TreeItemId idPrevious, String text, + int image=-1, int selectedImage=-1, TreeItemData data=None) -> TreeItemId + + + + + + + + + + + InsertItemBefore(TreeItemId parent, size_t index, String text, int image=-1, + int selectedImage=-1, TreeItemData data=None) -> TreeItemId + + + + + + + + + + + AppendItem(TreeItemId parent, String text, int image=-1, int selectedImage=-1, + TreeItemData data=None) -> TreeItemId + + + + + + + + + + Delete(TreeItemId item) + + + + + + DeleteChildren(TreeItemId item) + + + + + + DeleteAllItems() + + + Expand(TreeItemId item) + + + + + + Collapse(TreeItemId item) + + + + + + CollapseAndReset(TreeItemId item) + + + + + + Toggle(TreeItemId item) + + + + + + Unselect() + + + UnselectAll() + + + SelectItem(TreeItemId item) + + + + + + EnsureVisible(TreeItemId item) + + + + + + ScrollTo(TreeItemId item) + + + + + + EditLabel(TreeItemId item) + + + + + + GetEditControl() -> TextCtrl + + + SortChildren(TreeItemId item) + + + + + + HitTest(Point point) -> (item, where) + Determine which item (if any) belongs the given point. The +coordinates specified are relative to the client area of tree ctrl +and the where return value is set to a bitmask of wxTREE_HITTEST_xxx +constants. + + + + + + + + GetBoundingRect(TreeItemId item, bool textOnly=False) -> PyObject + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id=-1, String dir=DirDialogDefaultFolderStr, + Point pos=DefaultPosition, Size size=DefaultSize, + long style=wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER, + String filter=EmptyString, + int defaultFilter=0, String name=TreeCtrlNameStr) -> GenericDirCtrl + + + + + + + + + + + + + + PreGenericDirCtrl() -> GenericDirCtrl + + + Create(Window parent, int id=-1, String dir=DirDialogDefaultFolderStr, + Point pos=DefaultPosition, Size size=DefaultSize, + long style=wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER, + String filter=EmptyString, + int defaultFilter=0, String name=TreeCtrlNameStr) -> bool + + + + + + + + + + + + + + ExpandPath(String path) -> bool + + + + + + GetDefaultPath() -> String + + + SetDefaultPath(String path) + + + + + + GetPath() -> String + + + GetFilePath() -> String + + + SetPath(String path) + + + + + + ShowHidden(bool show) + + + + + + GetShowHidden() -> bool + + + GetFilter() -> String + + + SetFilter(String filter) + + + + + + GetFilterIndex() -> int + + + SetFilterIndex(int n) + + + + + + GetRootId() -> TreeItemId + + + GetTreeCtrl() -> TreeCtrl + + + GetFilterListCtrl() -> DirFilterListCtrl + + + FindChild(wxTreeItemId parentId, wxString path) -> (item, done) + Find the child that matches the first part of 'path'. E.g. if a child path is +"/usr" and 'path' is "/usr/include" then the child for /usr is returned. +If the path string has been used (we're at the leaf), done is set to True + + + + + + + + + DoResize() + + + ReCreateTree() + + + + + + __init__(GenericDirCtrl parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0) -> DirFilterListCtrl + + + + + + + + + + PreDirFilterListCtrl() -> DirFilterListCtrl + + + Create(GenericDirCtrl parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0) -> bool + + + + + + + + + + FillFilterList(String filter, int defaultFilter) + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, Validator validator=DefaultValidator, + String name=ControlNameStr) -> PyControl + + + + + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_DoMoveWindow(int x, int y, int width, int height) + + + + + + + + + base_DoSetSize(int x, int y, int width, int height, int sizeFlags=SIZE_AUTO) + + + + + + + + + + base_DoSetClientSize(int width, int height) + + + + + + + base_DoSetVirtualSize(int x, int y) + + + + + + + base_DoGetSize() -> (width, height) + + + + + + + base_DoGetClientSize() -> (width, height) + + + + + + + base_DoGetPosition() -> (x,y) + + + + + + + base_DoGetVirtualSize() -> Size + + + base_DoGetBestSize() -> Size + + + base_InitDialog() + + + base_TransferDataToWindow() -> bool + + + base_TransferDataFromWindow() -> bool + + + base_Validate() -> bool + + + base_AcceptsFocus() -> bool + + + base_AcceptsFocusFromKeyboard() -> bool + + + base_GetMaxSize() -> Size + + + base_AddChild(Window child) + + + + + + base_RemoveChild(Window child) + + + + + + +#--------------------------------------------------------------------------- + + +EVT_HELP = wx.PyEventBinder( wxEVT_HELP, 1) +EVT_HELP_RANGE = wx.PyEventBinder( wxEVT_HELP, 2) +EVT_DETAILED_HELP = wx.PyEventBinder( wxEVT_DETAILED_HELP, 1) +EVT_DETAILED_HELP_RANGE = wx.PyEventBinder( wxEVT_DETAILED_HELP, 2) + + + + + __init__(wxEventType type=wxEVT_NULL, int winid=0, Point pt=DefaultPosition) -> HelpEvent + + + + + + + + GetPosition() -> Point + + + SetPosition(Point pos) + + + + + + GetLink() -> String + + + SetLink(String link) + + + + + + GetTarget() -> String + + + SetTarget(String target) + + + + + + + + + __init__(Window window=None, bool doNow=True) -> ContextHelp + + + + + + + __del__() + + + BeginContextHelp(Window window=None) -> bool + + + + + + EndContextHelp() -> bool + + + + + + __init__(Window parent, int id=ID_CONTEXT_HELP, Point pos=DefaultPosition, + Size size=DefaultSize, long style=BU_AUTODRAW) -> ContextHelpButton + + + + + + + + + + + + HelpProvider.Set(HelpProvider helpProvider) -> HelpProvider + + + + + + HelpProvider.Get() -> HelpProvider + + + GetHelp(Window window) -> String + + + + + + ShowHelp(Window window) -> bool + + + + + + AddHelp(Window window, String text) + + + + + + + AddHelpById(int id, String text) + + + + + + + Destroy() + + + + + + __init__() -> SimpleHelpProvider + + + +#--------------------------------------------------------------------------- + + + + + __init__(Bitmap image, Cursor cursor=wxNullCursor) -> DragImage + + + + + + + DragIcon(Icon image, Cursor cursor=wxNullCursor) -> DragImage + + + + + + + DragString(String str, Cursor cursor=wxNullCursor) -> DragImage + + + + + + + DragTreeItem(TreeCtrl treeCtrl, TreeItemId id) -> DragImage + + + + + + + DragListItem(ListCtrl listCtrl, long id) -> DragImage + + + + + + + __del__() + + + SetBackingBitmap(Bitmap bitmap) + + + + + + BeginDrag(Point hotspot, Window window, bool fullScreen=False, + Rect rect=None) -> bool + + + + + + + + + BeginDragBounded(Point hotspot, Window window, Window boundingWindow) -> bool + + + + + + + + EndDrag() -> bool + + + Move(Point pt) -> bool + + + + + + Show() -> bool + + + Hide() -> bool + + + GetImageRect(Point pos) -> Rect + + + + + + DoDrawImage(DC dc, Point pos) -> bool + + + + + + + UpdateBackingFromWindow(DC windowDC, MemoryDC destDC, Rect sourceRect, Rect destRect) -> bool + + + + + + + + + RedrawImage(Point oldPos, Point newPos, bool eraseOld, bool drawNew) -> bool + + + + + + + + + + + wx = core + +#--------------------------------------------------------------------------- + + + + SystemSettings.GetColour(int index) -> Colour + + + + + + SystemSettings.GetFont(int index) -> Font + + + + + + SystemSettings.GetMetric(int index) -> int + + + + + + SystemSettings.HasFeature(int index) -> bool + + + + + + SystemSettings.GetScreenType() -> int + + + SystemSettings.SetScreenType(int screen) + + + + + + +# backwards compatibility aliasses +SystemSettings_GetSystemColour = SystemSettings_GetColour +SystemSettings_GetSystemFont = SystemSettings_GetFont +SystemSettings_GetSystemMetric = SystemSettings_GetMetric + + + + + __init__() -> SystemOptions + + + SystemOptions.SetOption(String name, String value) + + + + + + + SystemOptions.SetOptionInt(String name, int value) + + + + + + + SystemOptions.GetOption(String name) -> String + + + + + + SystemOptions.GetOptionInt(String name) -> int + + + + + + SystemOptions.HasOption(String name) -> bool + + + + + + +#--------------------------------------------------------------------------- + + + NewId() -> long + + + RegisterId(long id) + + + + + + GetCurrentId() -> long + + + Bell() + + + EndBusyCursor() + + + GetElapsedTime(bool resetTimer=True) -> long + + + + + + GetMousePosition() -> (x,y) + + + + + + + IsBusy() -> bool + + + Now() -> String + + + Shell(String command=EmptyString) -> bool + + + + + + StartTimer() + + + GetOsVersion() -> (platform, major, minor) + + + + + + + GetOsDescription() -> String + + + GetFreeMemory() -> long + + + Shutdown(int wFlags) -> bool + + + + + + Sleep(int secs) + + + + + + Usleep(unsigned long milliseconds) + + + + + + EnableTopLevelWindows(bool enable) + + + + + + StripMenuCodes(String in) -> String + + + + + + GetEmailAddress() -> String + + + GetHostName() -> String + + + GetFullHostName() -> String + + + GetUserId() -> String + + + GetUserName() -> String + + + GetHomeDir() -> String + + + GetUserHome(String user=EmptyString) -> String + + + + + + GetProcessId() -> unsigned long + + + Trap() + + + FileSelector(String message=FileSelectorPromptStr, String default_path=EmptyString, + String default_filename=EmptyString, + String default_extension=EmptyString, + String wildcard=FileSelectorDefaultWildcardStr, + int flags=0, Window parent=None, int x=-1, + int y=-1) -> String + + + + + + + + + + + + + + LoadFileSelector(String what, String extension, String default_name=EmptyString, + Window parent=None) -> String + + + + + + + + + SaveFileSelector(String what, String extension, String default_name=EmptyString, + Window parent=None) -> String + + + + + + + + + DirSelector(String message=DirSelectorPromptStr, String defaultPath=EmptyString, + long style=DD_DEFAULT_STYLE, + Point pos=DefaultPosition, Window parent=None) -> String + + + + + + + + + + GetTextFromUser(String message, String caption=EmptyString, String default_value=EmptyString, + Window parent=None, + int x=-1, int y=-1, bool centre=True) -> String + + + + + + + + + + + + GetPasswordFromUser(String message, String caption=EmptyString, String default_value=EmptyString, + Window parent=None) -> String + + + + + + + + + GetSingleChoice(String message, String caption, int choices, String choices_array, + Window parent=None, int x=-1, + int y=-1, bool centre=True, int width=150, int height=200) -> String + + + + + + + + + + + + + + + GetSingleChoiceIndex(String message, String caption, int choices, String choices_array, + Window parent=None, int x=-1, + int y=-1, bool centre=True, int width=150, int height=200) -> int + + + + + + + + + + + + + + + MessageBox(String message, String caption=EmptyString, int style=wxOK|wxCENTRE, + Window parent=None, int x=-1, + int y=-1) -> int + + + + + + + + + + + GetNumberFromUser(String message, String prompt, String caption, long value, + long min=0, long max=100, Window parent=None, + Point pos=DefaultPosition) -> long + + + + + + + + + + + + + ColourDisplay() -> bool + + + DisplayDepth() -> int + + + GetDisplayDepth() -> int + + + DisplaySize() -> (width, height) + + + + + + + GetDisplaySize() -> Size + + + DisplaySizeMM() -> (width, height) + + + + + + + GetDisplaySizeMM() -> Size + + + ClientDisplayRect() -> (x, y, width, height) + + + + + + + + + GetClientDisplayRect() -> Rect + + + SetCursor(Cursor cursor) + + + + + + BeginBusyCursor(Cursor cursor=wxHOURGLASS_CURSOR) + + + + + + GetActiveWindow() -> Window + + + GenericFindWindowAtPoint(Point pt) -> Window + + + + + + FindWindowAtPoint(Point pt) -> Window + + + + + + GetTopLevelParent(Window win) -> Window + + + + + + GetKeyState(int key) -> bool + + + + + + WakeUpMainThread() + + + MutexGuiEnter() + + + MutexGuiLeave() + + + + __init__() -> MutexGuiLocker + + + __del__() + + + + Thread_IsMain() -> bool + + +#--------------------------------------------------------------------------- + + + + + __init__(String tip) -> ToolTip + + + + + + SetTip(String tip) + + + + + + GetTip() -> String + + + GetWindow() -> Window + + + ToolTip.Enable(bool flag) + + + + + + ToolTip.SetDelay(long milliseconds) + + + + + + + + __init__(Window window, Size size) -> Caret + + + + + + + __del__() + + + IsOk() -> bool + + + IsVisible() -> bool + + + GetPosition() -> Point + + + GetPositionTuple() -> (x,y) + + + + + + + GetSize() -> Size + + + GetSizeTuple() -> (width, height) + + + + + + + GetWindow() -> Window + + + MoveXY(int x, int y) + + + + + + + Move(Point pt) + + + + + + SetSizeWH(int width, int height) + + + + + + + SetSize(Size size) + + + + + + Show(int show=True) + + + + + + Hide() + + + + Caret_GetBlinkTime() -> int + + + Caret_SetBlinkTime(int milliseconds) + + + + + + + __init__(Cursor cursor=wxHOURGLASS_CURSOR) -> BusyCursor + + + + + + __del__() + + + + + __init__(Window winToSkip=None) -> WindowDisabler + + + + + + __del__() + + + + + + __init__(String message) -> BusyInfo + + + + + + __del__() + + + + + __init__() -> StopWatch + + + Start(long t0=0) + + + + + + Pause() + + + Resume() + + + Time() -> long + + + + + + __init__(int maxFiles=9) -> FileHistory + + + + + + __del__() + + + AddFileToHistory(String file) + + + + + + RemoveFileFromHistory(int i) + + + + + + GetMaxFiles() -> int + + + UseMenu(Menu menu) + + + + + + RemoveMenu(Menu menu) + + + + + + Load(ConfigBase config) + + + + + + Save(ConfigBase config) + + + + + + AddFilesToMenu() + + + AddFilesToThisMenu(Menu menu) + + + + + + GetHistoryFile(int i) -> String + + + + + + GetCount() -> int + + + + + __init__(String name, String path=EmptyString) -> SingleInstanceChecker + + + + + + + PreSingleInstanceChecker() -> SingleInstanceChecker + + + __del__() + + + Create(String name, String path=EmptyString) -> bool + + + + + + + IsAnotherRunning() -> bool + + + + DrawWindowOnDC(Window window, DC dc, int method) + + + + + + + +#--------------------------------------------------------------------------- + + + + __del__() + + + GetTip() -> String + + + GetCurrentTip() -> size_t + + + PreprocessTip(String tip) -> String + + + + + + + + + __init__(size_t currentTip) -> PyTipProvider + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + + ShowTip(Window parent, TipProvider tipProvider, bool showAtStartup=True) -> bool + + + + + + + + CreateFileTipProvider(String filename, size_t currentTip) -> TipProvider + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(EvtHandler owner=None, int id=-1) -> Timer + + + + + + + __del__() + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + SetOwner(EvtHandler owner, int id=-1) + + + + + + + Start(int milliseconds=-1, bool oneShot=False) -> bool + + + + + + + Stop() + + + IsRunning() -> bool + + + GetInterval() -> int + + + IsOneShot() -> bool + + + GetId() -> int + + + +# For backwards compatibility with 2.4 +class PyTimer(Timer): + def __init__(self, notify): + Timer.__init__(self) + self.notify = notify + + def Notify(self): + if self.notify: + self.notify() + + +EVT_TIMER = wx.PyEventBinder( wxEVT_TIMER, 1 ) + + + + + + __init__(int timerid=0, int interval=0) -> TimerEvent + + + + + + + GetInterval() -> int + + + + + + + + + + __init__(wxTimer timer) -> TimerRunner +__init__(wxTimer timer, int milli, bool oneShot=False) -> TimerRunner + + + + + + + + __del__() + + + Start(int milli, bool oneShot=False) + + + + + + + +#--------------------------------------------------------------------------- + + + + __init__() -> Log + + + Log.IsEnabled() -> bool + + + Log.EnableLogging(bool doIt=True) -> bool + + + + + + Log.OnLog(wxLogLevel level, wxChar szString, time_t t) + + + + + + + + Flush() + + + Log.FlushActive() + + + Log.GetActiveTarget() -> Log + + + Log.SetActiveTarget(Log pLogger) -> Log + + + + + + Log.Suspend() + + + Log.Resume() + + + Log.SetVerbose(bool bVerbose=True) + + + + + + Log.SetLogLevel(wxLogLevel logLevel) + + + + + + Log.DontCreateOnDemand() + + + Log.SetTraceMask(wxTraceMask ulMask) + + + + + + Log.AddTraceMask(String str) + + + + + + Log.RemoveTraceMask(String str) + + + + + + Log.ClearTraceMasks() + + + Log.GetTraceMasks() -> wxArrayString + + + Log.SetTimestamp(wxChar ts) + + + + + + Log.GetVerbose() -> bool + + + Log.GetTraceMask() -> wxTraceMask + + + Log.IsAllowedTraceMask(wxChar mask) -> bool + + + + + + Log.GetLogLevel() -> wxLogLevel + + + Log.GetTimestamp() -> wxChar + + + Log.TimeStamp() -> String + + + Destroy() + + + + + + __init__() -> LogStderr + + + + + + __init__(wxTextCtrl pTextCtrl) -> LogTextCtrl + + + + + + + + + __init__() -> LogGui + + + + + + __init__(wxFrame pParent, String szTitle, bool bShow=True, bool bPassToOld=True) -> LogWindow + + + + + + + + + Show(bool bShow=True) + + + + + + GetFrame() -> wxFrame + + + GetOldLog() -> Log + + + IsPassingMessages() -> bool + + + PassMessages(bool bDoPass) + + + + + + + + + __init__(Log logger) -> LogChain + + + + + + SetLog(Log logger) + + + + + + PassMessages(bool bDoPass) + + + + + + IsPassingMessages() -> bool + + + GetOldLog() -> Log + + + + SysErrorCode() -> unsigned long + + + SysErrorMsg(unsigned long nErrCode=0) -> String + + + + + + LogFatalError(String msg) + + + + + + LogError(String msg) + + + + + + LogWarning(String msg) + + + + + + LogMessage(String msg) + + + + + + LogInfo(String msg) + + + + + + LogDebug(String msg) + + + + + + LogVerbose(String msg) + + + + + + LogStatus(String msg) + + + + + + LogStatusFrame(wxFrame pFrame, String msg) + + + + + + + LogSysError(String msg) + + + + + + + + + + + + LogTrace(unsigned long mask, String msg) +LogTrace(String mask, String msg) + + + + + + + LogGeneric(unsigned long level, String msg) + + + + + + + SafeShowMessage(String title, String text) + + + + + + + + __init__() -> LogNull + + + __del__() + + + + + + __init__() -> PyLog + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(EvtHandler parent=None, int id=-1) -> Process + + + + + + + Process.Kill(int pid, int sig=SIGTERM) -> int + + + + + + + Process.Exists(int pid) -> bool + + + + + + Process.Open(String cmd, int flags=EXEC_ASYNC) -> Process + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_OnTerminate(int pid, int status) + + + + + + + Redirect() + + + IsRedirected() -> bool + + + Detach() + + + GetInputStream() -> InputStream + + + GetErrorStream() -> InputStream + + + GetOutputStream() -> OutputStream + + + CloseOutput() + + + IsInputOpened() -> bool + + + IsInputAvailable() -> bool + + + IsErrorAvailable() -> bool + + + + + + __init__(int id=0, int pid=0, int exitcode=0) -> ProcessEvent + + + + + + + + GetPid() -> int + + + GetExitCode() -> int + + + + + +EVT_END_PROCESS = wx.PyEventBinder( wxEVT_END_PROCESS, 1 ) + + + Execute(String command, int flags=EXEC_ASYNC, Process process=None) -> long + + + + + + + +#--------------------------------------------------------------------------- + + + + __init__(int joystick=JOYSTICK1) -> Joystick + + + + + + __del__() + + + GetPosition() -> Point + + + GetZPosition() -> int + + + GetButtonState() -> int + + + GetPOVPosition() -> int + + + GetPOVCTSPosition() -> int + + + GetRudderPosition() -> int + + + GetUPosition() -> int + + + GetVPosition() -> int + + + GetMovementThreshold() -> int + + + SetMovementThreshold(int threshold) + + + + + + IsOk() -> bool + + + GetNumberJoysticks() -> int + + + GetManufacturerId() -> int + + + GetProductId() -> int + + + GetProductName() -> String + + + GetXMin() -> int + + + GetYMin() -> int + + + GetZMin() -> int + + + GetXMax() -> int + + + GetYMax() -> int + + + GetZMax() -> int + + + GetNumberButtons() -> int + + + GetNumberAxes() -> int + + + GetMaxButtons() -> int + + + GetMaxAxes() -> int + + + GetPollingMin() -> int + + + GetPollingMax() -> int + + + GetRudderMin() -> int + + + GetRudderMax() -> int + + + GetUMin() -> int + + + GetUMax() -> int + + + GetVMin() -> int + + + GetVMax() -> int + + + HasRudder() -> bool + + + HasZ() -> bool + + + HasU() -> bool + + + HasV() -> bool + + + HasPOV() -> bool + + + HasPOV4Dir() -> bool + + + HasPOVCTS() -> bool + + + SetCapture(Window win, int pollingFreq=0) -> bool + + + + + + + ReleaseCapture() -> bool + + + + + + __init__(wxEventType type=wxEVT_NULL, int state=0, int joystick=JOYSTICK1, + int change=0) -> JoystickEvent + + + + + + + + + + + + + + GetPosition() -> Point + + + GetZPosition() -> int + + + GetButtonState() -> int + + + GetButtonChange() -> int + + + GetJoystick() -> int + + + SetJoystick(int stick) + + + + + + SetButtonState(int state) + + + + + + SetButtonChange(int change) + + + + + + SetPosition(Point pos) + + + + + + SetZPosition(int zPos) + + + + + + IsButton() -> bool + + + IsMove() -> bool + + + IsZMove() -> bool + + + ButtonDown(int but=JOY_BUTTON_ANY) -> bool + + + + + + ButtonUp(int but=JOY_BUTTON_ANY) -> bool + + + + + + ButtonIsDown(int but=JOY_BUTTON_ANY) -> bool + + + + + + +EVT_JOY_BUTTON_DOWN = wx.PyEventBinder( wxEVT_JOY_BUTTON_DOWN ) +EVT_JOY_BUTTON_UP = wx.PyEventBinder( wxEVT_JOY_BUTTON_UP ) +EVT_JOY_MOVE = wx.PyEventBinder( wxEVT_JOY_MOVE ) +EVT_JOY_ZMOVE = wx.PyEventBinder( wxEVT_JOY_ZMOVE ) + +EVT_JOYSTICK_EVENTS = wx.PyEventBinder([ wxEVT_JOY_BUTTON_DOWN, + wxEVT_JOY_BUTTON_UP, + wxEVT_JOY_MOVE, + wxEVT_JOY_ZMOVE, + ]) + + + +#--------------------------------------------------------------------------- + + + + __init__(String fileName, bool isResource=False) -> Wave + + + + + + + WaveData(String data) -> Wave + + + + + + __del__() + + + IsOk() -> bool + + + Play(bool async=True, bool looped=False) -> bool + + + + + + + +#--------------------------------------------------------------------------- + + + + __init__(String mimeType, String openCmd, String printCmd, String desc) -> FileTypeInfo + + + + + + + + + FileTypeInfoSequence(wxArrayString sArray) -> FileTypeInfo + + + + + + NullFileTypeInfo() -> FileTypeInfo + + + IsValid() -> bool + + + SetIcon(String iconFile, int iconIndex=0) + + + + + + + SetShortDesc(String shortDesc) + + + + + + GetMimeType() -> String + + + GetOpenCommand() -> String + + + GetPrintCommand() -> String + + + GetShortDesc() -> String + + + GetDescription() -> String + + + GetExtensions() -> wxArrayString + + + GetExtensionsCount() -> int + + + GetIconFile() -> String + + + GetIconIndex() -> int + + + + + __init__(FileTypeInfo ftInfo) -> FileType + + + + + + __del__() + + + GetMimeType() -> PyObject + + + GetMimeTypes() -> PyObject + + + GetExtensions() -> PyObject + + + GetIcon() -> Icon + + + GetIconInfo() -> PyObject + + + GetDescription() -> PyObject + + + GetOpenCommand(String filename, String mimetype=EmptyString) -> PyObject + + + + + + + GetPrintCommand(String filename, String mimetype=EmptyString) -> PyObject + + + + + + + GetAllCommands(String filename, String mimetype=EmptyString) -> PyObject + + + + + + + SetCommand(String cmd, String verb, bool overwriteprompt=True) -> bool + + + + + + + + SetDefaultIcon(String cmd=EmptyString, int index=0) -> bool + + + + + + + Unassociate() -> bool + + + FileType.ExpandCommand(String command, String filename, String mimetype=EmptyString) -> String + + + + + + + + + + __init__() -> MimeTypesManager + + + __del__() + + + MimeTypesManager.IsOfType(String mimeType, String wildcard) -> bool + + + + + + + Initialize(int mailcapStyle=MAILCAP_ALL, String extraDir=EmptyString) + + + + + + + ClearData() + + + GetFileTypeFromExtension(String ext) -> FileType + + + + + + GetFileTypeFromMimeType(String mimeType) -> FileType + + + + + + ReadMailcap(String filename, bool fallback=False) -> bool + + + + + + + ReadMimeTypes(String filename) -> bool + + + + + + EnumAllFileTypes() -> PyObject + + + AddFallback(FileTypeInfo ft) + + + + + + Associate(FileTypeInfo ftInfo) -> FileType + + + + + + Unassociate(FileType ft) -> bool + + + + + + +#--------------------------------------------------------------------------- + + + + __init__() -> ArtProvider + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + ArtProvider.PushProvider(ArtProvider provider) + Add new provider to the top of providers stack. + + + + + + ArtProvider.PopProvider() -> bool + Remove latest added provider and delete it. + + + ArtProvider.RemoveProvider(ArtProvider provider) -> bool + Remove provider. The provider must have been added previously! +The provider is _not_ deleted. + + + + + + ArtProvider.GetBitmap(String id, String client=ART_OTHER, Size size=DefaultSize) -> Bitmap + Query the providers for bitmap with given ID and return it. Return +wx.NullBitmap if no provider provides it. + + + + + + + + ArtProvider.GetIcon(String id, String client=ART_OTHER, Size size=DefaultSize) -> Icon + Query the providers for icon with given ID and return it. Return +wx.NullIcon if no provider provides it. + + + + + + + + Destroy() + + + +#--------------------------------------------------------------------------- + + + + __del__() + + + ConfigBase.Set(ConfigBase pConfig) -> ConfigBase + + + + + + ConfigBase.Get(bool createOnDemand=True) -> ConfigBase + + + + + + ConfigBase.Create() -> ConfigBase + + + ConfigBase.DontCreateOnDemand() + + + SetPath(String strPath) + + + + + + GetPath() -> String + + + GetFirstGroup() -> PyObject + + + GetNextGroup(long index) -> PyObject + + + + + + GetFirstEntry() -> PyObject + + + GetNextEntry(long index) -> PyObject + + + + + + GetNumberOfEntries(bool bRecursive=False) -> size_t + + + + + + GetNumberOfGroups(bool bRecursive=False) -> size_t + + + + + + HasGroup(String strName) -> bool + + + + + + HasEntry(String strName) -> bool + + + + + + Exists(String strName) -> bool + + + + + + GetEntryType(String name) -> int + + + + + + Read(String key, String defaultVal=EmptyString) -> String + + + + + + + ReadInt(String key, long defaultVal=0) -> long + + + + + + + ReadFloat(String key, double defaultVal=0.0) -> double + + + + + + + ReadBool(String key, bool defaultVal=False) -> bool + + + + + + + Write(String key, String value) -> bool + + + + + + + WriteInt(String key, long value) -> bool + + + + + + + WriteFloat(String key, double value) -> bool + + + + + + + WriteBool(String key, bool value) -> bool + + + + + + + Flush(bool bCurrentOnly=False) -> bool + + + + + + RenameEntry(String oldName, String newName) -> bool + + + + + + + RenameGroup(String oldName, String newName) -> bool + + + + + + + DeleteEntry(String key, bool bDeleteGroupIfEmpty=True) -> bool + + + + + + + DeleteGroup(String key) -> bool + + + + + + DeleteAll() -> bool + + + IsExpandingEnvVars() -> bool + + + SetExpandEnvVars(bool bDoIt=True) + + + + + + SetRecordDefaults(bool bDoIt=True) + + + + + + IsRecordingDefaults() -> bool + + + ExpandEnvVars(String str) -> String + + + + + + GetAppName() -> String + + + GetVendorName() -> String + + + SetAppName(String appName) + + + + + + SetVendorName(String vendorName) + + + + + + SetStyle(long style) + + + + + + GetStyle() -> long + + + + + __init__(ConfigBase pContainer, String strEntry) -> ConfigPathChanger + + + + + + + __del__() + + + Name() -> String + + + + + + __init__(String appName=EmptyString, String vendorName=EmptyString, + String localFilename=EmptyString, String globalFilename=EmptyString, + long style=0) -> Config + + + + + + + + + + __del__() + + + + + + __init__(String appName=EmptyString, String vendorName=EmptyString, + String localFilename=EmptyString, String globalFilename=EmptyString, + long style=0) -> FileConfig + + + + + + + + + + __del__() + + + + ExpandEnvVars(String sz) -> String + + + + + +#--------------------------------------------------------------------------- + + + + __init__() -> DateTime + + + DateTimeFromTimeT(time_t timet) -> DateTime + + + + + + DateTimeFromJDN(double jdn) -> DateTime + + + + + + DateTimeFromHMS(int hour, int minute=0, int second=0, int millisec=0) -> DateTime + + + + + + + + + DateTimeFromDMY(int day, int month=Inv_Month, int year=Inv_Year, int hour=0, + int minute=0, int second=0, int millisec=0) -> DateTime + + + + + + + + + + + + __del__() + + + DateTime.SetCountry(int country) + + + + + + DateTime.GetCountry() -> int + + + DateTime.IsWestEuropeanCountry(int country=Country_Default) -> bool + + + + + + DateTime.GetCurrentYear(int cal=Gregorian) -> int + + + + + + DateTime.ConvertYearToBC(int year) -> int + + + + + + DateTime.GetCurrentMonth(int cal=Gregorian) -> int + + + + + + DateTime.IsLeapYear(int year=Inv_Year, int cal=Gregorian) -> bool + + + + + + + DateTime.GetCentury(int year=Inv_Year) -> int + + + + + + DateTime.GetNumberOfDaysinYear(int year, int cal=Gregorian) -> int + + + + + + + DateTime.GetNumberOfDaysInMonth(int month, int year=Inv_Year, int cal=Gregorian) -> int + + + + + + + + DateTime.GetMonthName(int month, int flags=Name_Full) -> String + + + + + + + DateTime.GetWeekDayName(int weekday, int flags=Name_Full) -> String + + + + + + + GetAmPmStrings() -> (am, pm) + Get the AM and PM strings in the current locale (may be empty) + + + + + + + DateTime.IsDSTApplicable(int year=Inv_Year, int country=Country_Default) -> bool + + + + + + + DateTime.GetBeginDST(int year=Inv_Year, int country=Country_Default) -> DateTime + + + + + + + DateTime.GetEndDST(int year=Inv_Year, int country=Country_Default) -> DateTime + + + + + + + DateTime.Now() -> DateTime + + + DateTime.UNow() -> DateTime + + + DateTime.Today() -> DateTime + + + SetToCurrent() -> DateTime + + + SetTimeT(time_t timet) -> DateTime + + + + + + SetJDN(double jdn) -> DateTime + + + + + + SetHMS(int hour, int minute=0, int second=0, int millisec=0) -> DateTime + + + + + + + + + Set(int day, int month=Inv_Month, int year=Inv_Year, int hour=0, + int minute=0, int second=0, int millisec=0) -> DateTime + + + + + + + + + + + + ResetTime() -> DateTime + + + SetYear(int year) -> DateTime + + + + + + SetMonth(int month) -> DateTime + + + + + + SetDay(int day) -> DateTime + + + + + + SetHour(int hour) -> DateTime + + + + + + SetMinute(int minute) -> DateTime + + + + + + SetSecond(int second) -> DateTime + + + + + + SetMillisecond(int millisecond) -> DateTime + + + + + + SetToWeekDayInSameWeek(int weekday, int flags=Monday_First) -> DateTime + + + + + + + GetWeekDayInSameWeek(int weekday, int flags=Monday_First) -> DateTime + + + + + + + SetToNextWeekDay(int weekday) -> DateTime + + + + + + GetNextWeekDay(int weekday) -> DateTime + + + + + + SetToPrevWeekDay(int weekday) -> DateTime + + + + + + GetPrevWeekDay(int weekday) -> DateTime + + + + + + SetToWeekDay(int weekday, int n=1, int month=Inv_Month, int year=Inv_Year) -> bool + + + + + + + + + SetToLastWeekDay(int weekday, int month=Inv_Month, int year=Inv_Year) -> bool + + + + + + + + GetLastWeekDay(int weekday, int month=Inv_Month, int year=Inv_Year) -> DateTime + + + + + + + + SetToTheWeek(int numWeek, int weekday=Mon, int flags=Monday_First) -> bool + + + + + + + + GetWeek(int numWeek, int weekday=Mon, int flags=Monday_First) -> DateTime + + + + + + + + SetToLastMonthDay(int month=Inv_Month, int year=Inv_Year) -> DateTime + + + + + + + GetLastMonthDay(int month=Inv_Month, int year=Inv_Year) -> DateTime + + + + + + + SetToYearDay(int yday) -> DateTime + + + + + + GetYearDay(int yday) -> DateTime + + + + + + GetJulianDayNumber() -> double + + + GetJDN() -> double + + + GetModifiedJulianDayNumber() -> double + + + GetMJD() -> double + + + GetRataDie() -> double + + + ToTimezone(wxDateTime::TimeZone tz, bool noDST=False) -> DateTime + + + + + + + MakeTimezone(wxDateTime::TimeZone tz, bool noDST=False) -> DateTime + + + + + + + ToGMT(bool noDST=False) -> DateTime + + + + + + MakeGMT(bool noDST=False) -> DateTime + + + + + + IsDST(int country=Country_Default) -> int + + + + + + IsValid() -> bool + + + GetTicks() -> time_t + + + GetYear(wxDateTime::TimeZone tz=LOCAL_TZ) -> int + + + + + + GetMonth(wxDateTime::TimeZone tz=LOCAL_TZ) -> int + + + + + + GetDay(wxDateTime::TimeZone tz=LOCAL_TZ) -> int + + + + + + GetWeekDay(wxDateTime::TimeZone tz=LOCAL_TZ) -> int + + + + + + GetHour(wxDateTime::TimeZone tz=LOCAL_TZ) -> int + + + + + + GetMinute(wxDateTime::TimeZone tz=LOCAL_TZ) -> int + + + + + + GetSecond(wxDateTime::TimeZone tz=LOCAL_TZ) -> int + + + + + + GetMillisecond(wxDateTime::TimeZone tz=LOCAL_TZ) -> int + + + + + + GetDayOfYear(wxDateTime::TimeZone tz=LOCAL_TZ) -> int + + + + + + GetWeekOfYear(int flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int + + + + + + + GetWeekOfMonth(int flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int + + + + + + + IsWorkDay(int country=Country_Default) -> bool + + + + + + IsEqualTo(DateTime datetime) -> bool + + + + + + IsEarlierThan(DateTime datetime) -> bool + + + + + + IsLaterThan(DateTime datetime) -> bool + + + + + + IsStrictlyBetween(DateTime t1, DateTime t2) -> bool + + + + + + + IsBetween(DateTime t1, DateTime t2) -> bool + + + + + + + IsSameDate(DateTime dt) -> bool + + + + + + IsSameTime(DateTime dt) -> bool + + + + + + IsEqualUpTo(DateTime dt, TimeSpan ts) -> bool + + + + + + + AddTS(TimeSpan diff) -> DateTime + + + + + + AddDS(DateSpan diff) -> DateTime + + + + + + SubtractTS(TimeSpan diff) -> DateTime + + + + + + SubtractDS(DateSpan diff) -> DateTime + + + + + + Subtract(DateTime dt) -> TimeSpan + + + + + + + + + + + __iadd__(TimeSpan diff) -> DateTime +__iadd__(DateSpan diff) -> DateTime + + + + + + + + + + + __isub__(TimeSpan diff) -> DateTime +__isub__(DateSpan diff) -> DateTime + + + + + + + + + + + __add__(TimeSpan other) -> DateTime +__add__(DateSpan other) -> DateTime + + + + + + + + + + + + + + + + __sub__(DateTime other) -> TimeSpan +__sub__(TimeSpan other) -> DateTime +__sub__(DateSpan other) -> DateTime + + + + + + __lt__(DateTime other) -> bool + + + + + + __le__(DateTime other) -> bool + + + + + + __gt__(DateTime other) -> bool + + + + + + __ge__(DateTime other) -> bool + + + + + + __eq__(DateTime other) -> bool + + + + + + __ne__(DateTime other) -> bool + + + + + + ParseRfc822Date(String date) -> int + + + + + + ParseFormat(String date, String format=DateFormatStr, DateTime dateDef=wxDefaultDateTime) -> int + + + + + + + + ParseDateTime(String datetime) -> int + + + + + + ParseDate(String date) -> int + + + + + + ParseTime(String time) -> int + + + + + + Format(String format=DateFormatStr, wxDateTime::TimeZone tz=LOCAL_TZ) -> String + + + + + + + FormatDate() -> String + + + FormatTime() -> String + + + FormatISODate() -> String + + + FormatISOTime() -> String + + + + + __init__(long hours=0, long minutes=0, long seconds=0, long milliseconds=0) -> TimeSpan + + + + + + + + + __del__() + + + TimeSpan.Seconds(long sec) -> TimeSpan + + + + + + TimeSpan.Second() -> TimeSpan + + + TimeSpan.Minutes(long min) -> TimeSpan + + + + + + TimeSpan.Minute() -> TimeSpan + + + TimeSpan.Hours(long hours) -> TimeSpan + + + + + + TimeSpan.Hour() -> TimeSpan + + + TimeSpan.Days(long days) -> TimeSpan + + + + + + TimeSpan.Day() -> TimeSpan + + + TimeSpan.Weeks(long days) -> TimeSpan + + + + + + TimeSpan.Week() -> TimeSpan + + + Add(TimeSpan diff) -> TimeSpan + + + + + + Subtract(TimeSpan diff) -> TimeSpan + + + + + + Multiply(int n) -> TimeSpan + + + + + + Neg() -> TimeSpan + + + Abs() -> TimeSpan + + + __iadd__(TimeSpan diff) -> TimeSpan + + + + + + __isub__(TimeSpan diff) -> TimeSpan + + + + + + __imul__(int n) -> TimeSpan + + + + + + __neg__() -> TimeSpan + + + __add__(TimeSpan other) -> TimeSpan + + + + + + __sub__(TimeSpan other) -> TimeSpan + + + + + + __mul__(int n) -> TimeSpan + + + + + + __rmul__(int n) -> TimeSpan + + + + + + __lt__(TimeSpan other) -> bool + + + + + + __le__(TimeSpan other) -> bool + + + + + + __gt__(TimeSpan other) -> bool + + + + + + __ge__(TimeSpan other) -> bool + + + + + + __eq__(TimeSpan other) -> bool + + + + + + __ne__(TimeSpan other) -> bool + + + + + + IsNull() -> bool + + + IsPositive() -> bool + + + IsNegative() -> bool + + + IsEqualTo(TimeSpan ts) -> bool + + + + + + IsLongerThan(TimeSpan ts) -> bool + + + + + + IsShorterThan(TimeSpan t) -> bool + + + + + + GetWeeks() -> int + + + GetDays() -> int + + + GetHours() -> int + + + GetMinutes() -> int + + + GetSeconds() -> wxLongLong + + + GetMilliseconds() -> wxLongLong + + + Format(String format=TimeSpanFormatStr) -> String + + + + + + + + __init__(int years=0, int months=0, int weeks=0, int days=0) -> DateSpan + + + + + + + + + __del__() + + + DateSpan.Days(int days) -> DateSpan + + + + + + DateSpan.Day() -> DateSpan + + + DateSpan.Weeks(int weeks) -> DateSpan + + + + + + DateSpan.Week() -> DateSpan + + + DateSpan.Months(int mon) -> DateSpan + + + + + + DateSpan.Month() -> DateSpan + + + DateSpan.Years(int years) -> DateSpan + + + + + + DateSpan.Year() -> DateSpan + + + SetYears(int n) -> DateSpan + + + + + + SetMonths(int n) -> DateSpan + + + + + + SetWeeks(int n) -> DateSpan + + + + + + SetDays(int n) -> DateSpan + + + + + + GetYears() -> int + + + GetMonths() -> int + + + GetWeeks() -> int + + + GetDays() -> int + + + GetTotalDays() -> int + + + Add(DateSpan other) -> DateSpan + + + + + + Subtract(DateSpan other) -> DateSpan + + + + + + Neg() -> DateSpan + + + Multiply(int factor) -> DateSpan + + + + + + __iadd__(DateSpan other) -> DateSpan + + + + + + __isub__(DateSpan other) -> DateSpan + + + + + + __neg__() -> DateSpan + + + __imul__(int factor) -> DateSpan + + + + + + __add__(DateSpan other) -> DateSpan + + + + + + __sub__(DateSpan other) -> DateSpan + + + + + + __mul__(int n) -> DateSpan + + + + + + __rmul__(int n) -> DateSpan + + + + + + __eq__(DateSpan other) -> bool + + + + + + __ne__(DateSpan other) -> bool + + + + + + + GetLocalTime() -> long + + + GetUTCTime() -> long + + + GetCurrentTime() -> long + + + GetLocalTimeMillis() -> wxLongLong + + +#--------------------------------------------------------------------------- + + + + __init__(int type) -> DataFormat + + + + + + CustomDataFormat(String format) -> DataFormat + + + + + + __del__() + + + + + + + + + + + + + __eq__(int format) -> bool +__eq__(DataFormat format) -> bool + + + + + + __ne__(int format) -> bool +__ne__(DataFormat format) -> bool + + + + + + SetType(int format) + + + + + + GetType() -> int + + + GetId() -> String + + + SetId(String format) + + + + + + + + __del__() + + + GetPreferredFormat(int dir=Get) -> DataFormat + + + + + + GetFormatCount(int dir=Get) -> size_t + + + + + + IsSupported(DataFormat format, int dir=Get) -> bool + + + + + + + GetDataSize(DataFormat format) -> size_t + + + + + + GetAllFormats(DataFormat formats, int dir=Get) + + + + + + + GetDataHere(DataFormat format, void buf) -> bool + + + + + + + SetData(DataFormat format, size_t len, void buf) -> bool + + + + + + + + + + + __init__(DataFormat format=FormatInvalid) -> DataObjectSimple + + + + + + GetFormat() -> DataFormat + + + SetFormat(DataFormat format) + + + + + + + + + __init__(DataFormat format=FormatInvalid) -> PyDataObjectSimple + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + + + + __init__() -> DataObjectComposite + + + Add(DataObjectSimple dataObject, int preferred=False) + + + + + + + + + + __init__(String text=EmptyString) -> TextDataObject + + + + + + GetTextLength() -> size_t + + + GetText() -> String + + + SetText(String text) + + + + + + + + + __init__(String text=EmptyString) -> PyTextDataObject + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + + + + __init__(Bitmap bitmap=wxNullBitmap) -> BitmapDataObject + + + + + + GetBitmap() -> Bitmap + + + SetBitmap(Bitmap bitmap) + + + + + + + + + __init__(Bitmap bitmap=wxNullBitmap) -> PyBitmapDataObject + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + + + + __init__() -> FileDataObject + + + GetFilenames() -> wxArrayString + + + + + + __init__(DataFormat format=FormatInvalid) -> CustomDataObject + + + + + + TakeData(PyObject data) + + + + + + SetData(PyObject data) -> bool + + + + + + GetSize() -> size_t + + + GetData() -> PyObject + + + + + + __init__() -> URLDataObject + + + GetURL() -> String + + + SetURL(String url) + + + + + + + + + __init__() -> MetafileDataObject + + + +#--------------------------------------------------------------------------- + + + IsDragResultOk(int res) -> bool + + + + + + + __init__(Window win=None, Icon copy=wxNullIcon, Icon move=wxNullIcon, + Icon none=wxNullIcon) -> DropSource + + + + + + + + + __del__() + + + _setCallbackInfo(PyObject self, PyObject _class, int incref) + + + + + + + + SetData(DataObject data) + + + + + + GetDataObject() -> DataObject + + + SetCursor(int res, Cursor cursor) + + + + + + + DoDragDrop(int flags=Drag_CopyOnly) -> int + + + + + + base_GiveFeedback(int effect) -> bool + + + + + + + + PyDropTarget(DataObject dataObject=None) -> DropTarget + + + + + + __del__() + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + GetDataObject() -> DataObject + + + SetDataObject(DataObject dataObject) + + + + + + base_OnEnter(int x, int y, int def) -> int + + + + + + + + base_OnDragOver(int x, int y, int def) -> int + + + + + + + + base_OnLeave() + + + base_OnDrop(int x, int y) -> bool + + + + + + + GetData() -> bool + + + PyDropTarget = DropTarget + + + + __init__() -> TextDropTarget + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_OnEnter(int x, int y, int def) -> int + + + + + + + + base_OnDragOver(int x, int y, int def) -> int + + + + + + + + base_OnLeave() + + + base_OnDrop(int x, int y) -> bool + + + + + + + base_OnData(int x, int y, int def) -> int + + + + + + + + + + + __init__() -> FileDropTarget + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_OnEnter(int x, int y, int def) -> int + + + + + + + + base_OnDragOver(int x, int y, int def) -> int + + + + + + + + base_OnLeave() + + + base_OnDrop(int x, int y) -> bool + + + + + + + base_OnData(int x, int y, int def) -> int + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> Clipboard + + + __del__() + + + Open() -> bool + + + Close() + + + IsOpened() -> bool + + + AddData(DataObject data) -> bool + + + + + + SetData(DataObject data) -> bool + + + + + + IsSupported(DataFormat format) -> bool + + + + + + GetData(DataObject data) -> bool + + + + + + Clear() + + + Flush() -> bool + + + UsePrimarySelection(bool primary=False) + + + + + + + + __init__(Clipboard clipboard=None) -> ClipboardLocker + + + + + + __del__() + + + __nonzero__() -> bool + + + + + wx = core + + + __init__(Colour colText, Colour colBack=wxNullColour, Colour colBorder=wxNullColour, + Font font=wxNullFont, + int border=CAL_BORDER_NONE) -> CalendarDateAttr + + + + + + + + + + CalendarDateAttrBorder(int border, Colour colBorder=wxNullColour) -> CalendarDateAttr + + + + + + + SetTextColour(Colour colText) + + + + + + SetBackgroundColour(Colour colBack) + + + + + + SetBorderColour(Colour col) + + + + + + SetFont(Font font) + + + + + + SetBorder(int border) + + + + + + SetHoliday(bool holiday) + + + + + + HasTextColour() -> bool + + + HasBackgroundColour() -> bool + + + HasBorderColour() -> bool + + + HasFont() -> bool + + + HasBorder() -> bool + + + IsHoliday() -> bool + + + GetTextColour() -> Colour + + + GetBackgroundColour() -> Colour + + + GetBorderColour() -> Colour + + + GetFont() -> Font + + + GetBorder() -> int + + + + + + __init__(CalendarCtrl cal, wxEventType type) -> CalendarEvent + + + + + + + GetDate() -> DateTime + + + SetDate(DateTime date) + + + + + + SetWeekDay(int wd) + + + + + + GetWeekDay() -> int + + + +EVT_CALENDAR = wx.PyEventBinder( wxEVT_CALENDAR_DOUBLECLICKED, 1) +EVT_CALENDAR_SEL_CHANGED = wx.PyEventBinder( wxEVT_CALENDAR_SEL_CHANGED, 1) +EVT_CALENDAR_DAY = wx.PyEventBinder( wxEVT_CALENDAR_DAY_CHANGED, 1) +EVT_CALENDAR_MONTH = wx.PyEventBinder( wxEVT_CALENDAR_MONTH_CHANGED, 1) +EVT_CALENDAR_YEAR = wx.PyEventBinder( wxEVT_CALENDAR_YEAR_CHANGED, 1) +EVT_CALENDAR_WEEKDAY_CLICKED = wx.PyEventBinder( wxEVT_CALENDAR_WEEKDAY_CLICKED, 1) + + + + + __init__(Window parent, int id, DateTime date=wxDefaultDateTime, + Point pos=DefaultPosition, Size size=DefaultSize, + long style=wxCAL_SHOW_HOLIDAYS|wxWANTS_CHARS, + String name=CalendarNameStr) -> CalendarCtrl + + + + + + + + + + + + PreCalendarCtrl() -> CalendarCtrl + + + Create(Window parent, int id, DateTime date=wxDefaultDateTime, + Point pos=DefaultPosition, Size size=DefaultSize, + long style=wxCAL_SHOW_HOLIDAYS|wxWANTS_CHARS, + String name=CalendarNameStr) -> bool + + + + + + + + + + + + SetDate(DateTime date) + + + + + + GetDate() -> DateTime + + + SetLowerDateLimit(DateTime date=wxDefaultDateTime) -> bool + + + + + + GetLowerDateLimit() -> DateTime + + + SetUpperDateLimit(DateTime date=wxDefaultDateTime) -> bool + + + + + + GetUpperDateLimit() -> DateTime + + + SetDateRange(DateTime lowerdate=wxDefaultDateTime, DateTime upperdate=wxDefaultDateTime) -> bool + + + + + + + EnableYearChange(bool enable=True) + + + + + + EnableMonthChange(bool enable=True) + + + + + + EnableHolidayDisplay(bool display=True) + + + + + + SetHeaderColours(Colour colFg, Colour colBg) + + + + + + + GetHeaderColourFg() -> Colour + + + GetHeaderColourBg() -> Colour + + + SetHighlightColours(Colour colFg, Colour colBg) + + + + + + + GetHighlightColourFg() -> Colour + + + GetHighlightColourBg() -> Colour + + + SetHolidayColours(Colour colFg, Colour colBg) + + + + + + + GetHolidayColourFg() -> Colour + + + GetHolidayColourBg() -> Colour + + + GetAttr(size_t day) -> CalendarDateAttr + + + + + + SetAttr(size_t day, CalendarDateAttr attr) + + + + + + + SetHoliday(size_t day) + + + + + + ResetAttr(size_t day) + + + + + + HitTest(Point pos, DateTime date=None, int wd=None) -> int + + + + + + + + Enable(bool enable=True) -> bool + + + + + + Show(bool show=True) -> bool + + + + + + GetMonthControl() -> Control + + + GetYearControl() -> Control + + + + + wx = core + + + _setOORInfo(PyObject _self) + + + + + + SetParameters(String params) + + + + + + IncRef() + + + DecRef() + + + Draw(Grid grid, GridCellAttr attr, DC dc, Rect rect, int row, + int col, bool isSelected) + + + + + + + + + + + + GetBestSize(Grid grid, GridCellAttr attr, DC dc, int row, int col) -> Size + + + + + + + + + + Clone() -> GridCellRenderer + + + + + + __init__() -> PyGridCellRenderer + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_SetParameters(String params) + + + + + + + + + __init__() -> GridCellStringRenderer + + + + + + __init__() -> GridCellNumberRenderer + + + + + + __init__(int width=-1, int precision=-1) -> GridCellFloatRenderer + + + + + + + GetWidth() -> int + + + SetWidth(int width) + + + + + + GetPrecision() -> int + + + SetPrecision(int precision) + + + + + + + + + __init__() -> GridCellBoolRenderer + + + + + + __init__(String outformat=DateTimeFormatStr, String informat=DateTimeFormatStr) -> GridCellDateTimeRenderer + + + + + + + + + + __init__(String choices=EmptyString) -> GridCellEnumRenderer + + + + + + + + + __init__() -> GridCellAutoWrapStringRenderer + + + + + _setOORInfo(PyObject _self) + + + + + + IsCreated() -> bool + + + GetControl() -> Control + + + SetControl(Control control) + + + + + + GetCellAttr() -> GridCellAttr + + + SetCellAttr(GridCellAttr attr) + + + + + + SetParameters(String params) + + + + + + IncRef() + + + DecRef() + + + Create(Window parent, int id, EvtHandler evtHandler) + + + + + + + + BeginEdit(int row, int col, Grid grid) + + + + + + + + EndEdit(int row, int col, Grid grid) -> bool + + + + + + + + Reset() + + + Clone() -> GridCellEditor + + + SetSize(Rect rect) + + + + + + Show(bool show, GridCellAttr attr=None) + + + + + + + PaintBackground(Rect rectCell, GridCellAttr attr) + + + + + + + IsAcceptedKey(KeyEvent event) -> bool + + + + + + StartingKey(KeyEvent event) + + + + + + StartingClick() + + + HandleReturn(KeyEvent event) + + + + + + Destroy() + + + + + + __init__() -> PyGridCellEditor + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_SetSize(Rect rect) + + + + + + base_Show(bool show, GridCellAttr attr=None) + + + + + + + base_PaintBackground(Rect rectCell, GridCellAttr attr) + + + + + + + base_IsAcceptedKey(KeyEvent event) -> bool + + + + + + base_StartingKey(KeyEvent event) + + + + + + base_StartingClick() + + + base_HandleReturn(KeyEvent event) + + + + + + base_Destroy() + + + base_SetParameters(String params) + + + + + + + + + __init__() -> GridCellTextEditor + + + GetValue() -> String + + + + + + __init__(int min=-1, int max=-1) -> GridCellNumberEditor + + + + + + + GetValue() -> String + + + + + + __init__() -> GridCellFloatEditor + + + GetValue() -> String + + + + + + __init__() -> GridCellBoolEditor + + + GetValue() -> String + + + + + + __init__(int choices=0, String choices_array=None, bool allowOthers=False) -> GridCellChoiceEditor + + + + + + + + GetValue() -> String + + + + + + __init__(String choices=EmptyString) -> GridCellEnumEditor + + + + + + GetValue() -> String + + + + + + __init__() -> GridCellAutoWrapStringEditor + + + GetValue() -> String + + + + + __init__(GridCellAttr attrDefault=None) -> GridCellAttr + + + + + + _setOORInfo(PyObject _self) + + + + + + Clone() -> GridCellAttr + + + MergeWith(GridCellAttr mergefrom) + + + + + + IncRef() + + + DecRef() + + + SetTextColour(Colour colText) + + + + + + SetBackgroundColour(Colour colBack) + + + + + + SetFont(Font font) + + + + + + SetAlignment(int hAlign, int vAlign) + + + + + + + SetSize(int num_rows, int num_cols) + + + + + + + SetOverflow(bool allow=True) + + + + + + SetReadOnly(bool isReadOnly=True) + + + + + + SetRenderer(GridCellRenderer renderer) + + + + + + SetEditor(GridCellEditor editor) + + + + + + SetKind(int kind) + + + + + + HasTextColour() -> bool + + + HasBackgroundColour() -> bool + + + HasFont() -> bool + + + HasAlignment() -> bool + + + HasRenderer() -> bool + + + HasEditor() -> bool + + + HasReadWriteMode() -> bool + + + HasOverflowMode() -> bool + + + GetTextColour() -> Colour + + + GetBackgroundColour() -> Colour + + + GetFont() -> Font + + + GetAlignment() -> (hAlign, vAlign) + + + + + + + GetSize() -> (num_rows, num_cols) + + + + + + + GetOverflow() -> bool + + + GetRenderer(Grid grid, int row, int col) -> GridCellRenderer + + + + + + + + GetEditor(Grid grid, int row, int col) -> GridCellEditor + + + + + + + + IsReadOnly() -> bool + + + SetDefAttr(GridCellAttr defAttr) + + + + + + + + __init__() -> GridCellAttrProvider + + + _setOORInfo(PyObject _self) + + + + + + GetAttr(int row, int col, int kind) -> GridCellAttr + + + + + + + + SetAttr(GridCellAttr attr, int row, int col) + + + + + + + + SetRowAttr(GridCellAttr attr, int row) + + + + + + + SetColAttr(GridCellAttr attr, int col) + + + + + + + UpdateAttrRows(size_t pos, int numRows) + + + + + + + UpdateAttrCols(size_t pos, int numCols) + + + + + + + + + + __init__() -> PyGridCellAttrProvider + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_GetAttr(int row, int col, int kind) -> GridCellAttr + + + + + + + + base_SetAttr(GridCellAttr attr, int row, int col) + + + + + + + + base_SetRowAttr(GridCellAttr attr, int row) + + + + + + + base_SetColAttr(GridCellAttr attr, int col) + + + + + + + + + + _setOORInfo(PyObject _self) + + + + + + SetAttrProvider(GridCellAttrProvider attrProvider) + + + + + + GetAttrProvider() -> GridCellAttrProvider + + + SetView(Grid grid) + + + + + + GetView() -> Grid + + + GetNumberRows() -> int + + + GetNumberCols() -> int + + + IsEmptyCell(int row, int col) -> bool + + + + + + + GetValue(int row, int col) -> String + + + + + + + SetValue(int row, int col, String value) + + + + + + + + GetTypeName(int row, int col) -> String + + + + + + + CanGetValueAs(int row, int col, String typeName) -> bool + + + + + + + + CanSetValueAs(int row, int col, String typeName) -> bool + + + + + + + + GetValueAsLong(int row, int col) -> long + + + + + + + GetValueAsDouble(int row, int col) -> double + + + + + + + GetValueAsBool(int row, int col) -> bool + + + + + + + SetValueAsLong(int row, int col, long value) + + + + + + + + SetValueAsDouble(int row, int col, double value) + + + + + + + + SetValueAsBool(int row, int col, bool value) + + + + + + + + Clear() + + + InsertRows(size_t pos=0, size_t numRows=1) -> bool + + + + + + + AppendRows(size_t numRows=1) -> bool + + + + + + DeleteRows(size_t pos=0, size_t numRows=1) -> bool + + + + + + + InsertCols(size_t pos=0, size_t numCols=1) -> bool + + + + + + + AppendCols(size_t numCols=1) -> bool + + + + + + DeleteCols(size_t pos=0, size_t numCols=1) -> bool + + + + + + + GetRowLabelValue(int row) -> String + + + + + + GetColLabelValue(int col) -> String + + + + + + SetRowLabelValue(int row, String value) + + + + + + + SetColLabelValue(int col, String value) + + + + + + + CanHaveAttributes() -> bool + + + GetAttr(int row, int col, int kind) -> GridCellAttr + + + + + + + + SetAttr(GridCellAttr attr, int row, int col) + + + + + + + + SetRowAttr(GridCellAttr attr, int row) + + + + + + + SetColAttr(GridCellAttr attr, int col) + + + + + + + + + + __init__() -> PyGridTableBase + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + Destroy() + Deletes the C++ object this Python object is a proxy for. + + + base_GetTypeName(int row, int col) -> String + + + + + + + base_CanGetValueAs(int row, int col, String typeName) -> bool + + + + + + + + base_CanSetValueAs(int row, int col, String typeName) -> bool + + + + + + + + base_Clear() + + + base_InsertRows(size_t pos=0, size_t numRows=1) -> bool + + + + + + + base_AppendRows(size_t numRows=1) -> bool + + + + + + base_DeleteRows(size_t pos=0, size_t numRows=1) -> bool + + + + + + + base_InsertCols(size_t pos=0, size_t numCols=1) -> bool + + + + + + + base_AppendCols(size_t numCols=1) -> bool + + + + + + base_DeleteCols(size_t pos=0, size_t numCols=1) -> bool + + + + + + + base_GetRowLabelValue(int row) -> String + + + + + + base_GetColLabelValue(int col) -> String + + + + + + base_SetRowLabelValue(int row, String value) + + + + + + + base_SetColLabelValue(int col, String value) + + + + + + + base_CanHaveAttributes() -> bool + + + base_GetAttr(int row, int col, int kind) -> GridCellAttr + + + + + + + + base_SetAttr(GridCellAttr attr, int row, int col) + + + + + + + + base_SetRowAttr(GridCellAttr attr, int row) + + + + + + + base_SetColAttr(GridCellAttr attr, int col) + + + + + + + + + + __init__(int numRows=0, int numCols=0) -> GridStringTable + + + + + + + + + __init__(GridTableBase table, int id, int comInt1=-1, int comInt2=-1) -> GridTableMessage + + + + + + + + + __del__() + + + SetTableObject(GridTableBase table) + + + + + + GetTableObject() -> GridTableBase + + + SetId(int id) + + + + + + GetId() -> int + + + SetCommandInt(int comInt1) + + + + + + GetCommandInt() -> int + + + SetCommandInt2(int comInt2) + + + + + + GetCommandInt2() -> int + + + + + __init__(int r=-1, int c=-1) -> GridCellCoords + + + + + + + __del__() + + + GetRow() -> int + + + SetRow(int n) + + + + + + GetCol() -> int + + + SetCol(int n) + + + + + + Set(int row, int col) + + + + + + + __eq__(GridCellCoords other) -> bool + + + + + + __ne__(GridCellCoords other) -> bool + + + + + + asTuple() -> PyObject + + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=WANTS_CHARS, + String name=PanelNameStr) -> Grid + + + + + + + + + + + CreateGrid(int numRows, int numCols, WXGRIDSELECTIONMODES selmode=wxGridSelectCells) -> bool + + + + + + + + SetSelectionMode(WXGRIDSELECTIONMODES selmode) + + + + + + GetSelectionMode() -> WXGRIDSELECTIONMODES + + + GetNumberRows() -> int + + + GetNumberCols() -> int + + + ProcessTableMessage(GridTableMessage ??) -> bool + + + + + + GetTable() -> GridTableBase + + + SetTable(GridTableBase table, bool takeOwnership=False, WXGRIDSELECTIONMODES selmode=wxGridSelectCells) -> bool + + + + + + + + ClearGrid() + + + InsertRows(int pos=0, int numRows=1, bool updateLabels=True) -> bool + + + + + + + + AppendRows(int numRows=1, bool updateLabels=True) -> bool + + + + + + + DeleteRows(int pos=0, int numRows=1, bool updateLabels=True) -> bool + + + + + + + + InsertCols(int pos=0, int numCols=1, bool updateLabels=True) -> bool + + + + + + + + AppendCols(int numCols=1, bool updateLabels=True) -> bool + + + + + + + DeleteCols(int pos=0, int numCols=1, bool updateLabels=True) -> bool + + + + + + + + DrawCellHighlight(DC dc, GridCellAttr attr) + + + + + + + DrawTextRectangle(DC dc, String ??, Rect ??, int horizontalAlignment=LEFT, + int verticalAlignment=TOP, int textOrientation=HORIZONTAL) + + + + + + + + + + + GetTextBoxSize(DC dc, list lines) -> (width, height) + + + + + + + + + BeginBatch() + + + EndBatch() + + + GetBatchCount() -> int + + + ForceRefresh() + + + Refresh(bool eraseb=True, Rect rect=None) + + + + + + + IsEditable() -> bool + + + EnableEditing(bool edit) + + + + + + EnableCellEditControl(bool enable=True) + + + + + + DisableCellEditControl() + + + CanEnableCellControl() -> bool + + + IsCellEditControlEnabled() -> bool + + + IsCellEditControlShown() -> bool + + + IsCurrentCellReadOnly() -> bool + + + ShowCellEditControl() + + + HideCellEditControl() + + + SaveEditControlValue() + + + XYToCell(int x, int y) -> GridCellCoords + + + + + + + YToRow(int y) -> int + + + + + + XToCol(int x) -> int + + + + + + YToEdgeOfRow(int y) -> int + + + + + + XToEdgeOfCol(int x) -> int + + + + + + CellToRect(int row, int col) -> Rect + + + + + + + GetGridCursorRow() -> int + + + GetGridCursorCol() -> int + + + IsVisible(int row, int col, bool wholeCellVisible=True) -> bool + + + + + + + + MakeCellVisible(int row, int col) + + + + + + + SetGridCursor(int row, int col) + + + + + + + MoveCursorUp(bool expandSelection) -> bool + + + + + + MoveCursorDown(bool expandSelection) -> bool + + + + + + MoveCursorLeft(bool expandSelection) -> bool + + + + + + MoveCursorRight(bool expandSelection) -> bool + + + + + + MovePageDown() -> bool + + + MovePageUp() -> bool + + + MoveCursorUpBlock(bool expandSelection) -> bool + + + + + + MoveCursorDownBlock(bool expandSelection) -> bool + + + + + + MoveCursorLeftBlock(bool expandSelection) -> bool + + + + + + MoveCursorRightBlock(bool expandSelection) -> bool + + + + + + GetDefaultRowLabelSize() -> int + + + GetRowLabelSize() -> int + + + GetDefaultColLabelSize() -> int + + + GetColLabelSize() -> int + + + GetLabelBackgroundColour() -> Colour + + + GetLabelTextColour() -> Colour + + + GetLabelFont() -> Font + + + GetRowLabelAlignment() -> (horiz, vert) + + + + + + + GetColLabelAlignment() -> (horiz, vert) + + + + + + + GetColLabelTextOrientation() -> int + + + GetRowLabelValue(int row) -> String + + + + + + GetColLabelValue(int col) -> String + + + + + + GetGridLineColour() -> Colour + + + GetCellHighlightColour() -> Colour + + + GetCellHighlightPenWidth() -> int + + + GetCellHighlightROPenWidth() -> int + + + SetRowLabelSize(int width) + + + + + + SetColLabelSize(int height) + + + + + + SetLabelBackgroundColour(Colour ??) + + + + + + SetLabelTextColour(Colour ??) + + + + + + SetLabelFont(Font ??) + + + + + + SetRowLabelAlignment(int horiz, int vert) + + + + + + + SetColLabelAlignment(int horiz, int vert) + + + + + + + SetColLabelTextOrientation(int textOrientation) + + + + + + SetRowLabelValue(int row, String ??) + + + + + + + SetColLabelValue(int col, String ??) + + + + + + + SetGridLineColour(Colour ??) + + + + + + SetCellHighlightColour(Colour ??) + + + + + + SetCellHighlightPenWidth(int width) + + + + + + SetCellHighlightROPenWidth(int width) + + + + + + EnableDragRowSize(bool enable=True) + + + + + + DisableDragRowSize() + + + CanDragRowSize() -> bool + + + EnableDragColSize(bool enable=True) + + + + + + DisableDragColSize() + + + CanDragColSize() -> bool + + + EnableDragGridSize(bool enable=True) + + + + + + DisableDragGridSize() + + + CanDragGridSize() -> bool + + + SetAttr(int row, int col, GridCellAttr attr) + + + + + + + + SetRowAttr(int row, GridCellAttr attr) + + + + + + + SetColAttr(int col, GridCellAttr attr) + + + + + + + SetColFormatBool(int col) + + + + + + SetColFormatNumber(int col) + + + + + + SetColFormatFloat(int col, int width=-1, int precision=-1) + + + + + + + + SetColFormatCustom(int col, String typeName) + + + + + + + EnableGridLines(bool enable=True) + + + + + + GridLinesEnabled() -> bool + + + GetDefaultRowSize() -> int + + + GetRowSize(int row) -> int + + + + + + GetDefaultColSize() -> int + + + GetColSize(int col) -> int + + + + + + GetDefaultCellBackgroundColour() -> Colour + + + GetCellBackgroundColour(int row, int col) -> Colour + + + + + + + GetDefaultCellTextColour() -> Colour + + + GetCellTextColour(int row, int col) -> Colour + + + + + + + GetDefaultCellFont() -> Font + + + GetCellFont(int row, int col) -> Font + + + + + + + GetDefaultCellAlignment() -> (horiz, vert) + + + + + + + GetCellAlignment() -> (horiz, vert) + + + + + + + + + GetDefaultCellOverflow() -> bool + + + GetCellOverflow(int row, int col) -> bool + + + + + + + GetCellSize(int row, int col) -> (num_rows, num_cols) + + + + + + + + + SetDefaultRowSize(int height, bool resizeExistingRows=False) + + + + + + + SetRowSize(int row, int height) + + + + + + + SetDefaultColSize(int width, bool resizeExistingCols=False) + + + + + + + SetColSize(int col, int width) + + + + + + + AutoSizeColumn(int col, bool setAsMin=True) + + + + + + + AutoSizeRow(int row, bool setAsMin=True) + + + + + + + AutoSizeColumns(bool setAsMin=True) + + + + + + AutoSizeRows(bool setAsMin=True) + + + + + + AutoSize() + + + AutoSizeRowLabelSize(int row) + + + + + + AutoSizeColLabelSize(int col) + + + + + + SetColMinimalWidth(int col, int width) + + + + + + + SetRowMinimalHeight(int row, int width) + + + + + + + SetColMinimalAcceptableWidth(int width) + + + + + + SetRowMinimalAcceptableHeight(int width) + + + + + + GetColMinimalAcceptableWidth() -> int + + + GetRowMinimalAcceptableHeight() -> int + + + SetDefaultCellBackgroundColour(Colour ??) + + + + + + SetCellBackgroundColour(int row, int col, Colour ??) + + + + + + + + SetDefaultCellTextColour(Colour ??) + + + + + + SetCellTextColour(int row, int col, Colour ??) + + + + + + + + SetDefaultCellFont(Font ??) + + + + + + SetCellFont(int row, int col, Font ??) + + + + + + + + SetDefaultCellAlignment(int horiz, int vert) + + + + + + + SetCellAlignment(int row, int col, int horiz, int vert) + + + + + + + + + SetDefaultCellOverflow(bool allow) + + + + + + SetCellOverflow(int row, int col, bool allow) + + + + + + + + SetCellSize(int row, int col, int num_rows, int num_cols) + + + + + + + + + SetDefaultRenderer(GridCellRenderer renderer) + + + + + + SetCellRenderer(int row, int col, GridCellRenderer renderer) + + + + + + + + GetDefaultRenderer() -> GridCellRenderer + + + GetCellRenderer(int row, int col) -> GridCellRenderer + + + + + + + SetDefaultEditor(GridCellEditor editor) + + + + + + SetCellEditor(int row, int col, GridCellEditor editor) + + + + + + + + GetDefaultEditor() -> GridCellEditor + + + GetCellEditor(int row, int col) -> GridCellEditor + + + + + + + GetCellValue(int row, int col) -> String + + + + + + + SetCellValue(int row, int col, String s) + + + + + + + + IsReadOnly(int row, int col) -> bool + + + + + + + SetReadOnly(int row, int col, bool isReadOnly=True) + + + + + + + + SelectRow(int row, bool addToSelected=False) + + + + + + + SelectCol(int col, bool addToSelected=False) + + + + + + + SelectBlock(int topRow, int leftCol, int bottomRow, int rightCol, + bool addToSelected=False) + + + + + + + + + + SelectAll() + + + IsSelection() -> bool + + + ClearSelection() + + + IsInSelection(int row, int col) -> bool + + + + + + + GetSelectedCells() -> wxGridCellCoordsArray + + + GetSelectionBlockTopLeft() -> wxGridCellCoordsArray + + + GetSelectionBlockBottomRight() -> wxGridCellCoordsArray + + + GetSelectedRows() -> wxArrayInt + + + GetSelectedCols() -> wxArrayInt + + + DeselectRow(int row) + + + + + + DeselectCol(int col) + + + + + + DeselectCell(int row, int col) + + + + + + + BlockToDeviceRect(GridCellCoords topLeft, GridCellCoords bottomRight) -> Rect + + + + + + + GetSelectionBackground() -> Colour + + + GetSelectionForeground() -> Colour + + + SetSelectionBackground(Colour c) + + + + + + SetSelectionForeground(Colour c) + + + + + + RegisterDataType(String typeName, GridCellRenderer renderer, GridCellEditor editor) + + + + + + + + GetDefaultEditorForCell(int row, int col) -> GridCellEditor + + + + + + + GetDefaultRendererForCell(int row, int col) -> GridCellRenderer + + + + + + + GetDefaultEditorForType(String typeName) -> GridCellEditor + + + + + + GetDefaultRendererForType(String typeName) -> GridCellRenderer + + + + + + SetMargins(int extraWidth, int extraHeight) + + + + + + + GetGridWindow() -> Window + + + GetGridRowLabelWindow() -> Window + + + GetGridColLabelWindow() -> Window + + + GetGridCornerLabelWindow() -> Window + + + + + + __init__(int id, wxEventType type, Grid obj, int row=-1, int col=-1, + int x=-1, int y=-1, bool sel=True, bool control=False, + bool shift=False, bool alt=False, + bool meta=False) -> GridEvent + + + + + + + + + + + + + + + + + GetRow() -> int + + + GetCol() -> int + + + GetPosition() -> Point + + + Selecting() -> bool + + + ControlDown() -> bool + + + MetaDown() -> bool + + + ShiftDown() -> bool + + + AltDown() -> bool + + + + + + __init__(int id, wxEventType type, Grid obj, int rowOrCol=-1, + int x=-1, int y=-1, bool control=False, bool shift=False, + bool alt=False, bool meta=False) -> GridSizeEvent + + + + + + + + + + + + + + + GetRowOrCol() -> int + + + GetPosition() -> Point + + + ControlDown() -> bool + + + MetaDown() -> bool + + + ShiftDown() -> bool + + + AltDown() -> bool + + + + + + __init__(int id, wxEventType type, Grid obj, GridCellCoords topLeft, + GridCellCoords bottomRight, bool sel=True, + bool control=False, bool shift=False, + bool alt=False, bool meta=False) -> GridRangeSelectEvent + + + + + + + + + + + + + + + GetTopLeftCoords() -> GridCellCoords + + + GetBottomRightCoords() -> GridCellCoords + + + GetTopRow() -> int + + + GetBottomRow() -> int + + + GetLeftCol() -> int + + + GetRightCol() -> int + + + Selecting() -> bool + + + ControlDown() -> bool + + + MetaDown() -> bool + + + ShiftDown() -> bool + + + AltDown() -> bool + + + + + + __init__(int id, wxEventType type, Object obj, int row, int col, + Control ctrl) -> GridEditorCreatedEvent + + + + + + + + + + + GetRow() -> int + + + GetCol() -> int + + + GetControl() -> Control + + + SetRow(int row) + + + + + + SetCol(int col) + + + + + + SetControl(Control ctrl) + + + + + + +EVT_GRID_CELL_LEFT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_CLICK ) +EVT_GRID_CELL_RIGHT_CLICK = wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_CLICK ) +EVT_GRID_CELL_LEFT_DCLICK = wx.PyEventBinder( wxEVT_GRID_CELL_LEFT_DCLICK ) +EVT_GRID_CELL_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_GRID_CELL_RIGHT_DCLICK ) +EVT_GRID_LABEL_LEFT_CLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_CLICK ) +EVT_GRID_LABEL_RIGHT_CLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_CLICK ) +EVT_GRID_LABEL_LEFT_DCLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_LEFT_DCLICK ) +EVT_GRID_LABEL_RIGHT_DCLICK = wx.PyEventBinder( wxEVT_GRID_LABEL_RIGHT_DCLICK ) +EVT_GRID_ROW_SIZE = wx.PyEventBinder( wxEVT_GRID_ROW_SIZE ) +EVT_GRID_COL_SIZE = wx.PyEventBinder( wxEVT_GRID_COL_SIZE ) +EVT_GRID_RANGE_SELECT = wx.PyEventBinder( wxEVT_GRID_RANGE_SELECT ) +EVT_GRID_CELL_CHANGE = wx.PyEventBinder( wxEVT_GRID_CELL_CHANGE ) +EVT_GRID_SELECT_CELL = wx.PyEventBinder( wxEVT_GRID_SELECT_CELL ) +EVT_GRID_EDITOR_SHOWN = wx.PyEventBinder( wxEVT_GRID_EDITOR_SHOWN ) +EVT_GRID_EDITOR_HIDDEN = wx.PyEventBinder( wxEVT_GRID_EDITOR_HIDDEN ) +EVT_GRID_EDITOR_CREATED = wx.PyEventBinder( wxEVT_GRID_EDITOR_CREATED ) + + + + wx = core + +#--------------------------------------------------------------------------- + + + + + __init__(String href, String target=EmptyString) -> HtmlLinkInfo + + + + + + + GetHref() -> String + + + GetTarget() -> String + + + GetEvent() -> MouseEvent + + + GetHtmlCell() -> HtmlCell + + + SetEvent(MouseEvent e) + + + + + + SetHtmlCell(HtmlCell e) + + + + + + + + + GetName() -> String + + + HasParam(String par) -> bool + + + + + + GetParam(String par, int with_commas=False) -> String + + + + + + + GetAllParams() -> String + + + HasEnding() -> bool + + + GetBeginPos() -> int + + + GetEndPos1() -> int + + + GetEndPos2() -> int + + + + + + SetFS(FileSystem fs) + + + + + + GetFS() -> FileSystem + + + Parse(String source) -> Object + + + + + + InitParser(String source) + + + + + + DoneParser() + + + DoParsing(int begin_pos, int end_pos) + + + + + + + StopParsing() + + + AddTagHandler(HtmlTagHandler handler) + + + + + + GetSource() -> String + + + PushTagHandler(HtmlTagHandler handler, String tags) + + + + + + + PopTagHandler() + + + + + + __init__(HtmlWindow wnd=None) -> HtmlWinParser + + + + + + SetDC(DC dc) + + + + + + GetDC() -> DC + + + GetCharHeight() -> int + + + GetCharWidth() -> int + + + GetWindow() -> HtmlWindow + + + SetFonts(String normal_face, String fixed_face, PyObject sizes=None) + + + + + + + + GetContainer() -> HtmlContainerCell + + + OpenContainer() -> HtmlContainerCell + + + SetContainer(HtmlContainerCell c) -> HtmlContainerCell + + + + + + CloseContainer() -> HtmlContainerCell + + + GetFontSize() -> int + + + SetFontSize(int s) + + + + + + GetFontBold() -> int + + + SetFontBold(int x) + + + + + + GetFontItalic() -> int + + + SetFontItalic(int x) + + + + + + GetFontUnderlined() -> int + + + SetFontUnderlined(int x) + + + + + + GetFontFixed() -> int + + + SetFontFixed(int x) + + + + + + GetAlign() -> int + + + SetAlign(int a) + + + + + + GetLinkColor() -> Colour + + + SetLinkColor(Colour clr) + + + + + + GetActualColor() -> Colour + + + SetActualColor(Colour clr) + + + + + + SetLink(String link) + + + + + + CreateCurrentFont() -> Font + + + GetLink() -> HtmlLinkInfo + + + + + + __init__() -> HtmlTagHandler + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + SetParser(HtmlParser parser) + + + + + + GetParser() -> HtmlParser + + + ParseInner(HtmlTag tag) + + + + + + + + + __init__() -> HtmlWinTagHandler + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + SetParser(HtmlParser parser) + + + + + + GetParser() -> HtmlWinParser + + + ParseInner(HtmlTag tag) + + + + + + + HtmlWinParser_AddTagHandler(PyObject tagHandlerClass) + + + + + +#--------------------------------------------------------------------------- + + + + __init__() -> HtmlSelection + + + __del__() + + + Set(Point fromPos, HtmlCell fromCell, Point toPos, HtmlCell toCell) + + + + + + + + + SetCells(HtmlCell fromCell, HtmlCell toCell) + + + + + + + GetFromCell() -> HtmlCell + + + GetToCell() -> HtmlCell + + + GetFromPos() -> Point + + + GetToPos() -> Point + + + GetFromPrivPos() -> Point + + + GetToPrivPos() -> Point + + + SetFromPrivPos(Point pos) + + + + + + SetToPrivPos(Point pos) + + + + + + ClearPrivPos() + + + IsEmpty() -> bool + + + + + __init__() -> HtmlRenderingState + + + __del__() + + + SetSelectionState(int s) + + + + + + GetSelectionState() -> int + + + SetFgColour(Colour c) + + + + + + GetFgColour() -> Colour + + + SetBgColour(Colour c) + + + + + + GetBgColour() -> Colour + + + + + GetSelectedTextColour(Colour clr) -> Colour + + + + + + GetSelectedTextBgColour(Colour clr) -> Colour + + + + + + + + + GetSelectedTextColour(Colour clr) -> Colour + + + + + + GetSelectedTextBgColour(Colour clr) -> Colour + + + + + + + + __init__() -> HtmlRenderingInfo + + + __del__() + + + SetSelection(HtmlSelection s) + + + + + + GetSelection() -> HtmlSelection + + + SetStyle(HtmlRenderingStyle style) + + + + + + GetStyle() -> HtmlRenderingStyle + + + GetState() -> HtmlRenderingState + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> HtmlCell + + + GetPosX() -> int + + + GetPosY() -> int + + + GetWidth() -> int + + + GetHeight() -> int + + + GetDescent() -> int + + + GetId() -> String + + + SetId(String id) + + + + + + GetLink(int x=0, int y=0) -> HtmlLinkInfo + + + + + + + GetNext() -> HtmlCell + + + GetParent() -> HtmlContainerCell + + + GetFirstChild() -> HtmlCell + + + GetCursor() -> Cursor + + + IsFormattingCell() -> bool + + + SetLink(HtmlLinkInfo link) + + + + + + SetNext(HtmlCell cell) + + + + + + SetParent(HtmlContainerCell p) + + + + + + SetPos(int x, int y) + + + + + + + Layout(int w) + + + + + + Draw(DC dc, int x, int y, int view_y1, int view_y2, HtmlRenderingInfo info) + + + + + + + + + + + DrawInvisible(DC dc, int x, int y, HtmlRenderingInfo info) + + + + + + + + + Find(int condition, void param) -> HtmlCell + + + + + + + AdjustPagebreak(int INOUT) -> bool + + + + + + SetCanLiveOnPagebreak(bool can) + + + + + + IsLinebreakAllowed() -> bool + + + IsTerminalCell() -> bool + + + FindCellByPos(int x, int y, unsigned int flags=HTML_FIND_EXACT) -> HtmlCell + + + + + + + + GetAbsPos() -> Point + + + GetFirstTerminal() -> HtmlCell + + + GetLastTerminal() -> HtmlCell + + + GetDepth() -> unsigned int + + + IsBefore(HtmlCell cell) -> bool + + + + + + ConvertToText(HtmlSelection sel) -> String + + + + + + + + + __init__(String word, DC dc) -> HtmlWordCell + + + + + + + + + + __init__(HtmlContainerCell parent) -> HtmlContainerCell + + + + + + InsertCell(HtmlCell cell) + + + + + + SetAlignHor(int al) + + + + + + GetAlignHor() -> int + + + SetAlignVer(int al) + + + + + + GetAlignVer() -> int + + + SetIndent(int i, int what, int units=HTML_UNITS_PIXELS) + + + + + + + + GetIndent(int ind) -> int + + + + + + GetIndentUnits(int ind) -> int + + + + + + SetAlign(HtmlTag tag) + + + + + + SetWidthFloat(int w, int units) + + + + + + + SetWidthFloatFromTag(HtmlTag tag) + + + + + + SetMinHeight(int h, int align=HTML_ALIGN_TOP) + + + + + + + SetBackgroundColour(Colour clr) + + + + + + GetBackgroundColour() -> Colour + + + SetBorder(Colour clr1, Colour clr2) + + + + + + + GetFirstChild() -> HtmlCell + + + + + + __init__(Colour clr, int flags=HTML_CLR_FOREGROUND) -> HtmlColourCell + + + + + + + + + + __init__(Font font) -> HtmlFontCell + + + + + + + + + __init__(Window wnd, int w=0) -> HtmlWidgetCell + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> HtmlFilter + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, int style=HW_DEFAULT_STYLE, + String name=HtmlWindowNameStr) -> HtmlWindow + + + + + + + + + + + PreHtmlWindow() -> HtmlWindow + + + Create(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, int style=HW_SCROLLBAR_AUTO, + String name=HtmlWindowNameStr) -> bool + + + + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + SetPage(String source) -> bool + + + + + + LoadPage(String location) -> bool + + + + + + LoadFile(String filename) -> bool + + + + + + AppendToPage(String source) -> bool + + + + + + GetOpenedPage() -> String + + + GetOpenedAnchor() -> String + + + GetOpenedPageTitle() -> String + + + SetRelatedFrame(Frame frame, String format) + + + + + + + GetRelatedFrame() -> Frame + + + SetRelatedStatusBar(int bar) + + + + + + SetFonts(String normal_face, String fixed_face, PyObject sizes=None) + + + + + + + + SetTitle(String title) + + + + + + SetBorders(int b) + + + + + + ReadCustomization(ConfigBase cfg, String path=EmptyString) + + + + + + + WriteCustomization(ConfigBase cfg, String path=EmptyString) + + + + + + + HistoryBack() -> bool + + + HistoryForward() -> bool + + + HistoryCanBack() -> bool + + + HistoryCanForward() -> bool + + + HistoryClear() + + + GetInternalRepresentation() -> HtmlContainerCell + + + GetParser() -> HtmlWinParser + + + ScrollToAnchor(String anchor) -> bool + + + + + + HasAnchor(String anchor) -> bool + + + + + + HtmlWindow.AddFilter(HtmlFilter filter) + + + + + + base_OnLinkClicked(HtmlLinkInfo link) + + + + + + base_OnSetTitle(String title) + + + + + + base_OnCellMouseHover(HtmlCell cell, int x, int y) + + + + + + + + base_OnCellClicked(HtmlCell cell, int x, int y, MouseEvent event) + + + + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> HtmlDCRenderer + + + __del__() + + + SetDC(DC dc, int maxwidth) + + + + + + + SetSize(int width, int height) + + + + + + + SetHtmlText(String html, String basepath=EmptyString, bool isdir=True) + + + + + + + + SetFonts(String normal_face, String fixed_face, PyObject sizes=None) + + + + + + + + Render(int x, int y, int from=0, int dont_render=False, int to=INT_MAX, + int choices=None, int LCOUNT=0) -> int + + + + + + + + + + + + GetTotalHeight() -> int + + + + + + __init__(String title=HtmlPrintoutTitleStr) -> HtmlPrintout + + + + + + SetHtmlText(String html, String basepath=EmptyString, bool isdir=True) + + + + + + + + SetHtmlFile(String htmlfile) + + + + + + SetHeader(String header, int pg=PAGE_ALL) + + + + + + + SetFooter(String footer, int pg=PAGE_ALL) + + + + + + + SetFonts(String normal_face, String fixed_face, PyObject sizes=None) + + + + + + + + SetMargins(float top=25.2, float bottom=25.2, float left=25.2, + float right=25.2, float spaces=5) + + + + + + + + + + HtmlPrintout.AddFilter(wxHtmlFilter filter) + + + + + + HtmlPrintout.CleanUpStatics() + + + + + + __init__(String name=HtmlPrintingTitleStr, Window parentWindow=None) -> HtmlEasyPrinting + + + + + + + __del__() + + + PreviewFile(String htmlfile) + + + + + + PreviewText(String htmltext, String basepath=EmptyString) + + + + + + + PrintFile(String htmlfile) + + + + + + PrintText(String htmltext, String basepath=EmptyString) + + + + + + + PrinterSetup() + + + PageSetup() + + + SetHeader(String header, int pg=PAGE_ALL) + + + + + + + SetFooter(String footer, int pg=PAGE_ALL) + + + + + + + SetFonts(String normal_face, String fixed_face, PyObject sizes=None) + + + + + + + + GetPrintData() -> PrintData + + + GetPageSetupData() -> PageSetupDialogData + + + +#--------------------------------------------------------------------------- + + + + __init__(String bookfile, String basepath, String title, String start) -> HtmlBookRecord + + + + + + + + + GetBookFile() -> String + + + GetTitle() -> String + + + GetStart() -> String + + + GetBasePath() -> String + + + SetContentsRange(int start, int end) + + + + + + + GetContentsStart() -> int + + + GetContentsEnd() -> int + + + SetTitle(String title) + + + + + + SetBasePath(String path) + + + + + + SetStart(String start) + + + + + + GetFullPath(String page) -> String + + + + + + + + GetLevel() -> int + + + GetID() -> int + + + GetName() -> String + + + GetPage() -> String + + + GetBook() -> HtmlBookRecord + + + + + Search() -> bool + + + IsActive() -> bool + + + GetCurIndex() -> int + + + GetMaxIndex() -> int + + + GetName() -> String + + + GetContentsItem() -> HtmlContentsItem + + + + + __init__() -> HtmlHelpData + + + __del__() + + + SetTempDir(String path) + + + + + + AddBook(String book) -> bool + + + + + + FindPageByName(String page) -> String + + + + + + FindPageById(int id) -> String + + + + + + GetBookRecArray() -> wxHtmlBookRecArray + + + GetContents() -> HtmlContentsItem + + + GetContentsCnt() -> int + + + GetIndex() -> HtmlContentsItem + + + GetIndexCnt() -> int + + + + + + __init__(Window parent, int ??, String title=EmptyString, int style=HF_DEFAULTSTYLE, + HtmlHelpData data=None) -> HtmlHelpFrame + + + + + + + + + + GetData() -> HtmlHelpData + + + SetTitleFormat(String format) + + + + + + Display(String x) + + + + + + DisplayID(int id) + + + + + + DisplayContents() + + + DisplayIndex() + + + KeywordSearch(String keyword) -> bool + + + + + + UseConfig(ConfigBase config, String rootpath=EmptyString) + + + + + + + ReadCustomization(ConfigBase cfg, String path=EmptyString) + + + + + + + WriteCustomization(ConfigBase cfg, String path=EmptyString) + + + + + + + + + + __init__(int style=HF_DEFAULTSTYLE) -> HtmlHelpController + + + + + + __del__() + + + SetTitleFormat(String format) + + + + + + SetTempDir(String path) + + + + + + AddBook(String book, int show_wait_msg=False) -> bool + + + + + + + Display(String x) + + + + + + DisplayID(int id) + + + + + + DisplayContents() + + + DisplayIndex() + + + KeywordSearch(String keyword) -> bool + + + + + + UseConfig(ConfigBase config, String rootpath=EmptyString) + + + + + + + ReadCustomization(ConfigBase cfg, String path=EmptyString) + + + + + + + WriteCustomization(ConfigBase cfg, String path=EmptyString) + + + + + + + GetFrame() -> HtmlHelpFrame + + + + + wx = core + +EVT_WIZARD_PAGE_CHANGED = wx.PyEventBinder( wxEVT_WIZARD_PAGE_CHANGED, 1) +EVT_WIZARD_PAGE_CHANGING = wx.PyEventBinder( wxEVT_WIZARD_PAGE_CHANGING, 1) +EVT_WIZARD_CANCEL = wx.PyEventBinder( wxEVT_WIZARD_CANCEL, 1) +EVT_WIZARD_HELP = wx.PyEventBinder( wxEVT_WIZARD_HELP, 1) +EVT_WIZARD_FINISHED = wx.PyEventBinder( wxEVT_WIZARD_FINISHED, 1) + + + + + __init__(wxEventType type=wxEVT_NULL, int id=-1, bool direction=True, + WizardPage page=None) -> WizardEvent + + + + + + + + + GetDirection() -> bool + + + GetPage() -> WizardPage + + + + + + Create(Wizard parent, Bitmap bitmap=wxNullBitmap, String resource=EmptyString) -> bool + + + + + + + + GetPrev() -> WizardPage + + + GetNext() -> WizardPage + + + GetBitmap() -> Bitmap + + + + + + __init__(Wizard parent, Bitmap bitmap=&wxNullBitmap, String resource=&wxPyEmptyString) -> PyWizardPage + + + + + + + + PrePyWizardPage() -> PyWizardPage + + + Create(Wizard parent, Bitmap bitmap=wxNullBitmap, String resource=EmptyString) -> bool + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_DoMoveWindow(int x, int y, int width, int height) + + + + + + + + + base_DoSetSize(int x, int y, int width, int height, int sizeFlags=SIZE_AUTO) + + + + + + + + + + base_DoSetClientSize(int width, int height) + + + + + + + base_DoSetVirtualSize(int x, int y) + + + + + + + base_DoGetSize() -> (width, height) + + + + + + + base_DoGetClientSize() -> (width, height) + + + + + + + base_DoGetPosition() -> (x,y) + + + + + + + base_DoGetVirtualSize() -> Size + + + base_DoGetBestSize() -> Size + + + base_InitDialog() + + + base_TransferDataToWindow() -> bool + + + base_TransferDataFromWindow() -> bool + + + base_Validate() -> bool + + + base_AcceptsFocus() -> bool + + + base_AcceptsFocusFromKeyboard() -> bool + + + base_GetMaxSize() -> Size + + + base_AddChild(Window child) + + + + + + base_RemoveChild(Window child) + + + + + + + + + __init__(Wizard parent, WizardPage prev=None, WizardPage next=None, + Bitmap bitmap=wxNullBitmap, wxChar resource=None) -> WizardPageSimple + + + + + + + + + + PreWizardPageSimple() -> WizardPageSimple + + + Create(Wizard parent=None, WizardPage prev=None, WizardPage next=None, + Bitmap bitmap=wxNullBitmap, wxChar resource=None) -> bool + + + + + + + + + + SetPrev(WizardPage prev) + + + + + + SetNext(WizardPage next) + + + + + + WizardPageSimple.Chain(WizardPageSimple first, WizardPageSimple second) + + + + + + + + + + __init__(Window parent, int id=-1, String title=EmptyString, + Bitmap bitmap=wxNullBitmap, Point pos=DefaultPosition, + long style=DEFAULT_DIALOG_STYLE) -> Wizard + + + + + + + + + + + PreWizard() -> Wizard + + + Create(Window parent, int id=-1, String title=EmptyString, + Bitmap bitmap=wxNullBitmap, Point pos=DefaultPosition) -> bool + + + + + + + + + + Init() + + + RunWizard(WizardPage firstPage) -> bool + + + + + + GetCurrentPage() -> WizardPage + + + SetPageSize(Size size) + + + + + + GetPageSize() -> Size + + + FitToPage(WizardPage firstPage) + + + + + + GetPageAreaSizer() -> Sizer + + + SetBorder(int border) + + + + + + IsRunning() -> bool + + + ShowPage(WizardPage page, bool goingForward=True) -> bool + + + + + + + HasNextPage(WizardPage page) -> bool + + + + + + HasPrevPage(WizardPage page) -> bool + + + + + + + + wx = core + + + + __init__(bool isRGB, GLCanvas win, wxPalette palette=wxNullPalette, + GLContext other=None) -> GLContext + + + + + + + + + __del__() + + + SetCurrent() + + + SetColour(String colour) + + + + + + SwapBuffers() + + + SetupPixelFormat() + + + SetupPalette(wxPalette palette) + + + + + + CreateDefaultPalette() -> wxPalette + + + GetPalette() -> wxPalette + + + GetWindow() -> Window + + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0, String name=GLCanvasNameStr, + int attribList=None, wxPalette palette=wxNullPalette) -> GLCanvas + + + + + + + + + + + + + wxGLCanvasWithContext(Window parent, GLContext shared=None, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, + long style=0, String name=GLCanvasNameStr, + int attribList=None, wxPalette palette=wxNullPalette) -> GLCanvas + + + + + + + + + + + + + + SetCurrent() + + + SetColour(String colour) + + + + + + SwapBuffers() + + + GetContext() -> GLContext + + + + + wx = core + +#--------------------------------------------------------------------------- + + + + + __init__() -> ShapeRegion + + + SetText(String s) + + + + + + SetFont(Font f) + + + + + + SetMinSize(double w, double h) + + + + + + + SetSize(double w, double h) + + + + + + + SetPosition(double x, double y) + + + + + + + SetProportions(double x, double y) + + + + + + + SetFormatMode(int mode) + + + + + + SetName(String s) + + + + + + SetColour(String col) + + + + + + GetText() -> String + + + GetFont() -> Font + + + GetMinSize(double OUTPUT, double OUTPUT) + + + + + + + GetProportion(double OUTPUT, double OUTPUT) + + + + + + + GetSize(double OUTPUT, double OUTPUT) + + + + + + + GetPosition(double OUTPUT, double OUTPUT) + + + + + + + GetFormatMode() -> int + + + GetName() -> String + + + GetColour() -> String + + + GetActualColourObject() -> Colour + + + GetFormattedText() -> wxList + + + GetPenColour() -> String + + + GetPenStyle() -> int + + + SetPenStyle(int style) + + + + + + SetPenColour(String col) + + + + + + GetActualPen() -> wxPen + + + GetWidth() -> double + + + GetHeight() -> double + + + ClearText() + + + + + + __init__(PyShapeEvtHandler prev=None, PyShape shape=None) -> PyShapeEvtHandler + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + _setOORInfo(PyObject _self) + + + + + + SetShape(PyShape sh) + + + + + + GetShape() -> PyShape + + + SetPreviousHandler(PyShapeEvtHandler handler) + + + + + + GetPreviousHandler() -> PyShapeEvtHandler + + + CreateNewCopy() -> PyShapeEvtHandler + + + base_OnDelete() + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=False) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__(PyShapeCanvas can=None) -> PyShape + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + GetBoundingBoxMax(double OUTPUT, double OUTPUT) + + + + + + + GetBoundingBoxMin(double OUTPUT, double OUTPUT) + + + + + + + GetPerimeterPoint(double x1, double y1, double x2, double y2, double OUTPUT, + double OUTPUT) -> bool + + + + + + + + + + + GetCanvas() -> PyShapeCanvas + + + SetCanvas(PyShapeCanvas the_canvas) + + + + + + AddToCanvas(PyShapeCanvas the_canvas, PyShape addAfter=None) + + + + + + + InsertInCanvas(PyShapeCanvas the_canvas) + + + + + + RemoveFromCanvas(PyShapeCanvas the_canvas) + + + + + + GetX() -> double + + + GetY() -> double + + + SetX(double x) + + + + + + SetY(double y) + + + + + + GetParent() -> PyShape + + + SetParent(PyShape p) + + + + + + GetTopAncestor() -> PyShape + + + GetChildren() -> PyObject + + + Unlink() + + + SetDrawHandles(bool drawH) + + + + + + GetDrawHandles() -> bool + + + MakeControlPoints() + + + DeleteControlPoints(DC dc=None) + + + + + + ResetControlPoints() + + + GetEventHandler() -> PyShapeEvtHandler + + + SetEventHandler(PyShapeEvtHandler handler) + + + + + + MakeMandatoryControlPoints() + + + ResetMandatoryControlPoints() + + + Recompute() -> bool + + + CalculateSize() + + + Select(bool select=True, DC dc=None) + + + + + + + SetHighlight(bool hi=True, bool recurse=False) + + + + + + + IsHighlighted() -> bool + + + Selected() -> bool + + + AncestorSelected() -> bool + + + SetSensitivityFilter(int sens=OP_ALL, bool recursive=False) + + + + + + + GetSensitivityFilter() -> int + + + SetDraggable(bool drag, bool recursive=False) + + + + + + + SetFixedSize(bool x, bool y) + + + + + + + GetFixedSize(bool OUTPUT, bool OUTPUT) + + + + + + + GetFixedWidth() -> bool + + + GetFixedHeight() -> bool + + + SetSpaceAttachments(bool sp) + + + + + + GetSpaceAttachments() -> bool + + + SetShadowMode(int mode, bool redraw=False) + + + + + + + GetShadowMode() -> int + + + HitTest(double x, double y, int OUTPUT, double OUTPUT) -> bool + + + + + + + + + SetCentreResize(bool cr) + + + + + + GetCentreResize() -> bool + + + SetMaintainAspectRatio(bool ar) + + + + + + GetMaintainAspectRatio() -> bool + + + GetLines() -> PyObject + + + SetDisableLabel(bool flag) + + + + + + GetDisableLabel() -> bool + + + SetAttachmentMode(int mode) + + + + + + GetAttachmentMode() -> int + + + SetId(long i) + + + + + + GetId() -> long + + + SetPen(wxPen pen) + + + + + + SetBrush(wxBrush brush) + + + + + + Show(bool show) + + + + + + IsShown() -> bool + + + Move(DC dc, double x1, double y1, bool display=True) + + + + + + + + + Erase(DC dc) + + + + + + EraseContents(DC dc) + + + + + + Draw(DC dc) + + + + + + Flash() + + + MoveLinks(DC dc) + + + + + + DrawContents(DC dc) + + + + + + SetSize(double x, double y, bool recursive=True) + + + + + + + + SetAttachmentSize(double x, double y) + + + + + + + Attach(PyShapeCanvas can) + + + + + + Detach() + + + Constrain() -> bool + + + AddLine(PyLineShape line, PyShape other, int attachFrom=0, + int attachTo=0, int positionFrom=-1, int positionTo=-1) + + + + + + + + + + + GetLinePosition(PyLineShape line) -> int + + + + + + AddText(String string) + + + + + + GetPen() -> wxPen + + + GetBrush() -> wxBrush + + + SetDefaultRegionSize() + + + FormatText(DC dc, String s, int regionId=0) + + + + + + + + SetFormatMode(int mode, int regionId=0) + + + + + + + GetFormatMode(int regionId=0) -> int + + + + + + SetFont(Font font, int regionId=0) + + + + + + + GetFont(int regionId=0) -> Font + + + + + + SetTextColour(String colour, int regionId=0) + + + + + + + GetTextColour(int regionId=0) -> String + + + + + + GetNumberOfTextRegions() -> int + + + SetRegionName(String name, int regionId=0) + + + + + + + GetRegionName(int regionId) -> String + + + + + + GetRegionId(String name) -> int + + + + + + NameRegions(String parentName=EmptyString) + + + + + + GetRegions() -> PyObject + + + AddRegion(ShapeRegion region) + + + + + + ClearRegions() + + + AssignNewIds() + + + FindRegion(String regionName, int OUTPUT) -> PyShape + + + + + + + FindRegionNames(wxStringList list) + + + + + + ClearText(int regionId=0) + + + + + + RemoveLine(PyLineShape line) + + + + + + GetAttachmentPosition(int attachment, double OUTPUT, double OUTPUT, int nth=0, + int no_arcs=1, PyLineShape line=None) -> bool + + + + + + + + + + + GetNumberOfAttachments() -> int + + + AttachmentIsValid(int attachment) -> bool + + + + + + GetAttachmentPositionEdge(int attachment, double OUTPUT, double OUTPUT, int nth=0, + int no_arcs=1, PyLineShape line=None) -> bool + + + + + + + + + + + CalcSimpleAttachment(RealPoint pt1, RealPoint pt2, int nth, int noArcs, + PyLineShape line) -> RealPoint + + + + + + + + + + AttachmentSortTest(int attachmentPoint, RealPoint pt1, RealPoint pt2) -> bool + + + + + + + + EraseLinks(DC dc, int attachment=-1, bool recurse=False) + + + + + + + + DrawLinks(DC dc, int attachment=-1, bool recurse=False) + + + + + + + + MoveLineToNewAttachment(DC dc, PyLineShape to_move, double x, double y) -> bool + + + + + + + + + ApplyAttachmentOrdering(PyObject linesToSort) + + + + + + GetBranchingAttachmentRoot(int attachment) -> RealPoint + + + + + + GetBranchingAttachmentInfo(int attachment, RealPoint root, RealPoint neck, RealPoint shoulder1, + RealPoint shoulder2) -> bool + + + + + + + + + + GetBranchingAttachmentPoint(int attachment, int n, RealPoint attachmentPoint, RealPoint stemPoint) -> bool + + + + + + + + + GetAttachmentLineCount(int attachment) -> int + + + + + + SetBranchNeckLength(int len) + + + + + + GetBranchNeckLength() -> int + + + SetBranchStemLength(int len) + + + + + + GetBranchStemLength() -> int + + + SetBranchSpacing(int len) + + + + + + GetBranchSpacing() -> int + + + SetBranchStyle(long style) + + + + + + GetBranchStyle() -> long + + + PhysicalToLogicalAttachment(int physicalAttachment) -> int + + + + + + LogicalToPhysicalAttachment(int logicalAttachment) -> int + + + + + + Draggable() -> bool + + + HasDescendant(PyShape image) -> bool + + + + + + CreateNewCopy(bool resetMapping=True, bool recompute=True) -> PyShape + + + + + + + Copy(PyShape copy) + + + + + + CopyWithHandler(PyShape copy) + + + + + + Rotate(double x, double y, double theta) + + + + + + + + GetRotation() -> double + + + ClearAttachments() + + + Recentre(DC dc) + + + + + + ClearPointList(wxList list) + + + + + + GetBackgroundPen() -> wxPen + + + GetBackgroundBrush() -> wxBrush + + + base_OnDelete() + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=False) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__() -> PseudoMetaFile + + + __del__() + + + Draw(DC dc, double xoffset, double yoffset) + + + + + + + + Clear() + + + Copy(PseudoMetaFile copy) + + + + + + Scale(double sx, double sy) + + + + + + + ScaleTo(double w, double h) + + + + + + + Translate(double x, double y) + + + + + + + Rotate(double x, double y, double theta) + + + + + + + + LoadFromMetaFile(String filename, double width, double height) -> bool + + + + + + + + GetBounds(double minX, double minY, double maxX, double maxY) + + + + + + + + + CalculateSize(PyDrawnShape shape) + + + + + + SetRotateable(bool rot) + + + + + + GetRotateable() -> bool + + + SetSize(double w, double h) + + + + + + + SetFillBrush(wxBrush brush) + + + + + + GetFillBrush() -> wxBrush + + + SetOutlinePen(wxPen pen) + + + + + + GetOutlinePen() -> wxPen + + + SetOutlineOp(int op) + + + + + + GetOutlineOp() -> int + + + IsValid() -> bool + + + DrawLine(Point pt1, Point pt2) + + + + + + + DrawRectangle(Rect rect) + + + + + + DrawRoundedRectangle(Rect rect, double radius) + + + + + + + DrawArc(Point centrePt, Point startPt, Point endPt) + + + + + + + + DrawEllipticArc(Rect rect, double startAngle, double endAngle) + + + + + + + + DrawEllipse(Rect rect) + + + + + + DrawPoint(Point pt) + + + + + + DrawText(String text, Point pt) + + + + + + + DrawLines(int PCOUNT, Point points) + + + + + + + DrawPolygon(int PCOUNT, Point points, int flags=0) + + + + + + + + DrawSpline(int PCOUNT, Point points) + + + + + + + SetClippingRect(Rect rect) + + + + + + DestroyClippingRect() + + + SetPen(wxPen pen, bool isOutline=FALSE) + + + + + + + SetBrush(wxBrush brush, bool isFill=FALSE) + + + + + + + SetFont(Font font) + + + + + + SetTextColour(Colour colour) + + + + + + SetBackgroundColour(Colour colour) + + + + + + SetBackgroundMode(int mode) + + + + + + + + + __init__(double width=0.0, double height=0.0) -> PyRectangleShape + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + SetCornerRadius(double radius) + + + + + + base_OnDelete() + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=FALSE) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__(PyShapeCanvas the_canvas=None, PyShape object=None, + double size=0.0, double the_xoffset=0.0, double the_yoffset=0.0, + int the_type=0) -> PyControlPoint + + + + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + SetCornerRadius(double radius) + + + + + + base_OnDelete() + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=FALSE) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__() -> PyBitmapShape + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + GetBitmap() -> Bitmap + + + GetFilename() -> String + + + SetBitmap(Bitmap bitmap) + + + + + + SetFilename(String filename) + + + + + + base_OnDelete() + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=FALSE) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__() -> PyDrawnShape + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + CalculateSize() + + + DestroyClippingRect() + + + DrawArc(Point centrePoint, Point startPoint, Point endPoint) + + + + + + + + DrawAtAngle(int angle) + + + + + + DrawEllipticArc(Rect rect, double startAngle, double endAngle) + + + + + + + + DrawLine(Point point1, Point point2) + + + + + + + DrawLines(int PCOUNT, Point points) + + + + + + + DrawPoint(Point point) + + + + + + DrawPolygon(int PCOUNT, Point points, int flags=0) + + + + + + + + DrawRectangle(Rect rect) + + + + + + DrawRoundedRectangle(Rect rect, double radius) + + + + + + + DrawSpline(int PCOUNT, Point points) + + + + + + + DrawText(String text, Point point) + + + + + + + GetAngle() -> int + + + GetMetaFile() -> PseudoMetaFile + + + GetRotation() -> double + + + LoadFromMetaFile(String filename) -> bool + + + + + + Rotate(double x, double y, double theta) + + + + + + + + SetClippingRect(Rect rect) + + + + + + SetDrawnBackgroundColour(Colour colour) + + + + + + SetDrawnBackgroundMode(int mode) + + + + + + SetDrawnBrush(wxBrush pen, bool isOutline=FALSE) + + + + + + + SetDrawnFont(Font font) + + + + + + SetDrawnPen(wxPen pen, bool isOutline=FALSE) + + + + + + + SetDrawnTextColour(Colour colour) + + + + + + Scale(double sx, double sy) + + + + + + + SetSaveToFile(bool save) + + + + + + Translate(double x, double y) + + + + + + + base_OnDelete() + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=FALSE) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__(int type, PyShape constraining, PyObject constrained) -> OGLConstraint + + + + + + + + Evaluate() -> bool + + + SetSpacing(double x, double y) + + + + + + + Equals(double a, double b) -> bool + + + + + + + + + + __init__() -> PyCompositeShape + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + AddChild(PyShape child, PyShape addAfter=None) + + + + + + + AddConstraint(OGLConstraint constraint) -> OGLConstraint + + + + + + AddConstrainedShapes(int type, PyShape constraining, PyObject constrained) -> OGLConstraint + + + + + + + + AddSimpleConstraint(int type, PyShape constraining, PyShape constrained) -> OGLConstraint + + + + + + + + CalculateSize() + + + ContainsDivision(PyDivisionShape division) -> bool + + + + + + DeleteConstraint(OGLConstraint constraint) + + + + + + DeleteConstraintsInvolvingChild(PyShape child) + + + + + + FindContainerImage() -> PyShape + + + GetConstraints() -> PyObject + + + GetDivisions() -> PyObject + + + MakeContainer() + + + Recompute() -> bool + + + RemoveChild(PyShape child) + + + + + + base_OnDelete() + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=FALSE) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__(double width=0.0, double height=0.0) -> PyDividedShape + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + EditRegions() + + + SetRegionSizes() + + + base_OnDelete() + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=FALSE) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__() -> PyDivisionShape + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + AdjustBottom(double bottom, bool test) + + + + + + + AdjustLeft(double left, bool test) + + + + + + + AdjustRight(double right, bool test) + + + + + + + AdjustTop(double top, bool test) + + + + + + + Divide(int direction) + + + + + + EditEdge(int side) + + + + + + GetBottomSide() -> PyDivisionShape + + + GetHandleSide() -> int + + + GetLeftSide() -> PyDivisionShape + + + GetLeftSideColour() -> String + + + GetLeftSidePen() -> wxPen + + + GetRightSide() -> PyDivisionShape + + + GetTopSide() -> PyDivisionShape + + + GetTopSidePen() -> wxPen + + + ResizeAdjoining(int side, double newPos, bool test) + + + + + + + + PopupMenu(double x, double y) + + + + + + + SetBottomSide(PyDivisionShape shape) + + + + + + SetHandleSide(int side) + + + + + + SetLeftSide(PyDivisionShape shape) + + + + + + SetLeftSideColour(String colour) + + + + + + SetLeftSidePen(wxPen pen) + + + + + + SetRightSide(PyDivisionShape shape) + + + + + + SetTopSide(PyDivisionShape shape) + + + + + + SetTopSideColour(String colour) + + + + + + SetTopSidePen(wxPen pen) + + + + + + base_OnDelete() + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=FALSE) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__(double width=0.0, double height=0.0) -> PyEllipseShape + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=FALSE) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__(double width=0.0) -> PyCircleShape + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=FALSE) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__(int type=0, int end=0, double size=0.0, double dist=0.0, + String name=EmptyString, PseudoMetaFile mf=None, + long arrowId=-1) -> ArrowHead + + + + + + + + + + + + __del__() + + + _GetType() -> int + + + GetPosition() -> int + + + SetPosition(int pos) + + + + + + GetXOffset() -> double + + + GetYOffset() -> double + + + GetSpacing() -> double + + + GetSize() -> double + + + GetName() -> String + + + SetXOffset(double x) + + + + + + SetYOffset(double y) + + + + + + GetMetaFile() -> PseudoMetaFile + + + GetId() -> long + + + GetArrowEnd() -> int + + + GetArrowSize() -> double + + + SetSize(double size) + + + + + + SetSpacing(double sp) + + + + + + + + + __init__() -> PyLineShape + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + AddArrow(int type, int end=ARROW_POSITION_END, double arrowSize=10.0, + double xOffset=0.0, String name=EmptyString, + PseudoMetaFile mf=None, long arrowId=-1) + + + + + + + + + + + + AddArrowOrdered(ArrowHead arrow, PyObject referenceList, int end) + + + + + + + + ClearArrow(String name) -> bool + + + + + + ClearArrowsAtPosition(int position=-1) + + + + + + DrawArrow(DC dc, ArrowHead arrow, double xOffset, bool proportionalOffset) + + + + + + + + + DeleteArrowHeadId(long arrowId) -> bool + + + + + + DeleteArrowHead(int position, String name) -> bool + + + + + + + DeleteLineControlPoint() -> bool + + + DrawArrows(DC dc) + + + + + + DrawRegion(DC dc, ShapeRegion region, double x, double y) + + + + + + + + + EraseRegion(DC dc, ShapeRegion region, double x, double y) + + + + + + + + + FindArrowHeadId(long arrowId) -> ArrowHead + + + + + + FindArrowHead(int position, String name) -> ArrowHead + + + + + + + FindLineEndPoints(double OUTPUT, double OUTPUT, double OUTPUT, double OUTPUT) + + + + + + + + + FindLinePosition(double x, double y) -> int + + + + + + + FindMinimumWidth() -> double + + + FindNth(PyShape image, int OUTPUT, int OUTPUT, bool incoming) + + + + + + + + + GetAttachmentFrom() -> int + + + GetAttachmentTo() -> int + + + GetEnds(double OUTPUT, double OUTPUT, double OUTPUT, double OUTPUT) + + + + + + + + + GetFrom() -> PyShape + + + GetLabelPosition(int position, double OUTPUT, double OUTPUT) + + + + + + + + GetNextControlPoint(PyShape shape) -> RealPoint + + + + + + GetTo() -> PyShape + + + Initialise() + + + InsertLineControlPoint(DC dc) + + + + + + IsEnd(PyShape shape) -> bool + + + + + + IsSpline() -> bool + + + MakeLineControlPoints(int n) + + + + + + GetLineControlPoints() -> PyObject + + + SetAttachmentFrom(int fromAttach) + + + + + + SetAttachments(int fromAttach, int toAttach) + + + + + + + SetAttachmentTo(int toAttach) + + + + + + SetEnds(double x1, double y1, double x2, double y2) + + + + + + + + + SetFrom(PyShape object) + + + + + + SetIgnoreOffsets(bool ignore) + + + + + + SetSpline(bool spline) + + + + + + SetTo(PyShape object) + + + + + + Straighten(DC dc=None) + + + + + + Unlink() + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=FALSE) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__() -> PyPolygonShape + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + Create(PyObject points) -> PyObject + + + + + + AddPolygonPoint(int pos=0) + + + + + + CalculatePolygonCentre() + + + DeletePolygonPoint(int pos=0) + + + + + + GetPoints() -> PyObject + + + UpdateOriginalPoints() + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=FALSE) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__(double width=0.0, double height=0.0) -> PyTextShape + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + base_OnDelete() + + + base_OnDraw(DC dc) + + + + + + base_OnDrawContents(DC dc) + + + + + + base_OnDrawBranches(DC dc, bool erase=FALSE) + + + + + + + base_OnMoveLinks(DC dc) + + + + + + base_OnErase(DC dc) + + + + + + base_OnEraseContents(DC dc) + + + + + + base_OnHighlight(DC dc) + + + + + + base_OnLeftClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnLeftDoubleClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnRightClick(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnSize(double x, double y) + + + + + + + base_OnMovePre(DC dc, double x, double y, double old_x, double old_y, + bool display=True) -> bool + + + + + + + + + + + base_OnMovePost(DC dc, double x, double y, double old_x, double old_y, + bool display=True) + + + + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0, int attachment=0) + + + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0, int attachment=0) + + + + + + + + + base_OnDrawOutline(DC dc, double x, double y, double w, double h) + + + + + + + + + + base_OnDrawControlPoints(DC dc) + + + + + + base_OnEraseControlPoints(DC dc) + + + + + + base_OnMoveLink(DC dc, bool moveControlPoints=True) + + + + + + + base_OnSizingDragLeft(PyControlPoint pt, bool draw, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + + base_OnSizingBeginDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnSizingEndDragLeft(PyControlPoint pt, double x, double y, int keys=0, + int attachment=0) + + + + + + + + + + base_OnBeginSize(double w, double h) + + + + + + + base_OnEndSize(double w, double h) + + + + + + + + + + __init__() -> Diagram + + + AddShape(PyShape shape, PyShape addAfter=None) + + + + + + + Clear(DC dc) + + + + + + DeleteAllShapes() + + + DrawOutline(DC dc, double x1, double y1, double x2, double y2) + + + + + + + + + + FindShape(long id) -> PyShape + + + + + + GetCanvas() -> PyShapeCanvas + + + GetCount() -> int + + + GetGridSpacing() -> double + + + GetMouseTolerance() -> int + + + GetShapeList() -> PyObject + + + GetQuickEditMode() -> bool + + + GetSnapToGrid() -> bool + + + InsertShape(PyShape shape) + + + + + + RecentreAll(DC dc) + + + + + + Redraw(DC dc) + + + + + + RemoveAllShapes() + + + RemoveShape(PyShape shape) + + + + + + SetCanvas(PyShapeCanvas canvas) + + + + + + SetGridSpacing(double spacing) + + + + + + SetMouseTolerance(int tolerance) + + + + + + SetQuickEditMode(bool mode) + + + + + + SetSnapToGrid(bool snap) + + + + + + ShowAll(bool show) + + + + + + Snap(double INOUT, double INOUT) + + + + + + + + + + __init__(Window parent=None, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=BORDER, + String name=wxPyShapeCanvasNameStr) -> PyShapeCanvas + + + + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + AddShape(PyShape shape, PyShape addAfter=None) + + + + + + + FindShape(double x1, double y, int OUTPUT, wxClassInfo info=None, + PyShape notImage=None) -> PyShape + + + + + + + + + + FindFirstSensitiveShape(double x1, double y, int OUTPUT, int op) -> PyShape + + + + + + + + + GetDiagram() -> Diagram + + + GetQuickEditMode() -> bool + + + InsertShape(PyShape shape) + + + + + + base_OnBeginDragLeft(double x, double y, int keys=0) + + + + + + + + base_OnBeginDragRight(double x, double y, int keys=0) + + + + + + + + base_OnEndDragLeft(double x, double y, int keys=0) + + + + + + + + base_OnEndDragRight(double x, double y, int keys=0) + + + + + + + + base_OnDragLeft(bool draw, double x, double y, int keys=0) + + + + + + + + + base_OnDragRight(bool draw, double x, double y, int keys=0) + + + + + + + + + base_OnLeftClick(double x, double y, int keys=0) + + + + + + + + base_OnRightClick(double x, double y, int keys=0) + + + + + + + + Redraw(DC dc) + + + + + + RemoveShape(PyShape shape) + + + + + + SetDiagram(Diagram diagram) + + + + + + Snap(double INOUT, double INOUT) + + + + + + + +# Aliases +ShapeCanvas = PyShapeCanvas +ShapeEvtHandler = PyShapeEvtHandler +Shape = PyShape +RectangleShape = PyRectangleShape +BitmapShape = PyBitmapShape +DrawnShape = PyDrawnShape +CompositeShape = PyCompositeShape +DividedShape = PyDividedShape +DivisionShape = PyDivisionShape +EllipseShape = PyEllipseShape +CircleShape = PyCircleShape +LineShape = PyLineShape +PolygonShape = PyPolygonShape +TextShape = PyTextShape +ControlPoint = PyControlPoint + + + OGLInitialize() + + + OGLCleanUp() + + + + wx = core + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, String name=STCNameStr) -> StyledTextCtrl + + + + + + + + + + + PreStyledTextCtrl() -> StyledTextCtrl + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=0, String name=wxSTCNameStr) + + + + + + + + + + + AddText(String text) + + + + + + AddStyledText(wxMemoryBuffer data) + + + + + + InsertText(int pos, String text) + + + + + + + ClearAll() + + + ClearDocumentStyle() + + + GetLength() -> int + + + GetCharAt(int pos) -> int + + + + + + GetCurrentPos() -> int + + + GetAnchor() -> int + + + GetStyleAt(int pos) -> int + + + + + + Redo() + + + SetUndoCollection(bool collectUndo) + + + + + + SelectAll() + + + SetSavePoint() + + + GetStyledText(int startPos, int endPos) -> wxMemoryBuffer + + + + + + + CanRedo() -> bool + + + MarkerLineFromHandle(int handle) -> int + + + + + + MarkerDeleteHandle(int handle) + + + + + + GetUndoCollection() -> bool + + + GetViewWhiteSpace() -> int + + + SetViewWhiteSpace(int viewWS) + + + + + + PositionFromPoint(Point pt) -> int + + + + + + PositionFromPointClose(int x, int y) -> int + + + + + + + GotoLine(int line) + + + + + + GotoPos(int pos) + + + + + + SetAnchor(int posAnchor) + + + + + + GetCurLine(int OUTPUT) -> String + + + + + + GetEndStyled() -> int + + + ConvertEOLs(int eolMode) + + + + + + GetEOLMode() -> int + + + SetEOLMode(int eolMode) + + + + + + StartStyling(int pos, int mask) + + + + + + + SetStyling(int length, int style) + + + + + + + GetBufferedDraw() -> bool + + + SetBufferedDraw(bool buffered) + + + + + + SetTabWidth(int tabWidth) + + + + + + GetTabWidth() -> int + + + SetCodePage(int codePage) + + + + + + MarkerDefine(int markerNumber, int markerSymbol, Colour foreground=wxNullColour, + Colour background=wxNullColour) + + + + + + + + + MarkerSetForeground(int markerNumber, Colour fore) + + + + + + + MarkerSetBackground(int markerNumber, Colour back) + + + + + + + MarkerAdd(int line, int markerNumber) -> int + + + + + + + MarkerDelete(int line, int markerNumber) + + + + + + + MarkerDeleteAll(int markerNumber) + + + + + + MarkerGet(int line) -> int + + + + + + MarkerNext(int lineStart, int markerMask) -> int + + + + + + + MarkerPrevious(int lineStart, int markerMask) -> int + + + + + + + MarkerDefineBitmap(int markerNumber, Bitmap bmp) + + + + + + + SetMarginType(int margin, int marginType) + + + + + + + GetMarginType(int margin) -> int + + + + + + SetMarginWidth(int margin, int pixelWidth) + + + + + + + GetMarginWidth(int margin) -> int + + + + + + SetMarginMask(int margin, int mask) + + + + + + + GetMarginMask(int margin) -> int + + + + + + SetMarginSensitive(int margin, bool sensitive) + + + + + + + GetMarginSensitive(int margin) -> bool + + + + + + StyleClearAll() + + + StyleSetForeground(int style, Colour fore) + + + + + + + StyleSetBackground(int style, Colour back) + + + + + + + StyleSetBold(int style, bool bold) + + + + + + + StyleSetItalic(int style, bool italic) + + + + + + + StyleSetSize(int style, int sizePoints) + + + + + + + StyleSetFaceName(int style, String fontName) + + + + + + + StyleSetEOLFilled(int style, bool filled) + + + + + + + StyleResetDefault() + + + StyleSetUnderline(int style, bool underline) + + + + + + + StyleSetCase(int style, int caseForce) + + + + + + + StyleSetCharacterSet(int style, int characterSet) + + + + + + + StyleSetHotSpot(int style, bool hotspot) + + + + + + + SetSelForeground(bool useSetting, Colour fore) + + + + + + + SetSelBackground(bool useSetting, Colour back) + + + + + + + SetCaretForeground(Colour fore) + + + + + + CmdKeyAssign(int key, int modifiers, int cmd) + + + + + + + + CmdKeyClear(int key, int modifiers) + + + + + + + CmdKeyClearAll() + + + SetStyleBytes(int length, char styleBytes) + + + + + + + StyleSetVisible(int style, bool visible) + + + + + + + GetCaretPeriod() -> int + + + SetCaretPeriod(int periodMilliseconds) + + + + + + SetWordChars(String characters) + + + + + + BeginUndoAction() + + + EndUndoAction() + + + IndicatorSetStyle(int indic, int style) + + + + + + + IndicatorGetStyle(int indic) -> int + + + + + + IndicatorSetForeground(int indic, Colour fore) + + + + + + + IndicatorGetForeground(int indic) -> Colour + + + + + + SetWhitespaceForeground(bool useSetting, Colour fore) + + + + + + + SetWhitespaceBackground(bool useSetting, Colour back) + + + + + + + SetStyleBits(int bits) + + + + + + GetStyleBits() -> int + + + SetLineState(int line, int state) + + + + + + + GetLineState(int line) -> int + + + + + + GetMaxLineState() -> int + + + GetCaretLineVisible() -> bool + + + SetCaretLineVisible(bool show) + + + + + + GetCaretLineBack() -> Colour + + + SetCaretLineBack(Colour back) + + + + + + StyleSetChangeable(int style, bool changeable) + + + + + + + AutoCompShow(int lenEntered, String itemList) + + + + + + + AutoCompCancel() + + + AutoCompActive() -> bool + + + AutoCompPosStart() -> int + + + AutoCompComplete() + + + AutoCompStops(String characterSet) + + + + + + AutoCompSetSeparator(int separatorCharacter) + + + + + + AutoCompGetSeparator() -> int + + + AutoCompSelect(String text) + + + + + + AutoCompSetCancelAtStart(bool cancel) + + + + + + AutoCompGetCancelAtStart() -> bool + + + AutoCompSetFillUps(String characterSet) + + + + + + AutoCompSetChooseSingle(bool chooseSingle) + + + + + + AutoCompGetChooseSingle() -> bool + + + AutoCompSetIgnoreCase(bool ignoreCase) + + + + + + AutoCompGetIgnoreCase() -> bool + + + UserListShow(int listType, String itemList) + + + + + + + AutoCompSetAutoHide(bool autoHide) + + + + + + AutoCompGetAutoHide() -> bool + + + AutoCompSetDropRestOfWord(bool dropRestOfWord) + + + + + + AutoCompGetDropRestOfWord() -> bool + + + RegisterImage(int type, Bitmap bmp) + + + + + + + ClearRegisteredImages() + + + AutoCompGetTypeSeparator() -> int + + + AutoCompSetTypeSeparator(int separatorCharacter) + + + + + + SetIndent(int indentSize) + + + + + + GetIndent() -> int + + + SetUseTabs(bool useTabs) + + + + + + GetUseTabs() -> bool + + + SetLineIndentation(int line, int indentSize) + + + + + + + GetLineIndentation(int line) -> int + + + + + + GetLineIndentPosition(int line) -> int + + + + + + GetColumn(int pos) -> int + + + + + + SetUseHorizontalScrollBar(bool show) + + + + + + GetUseHorizontalScrollBar() -> bool + + + SetIndentationGuides(bool show) + + + + + + GetIndentationGuides() -> bool + + + SetHighlightGuide(int column) + + + + + + GetHighlightGuide() -> int + + + GetLineEndPosition(int line) -> int + + + + + + GetCodePage() -> int + + + GetCaretForeground() -> Colour + + + GetReadOnly() -> bool + + + SetCurrentPos(int pos) + + + + + + SetSelectionStart(int pos) + + + + + + GetSelectionStart() -> int + + + SetSelectionEnd(int pos) + + + + + + GetSelectionEnd() -> int + + + SetPrintMagnification(int magnification) + + + + + + GetPrintMagnification() -> int + + + SetPrintColourMode(int mode) + + + + + + GetPrintColourMode() -> int + + + FindText(int minPos, int maxPos, String text, int flags=0) -> int + + + + + + + + + FormatRange(bool doDraw, int startPos, int endPos, DC draw, DC target, + Rect renderRect, Rect pageRect) -> int + + + + + + + + + + + + GetFirstVisibleLine() -> int + + + GetLine(int line) -> String + + + + + + GetLineCount() -> int + + + SetMarginLeft(int pixelWidth) + + + + + + GetMarginLeft() -> int + + + SetMarginRight(int pixelWidth) + + + + + + GetMarginRight() -> int + + + GetModify() -> bool + + + SetSelection(int start, int end) + + + + + + + GetSelectedText() -> String + + + GetTextRange(int startPos, int endPos) -> String + + + + + + + HideSelection(bool normal) + + + + + + LineFromPosition(int pos) -> int + + + + + + PositionFromLine(int line) -> int + + + + + + LineScroll(int columns, int lines) + + + + + + + EnsureCaretVisible() + + + ReplaceSelection(String text) + + + + + + SetReadOnly(bool readOnly) + + + + + + CanPaste() -> bool + + + CanUndo() -> bool + + + EmptyUndoBuffer() + + + Undo() + + + Cut() + + + Copy() + + + Paste() + + + Clear() + + + SetText(String text) + + + + + + GetText() -> String + + + GetTextLength() -> int + + + SetOvertype(bool overtype) + + + + + + GetOvertype() -> bool + + + SetCaretWidth(int pixelWidth) + + + + + + GetCaretWidth() -> int + + + SetTargetStart(int pos) + + + + + + GetTargetStart() -> int + + + SetTargetEnd(int pos) + + + + + + GetTargetEnd() -> int + + + ReplaceTarget(String text) -> int + + + + + + ReplaceTargetRE(String text) -> int + + + + + + SearchInTarget(String text) -> int + + + + + + SetSearchFlags(int flags) + + + + + + GetSearchFlags() -> int + + + CallTipShow(int pos, String definition) + + + + + + + CallTipCancel() + + + CallTipActive() -> bool + + + CallTipPosAtStart() -> int + + + CallTipSetHighlight(int start, int end) + + + + + + + CallTipSetBackground(Colour back) + + + + + + CallTipSetForeground(Colour fore) + + + + + + CallTipSetForegroundHighlight(Colour fore) + + + + + + VisibleFromDocLine(int line) -> int + + + + + + DocLineFromVisible(int lineDisplay) -> int + + + + + + SetFoldLevel(int line, int level) + + + + + + + GetFoldLevel(int line) -> int + + + + + + GetLastChild(int line, int level) -> int + + + + + + + GetFoldParent(int line) -> int + + + + + + ShowLines(int lineStart, int lineEnd) + + + + + + + HideLines(int lineStart, int lineEnd) + + + + + + + GetLineVisible(int line) -> bool + + + + + + SetFoldExpanded(int line, bool expanded) + + + + + + + GetFoldExpanded(int line) -> bool + + + + + + ToggleFold(int line) + + + + + + EnsureVisible(int line) + + + + + + SetFoldFlags(int flags) + + + + + + EnsureVisibleEnforcePolicy(int line) + + + + + + SetTabIndents(bool tabIndents) + + + + + + GetTabIndents() -> bool + + + SetBackSpaceUnIndents(bool bsUnIndents) + + + + + + GetBackSpaceUnIndents() -> bool + + + SetMouseDwellTime(int periodMilliseconds) + + + + + + GetMouseDwellTime() -> int + + + WordStartPosition(int pos, bool onlyWordCharacters) -> int + + + + + + + WordEndPosition(int pos, bool onlyWordCharacters) -> int + + + + + + + SetWrapMode(int mode) + + + + + + GetWrapMode() -> int + + + SetLayoutCache(int mode) + + + + + + GetLayoutCache() -> int + + + SetScrollWidth(int pixelWidth) + + + + + + GetScrollWidth() -> int + + + TextWidth(int style, String text) -> int + + + + + + + SetEndAtLastLine(bool endAtLastLine) + + + + + + GetEndAtLastLine() -> int + + + TextHeight(int line) -> int + + + + + + SetUseVerticalScrollBar(bool show) + + + + + + GetUseVerticalScrollBar() -> bool + + + AppendText(int length, String text) + + + + + + + GetTwoPhaseDraw() -> bool + + + SetTwoPhaseDraw(bool twoPhase) + + + + + + TargetFromSelection() + + + LinesJoin() + + + LinesSplit(int pixelWidth) + + + + + + SetFoldMarginColour(bool useSetting, Colour back) + + + + + + + SetFoldMarginHiColour(bool useSetting, Colour fore) + + + + + + + LineDuplicate() + + + HomeDisplay() + + + HomeDisplayExtend() + + + LineEndDisplay() + + + LineEndDisplayExtend() + + + LineCopy() + + + MoveCaretInsideView() + + + LineLength(int line) -> int + + + + + + BraceHighlight(int pos1, int pos2) + + + + + + + BraceBadLight(int pos) + + + + + + BraceMatch(int pos) -> int + + + + + + GetViewEOL() -> bool + + + SetViewEOL(bool visible) + + + + + + GetDocPointer() -> void + + + SetDocPointer(void docPointer) + + + + + + SetModEventMask(int mask) + + + + + + GetEdgeColumn() -> int + + + SetEdgeColumn(int column) + + + + + + GetEdgeMode() -> int + + + SetEdgeMode(int mode) + + + + + + GetEdgeColour() -> Colour + + + SetEdgeColour(Colour edgeColour) + + + + + + SearchAnchor() + + + SearchNext(int flags, String text) -> int + + + + + + + SearchPrev(int flags, String text) -> int + + + + + + + LinesOnScreen() -> int + + + UsePopUp(bool allowPopUp) + + + + + + SelectionIsRectangle() -> bool + + + SetZoom(int zoom) + + + + + + GetZoom() -> int + + + CreateDocument() -> void + + + AddRefDocument(void docPointer) + + + + + + ReleaseDocument(void docPointer) + + + + + + GetModEventMask() -> int + + + SetSTCFocus(bool focus) + + + + + + GetSTCFocus() -> bool + + + SetStatus(int statusCode) + + + + + + GetStatus() -> int + + + SetMouseDownCaptures(bool captures) + + + + + + GetMouseDownCaptures() -> bool + + + SetSTCCursor(int cursorType) + + + + + + GetSTCCursor() -> int + + + SetControlCharSymbol(int symbol) + + + + + + GetControlCharSymbol() -> int + + + WordPartLeft() + + + WordPartLeftExtend() + + + WordPartRight() + + + WordPartRightExtend() + + + SetVisiblePolicy(int visiblePolicy, int visibleSlop) + + + + + + + DelLineLeft() + + + DelLineRight() + + + SetXOffset(int newOffset) + + + + + + GetXOffset() -> int + + + ChooseCaretX() + + + SetXCaretPolicy(int caretPolicy, int caretSlop) + + + + + + + SetYCaretPolicy(int caretPolicy, int caretSlop) + + + + + + + SetPrintWrapMode(int mode) + + + + + + GetPrintWrapMode() -> int + + + SetHotspotActiveForeground(bool useSetting, Colour fore) + + + + + + + SetHotspotActiveBackground(bool useSetting, Colour back) + + + + + + + SetHotspotActiveUnderline(bool underline) + + + + + + PositionBefore(int pos) -> int + + + + + + PositionAfter(int pos) -> int + + + + + + CopyRange(int start, int end) + + + + + + + CopyText(int length, String text) + + + + + + + StartRecord() + + + StopRecord() + + + SetLexer(int lexer) + + + + + + GetLexer() -> int + + + Colourise(int start, int end) + + + + + + + SetProperty(String key, String value) + + + + + + + SetKeyWords(int keywordSet, String keyWords) + + + + + + + SetLexerLanguage(String language) + + + + + + GetCurrentLine() -> int + + + StyleSetSpec(int styleNum, String spec) + + + + + + + StyleSetFont(int styleNum, Font font) + + + + + + + StyleSetFontAttr(int styleNum, int size, String faceName, bool bold, + bool italic, bool underline) + + + + + + + + + + + CmdKeyExecute(int cmd) + + + + + + SetMargins(int left, int right) + + + + + + + GetSelection(int OUTPUT, int OUTPUT) + + + + + + + PointFromPosition(int pos) -> Point + + + + + + ScrollToLine(int line) + + + + + + ScrollToColumn(int column) + + + + + + SendMsg(int msg, long wp=0, long lp=0) -> long + + + + + + + + SetVScrollBar(wxScrollBar bar) + + + + + + SetHScrollBar(wxScrollBar bar) + + + + + + GetLastKeydownProcessed() -> bool + + + SetLastKeydownProcessed(bool val) + + + + + + SaveFile(String filename) -> bool + + + + + + LoadFile(String filename) -> bool + + + + + + DoDragOver(int x, int y, wxDragResult def) -> wxDragResult + + + + + + + + DoDropText(long x, long y, String data) -> bool + + + + + + + + + + + __init__(wxEventType commandType=0, int id=0) -> StyledTextEvent + + + + + + + __del__() + + + SetPosition(int pos) + + + + + + SetKey(int k) + + + + + + SetModifiers(int m) + + + + + + SetModificationType(int t) + + + + + + SetText(String t) + + + + + + SetLength(int len) + + + + + + SetLinesAdded(int num) + + + + + + SetLine(int val) + + + + + + SetFoldLevelNow(int val) + + + + + + SetFoldLevelPrev(int val) + + + + + + SetMargin(int val) + + + + + + SetMessage(int val) + + + + + + SetWParam(int val) + + + + + + SetLParam(int val) + + + + + + SetListType(int val) + + + + + + SetX(int val) + + + + + + SetY(int val) + + + + + + SetDragText(String val) + + + + + + SetDragAllowMove(bool val) + + + + + + SetDragResult(wxDragResult val) + + + + + + GetPosition() -> int + + + GetKey() -> int + + + GetModifiers() -> int + + + GetModificationType() -> int + + + GetText() -> String + + + GetLength() -> int + + + GetLinesAdded() -> int + + + GetLine() -> int + + + GetFoldLevelNow() -> int + + + GetFoldLevelPrev() -> int + + + GetMargin() -> int + + + GetMessage() -> int + + + GetWParam() -> int + + + GetLParam() -> int + + + GetListType() -> int + + + GetX() -> int + + + GetY() -> int + + + GetDragText() -> String + + + GetDragAllowMove() -> bool + + + GetDragResult() -> wxDragResult + + + GetShift() -> bool + + + GetControl() -> bool + + + GetAlt() -> bool + + + Clone() -> Event + + + +EVT_STC_CHANGE = wx.PyEventBinder( wxEVT_STC_CHANGE, 1 ) +EVT_STC_STYLENEEDED = wx.PyEventBinder( wxEVT_STC_STYLENEEDED, 1 ) +EVT_STC_CHARADDED = wx.PyEventBinder( wxEVT_STC_CHARADDED, 1 ) +EVT_STC_SAVEPOINTREACHED = wx.PyEventBinder( wxEVT_STC_SAVEPOINTREACHED, 1 ) +EVT_STC_SAVEPOINTLEFT = wx.PyEventBinder( wxEVT_STC_SAVEPOINTLEFT, 1 ) +EVT_STC_ROMODIFYATTEMPT = wx.PyEventBinder( wxEVT_STC_ROMODIFYATTEMPT, 1 ) +EVT_STC_KEY = wx.PyEventBinder( wxEVT_STC_KEY, 1 ) +EVT_STC_DOUBLECLICK = wx.PyEventBinder( wxEVT_STC_DOUBLECLICK, 1 ) +EVT_STC_UPDATEUI = wx.PyEventBinder( wxEVT_STC_UPDATEUI, 1 ) +EVT_STC_MODIFIED = wx.PyEventBinder( wxEVT_STC_MODIFIED, 1 ) +EVT_STC_MACRORECORD = wx.PyEventBinder( wxEVT_STC_MACRORECORD, 1 ) +EVT_STC_MARGINCLICK = wx.PyEventBinder( wxEVT_STC_MARGINCLICK, 1 ) +EVT_STC_NEEDSHOWN = wx.PyEventBinder( wxEVT_STC_NEEDSHOWN, 1 ) +EVT_STC_POSCHANGED = wx.PyEventBinder( wxEVT_STC_POSCHANGED, 1 ) +EVT_STC_PAINTED = wx.PyEventBinder( wxEVT_STC_PAINTED, 1 ) +EVT_STC_USERLISTSELECTION = wx.PyEventBinder( wxEVT_STC_USERLISTSELECTION, 1 ) +EVT_STC_URIDROPPED = wx.PyEventBinder( wxEVT_STC_URIDROPPED, 1 ) +EVT_STC_DWELLSTART = wx.PyEventBinder( wxEVT_STC_DWELLSTART, 1 ) +EVT_STC_DWELLEND = wx.PyEventBinder( wxEVT_STC_DWELLEND, 1 ) +EVT_STC_START_DRAG = wx.PyEventBinder( wxEVT_STC_START_DRAG, 1 ) +EVT_STC_DRAG_OVER = wx.PyEventBinder( wxEVT_STC_DRAG_OVER, 1 ) +EVT_STC_DO_DROP = wx.PyEventBinder( wxEVT_STC_DO_DROP, 1 ) +EVT_STC_ZOOM = wx.PyEventBinder( wxEVT_STC_ZOOM, 1 ) +EVT_STC_HOTSPOT_CLICK = wx.PyEventBinder( wxEVT_STC_HOTSPOT_CLICK, 1 ) +EVT_STC_HOTSPOT_DCLICK = wx.PyEventBinder( wxEVT_STC_HOTSPOT_DCLICK, 1 ) +EVT_STC_CALLTIP_CLICK = wx.PyEventBinder( wxEVT_STC_CALLTIP_CLICK, 1 ) + + + + wx = core + +#--------------------------------------------------------------------------- + + + + + __init__(String filemask, int flags=XRC_USE_LOCALE) -> XmlResource + + + + + + + EmptyXmlResource(int flags=XRC_USE_LOCALE) -> XmlResource + + + + + + __del__() + + + Load(String filemask) -> bool + + + + + + LoadFromString(String data) -> bool + + + + + + InitAllHandlers() + + + AddHandler(XmlResourceHandler handler) + + + + + + InsertHandler(XmlResourceHandler handler) + + + + + + ClearHandlers() + + + XmlResource.AddSubclassFactory(XmlSubclassFactory factory) + + + + + + LoadMenu(String name) -> Menu + + + + + + LoadMenuBar(String name) -> MenuBar + + + + + + LoadMenuBarOnFrame(Window parent, String name) -> MenuBar + + + + + + + LoadToolBar(Window parent, String name) -> wxToolBar + + + + + + + LoadDialog(Window parent, String name) -> wxDialog + + + + + + + LoadOnDialog(wxDialog dlg, Window parent, String name) -> bool + + + + + + + + LoadPanel(Window parent, String name) -> wxPanel + + + + + + + LoadOnPanel(wxPanel panel, Window parent, String name) -> bool + + + + + + + + LoadFrame(Window parent, String name) -> wxFrame + + + + + + + LoadOnFrame(wxFrame frame, Window parent, String name) -> bool + + + + + + + + LoadObject(Window parent, String name, String classname) -> Object + + + + + + + + LoadOnObject(Object instance, Window parent, String name, String classname) -> bool + + + + + + + + + LoadBitmap(String name) -> Bitmap + + + + + + LoadIcon(String name) -> Icon + + + + + + AttachUnknownControl(String name, Window control, Window parent=None) -> bool + + + + + + + + XmlResource.GetXRCID(String str_id) -> int + + + + + + GetVersion() -> long + + + CompareVersion(int major, int minor, int release, int revision) -> int + + + + + + + + + XmlResource.Get() -> XmlResource + + + XmlResource.Set(XmlResource res) -> XmlResource + + + + + + GetFlags() -> int + + + SetFlags(int flags) + + + + + + +def XRCID(str_id): + return XmlResource_GetXRCID(str_id) + +def XRCCTRL(window, str_id, *ignoreargs): + return window.FindWindowById(XRCID(str_id)) + + +#--------------------------------------------------------------------------- + + + + __init__() -> XmlSubclassFactory + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + +#--------------------------------------------------------------------------- + + + + __init__(String name=EmptyString, String value=EmptyString, + XmlProperty next=None) -> XmlProperty + + + + + + + + GetName() -> String + + + GetValue() -> String + + + GetNext() -> XmlProperty + + + SetName(String name) + + + + + + SetValue(String value) + + + + + + SetNext(XmlProperty next) + + + + + + + + __init__(XmlNode parent=None, int type=0, String name=EmptyString, + String content=EmptyString, XmlProperty props=None, + XmlNode next=None) -> XmlNode + + + + + + + + + + + XmlNodeEasy(int type, String name, String content=EmptyString) -> XmlNode + + + + + + + + __del__() + + + AddChild(XmlNode child) + + + + + + InsertChild(XmlNode child, XmlNode before_node) + + + + + + + RemoveChild(XmlNode child) -> bool + + + + + + AddProperty(XmlProperty prop) + + + + + + AddPropertyName(String name, String value) + + + + + + + DeleteProperty(String name) -> bool + + + + + + GetType() -> int + + + GetName() -> String + + + GetContent() -> String + + + GetParent() -> XmlNode + + + GetNext() -> XmlNode + + + GetChildren() -> XmlNode + + + GetProperties() -> XmlProperty + + + GetPropVal(String propName, String defaultVal) -> String + + + + + + + HasProp(String propName) -> bool + + + + + + SetType(int type) + + + + + + SetName(String name) + + + + + + SetContent(String con) + + + + + + SetParent(XmlNode parent) + + + + + + SetNext(XmlNode next) + + + + + + SetChildren(XmlNode child) + + + + + + SetProperties(XmlProperty prop) + + + + + + + + + __init__(String filename, String encoding=UTF8String) -> XmlDocument + + + + + + + XmlDocumentFromStream(InputStream stream, String encoding=UTF8String) -> XmlDocument + + + + + + + EmptyXmlDocument() -> XmlDocument + + + __del__() + + + Load(String filename, String encoding=UTF8String) -> bool + + + + + + + LoadFromStream(InputStream stream, String encoding=UTF8String) -> bool + + + + + + + Save(String filename) -> bool + + + + + + SaveToStream(OutputStream stream) -> bool + + + + + + IsOk() -> bool + + + GetRoot() -> XmlNode + + + GetVersion() -> String + + + GetFileEncoding() -> String + + + SetRoot(XmlNode node) + + + + + + SetVersion(String version) + + + + + + SetFileEncoding(String encoding) + + + + + + +#--------------------------------------------------------------------------- + + + + + __init__() -> XmlResourceHandler + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + CreateResource(XmlNode node, Object parent, Object instance) -> Object + + + + + + + + SetParentResource(XmlResource res) + + + + + + GetResource() -> XmlResource + + + GetNode() -> XmlNode + + + GetClass() -> String + + + GetParent() -> Object + + + GetInstance() -> Object + + + GetParentAsWindow() -> Window + + + GetInstanceAsWindow() -> Window + + + IsOfClass(XmlNode node, String classname) -> bool + + + + + + + GetNodeContent(XmlNode node) -> String + + + + + + HasParam(String param) -> bool + + + + + + GetParamNode(String param) -> XmlNode + + + + + + GetParamValue(String param) -> String + + + + + + AddStyle(String name, int value) + + + + + + + AddWindowStyles() + + + GetStyle(String param=StyleString, int defaults=0) -> int + + + + + + + GetText(String param, bool translate=True) -> String + + + + + + + GetID() -> int + + + GetName() -> String + + + GetBool(String param, bool defaultv=False) -> bool + + + + + + + GetLong(String param, long defaultv=0) -> long + + + + + + + GetColour(String param) -> Colour + + + + + + GetSize(String param=SizeString) -> Size + + + + + + GetPosition(String param=PosString) -> Point + + + + + + GetDimension(String param, int defaultv=0) -> int + + + + + + + GetBitmap(String param=BitmapString, wxArtClient defaultArtClient=wxART_OTHER, + Size size=DefaultSize) -> Bitmap + + + + + + + + GetIcon(String param=IconString, wxArtClient defaultArtClient=wxART_OTHER, + Size size=DefaultSize) -> Icon + + + + + + + + GetFont(String param=FontString) -> Font + + + + + + SetupWindow(Window wnd) + + + + + + CreateChildren(Object parent, bool this_hnd_only=False) + + + + + + + CreateChildrenPrivately(Object parent, XmlNode rootnode=None) + + + + + + + CreateResFromNode(XmlNode node, Object parent, Object instance=None) -> Object + + + + + + + + GetCurFileSystem() -> FileSystem + + + #---------------------------------------------------------------------------- +# The global was removed in favor of static accessor functions. This is for +# backwards compatibility: + +TheXmlResource = XmlResource_Get() + + +#---------------------------------------------------------------------------- +# Create a factory for handling the subclass property of the object tag. + + +def _my_import(name): + mod = __import__(name) + components = name.split('.') + for comp in components[1:]: + mod = getattr(mod, comp) + return mod + + +class XmlSubclassFactory_Python(XmlSubclassFactory): + def __init__(self): + XmlSubclassFactory.__init__(self) + + def Create(self, className): + assert className.find('.') != -1, "Module name must be specified!" + mname = className[:className.rfind('.')] + cname = className[className.rfind('.')+1:] + module = _my_import(mname) + klass = getattr(module, cname) + inst = klass() + return inst + + +XmlResource_AddSubclassFactory(XmlSubclassFactory_Python()) + +#---------------------------------------------------------------------------- + + + + + wx = core + + + + __init__(Object target) -> DynamicSashSplitEvent + + + + + + + + + __init__(Object target) -> DynamicSashUnifyEvent + + + + + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=wxCLIP_CHILDREN|wxDS_MANAGE_SCROLLBARS|wxDS_DRAG_CORNER, + String name=DynamicSashNameStr) -> DynamicSashWindow + + + + + + + + + + + PreDynamicSashWindow() -> DynamicSashWindow + + + Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=wxCLIP_CHILDREN|wxDS_MANAGE_SCROLLBARS|wxDS_DRAG_CORNER, + String name=DynamicSashNameStr) -> bool + + + + + + + + + + + GetHScrollBar(Window child) -> ScrollBar + + + + + + GetVScrollBar(Window child) -> ScrollBar + + + + + + +EVT_DYNAMIC_SASH_SPLIT = wx.PyEventBinder( wxEVT_DYNAMIC_SASH_SPLIT, 1 ) +EVT_DYNAMIC_SASH_UNIFY = wx.PyEventBinder( wxEVT_DYNAMIC_SASH_UNIFY, 1 ) + + + + + __init__(Window parent, int id, String label, Point pos=DefaultPosition, + Size size=DefaultSize, long style=wxEL_ALLOW_NEW|wxEL_ALLOW_EDIT|wxEL_ALLOW_DELETE, + String name=EditableListBoxNameStr) -> EditableListBox + + + + + + + + + + + + SetStrings(wxArrayString strings) + + + + + + GetStrings() -> PyObject + + + GetListCtrl() -> wxListCtrl + + + GetDelButton() -> BitmapButton + + + GetNewButton() -> BitmapButton + + + GetUpButton() -> BitmapButton + + + GetDownButton() -> BitmapButton + + + GetEditButton() -> BitmapButton + + + + + + __init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize, + long style=TR_HAS_BUTTONS) -> RemotelyScrolledTreeCtrl + + + + + + + + + + HideVScrollbar() + + + AdjustRemoteScrollbars() + + + GetScrolledWindow() -> ScrolledWindow + + + ScrollToLine(int posHoriz, int posVert) + + + + + + + SetCompanionWindow(Window companion) + + + + + + GetCompanionWindow() -> Window + + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0) -> TreeCompanionWindow + + + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + GetTreeCtrl() -> RemotelyScrolledTreeCtrl + + + SetTreeCtrl(RemotelyScrolledTreeCtrl treeCtrl) + + + + + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=wxSP_3D|wxCLIP_CHILDREN) -> ThinSplitterWindow + + + + + + + + + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=0) -> SplitterScrolledWindow + + + + + + + + + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=wxLED_ALIGN_LEFT|wxLED_DRAW_FADED) -> LEDNumberCtrl + + + + + + + + + + PreLEDNumberCtrl() -> LEDNumberCtrl + + + Create(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=wxLED_ALIGN_LEFT|wxLED_DRAW_FADED) -> bool + + + + + + + + + + GetAlignment() -> int + + + GetDrawFaded() -> bool + + + GetValue() -> String + + + SetAlignment(int Alignment, bool Redraw=true) + + + + + + + SetDrawFaded(bool DrawFaded, bool Redraw=true) + + + + + + + SetValue(String Value, bool Redraw=true) + + + + + + + + + + __init__(String text=EmptyString, int image=-1, size_t width=100, + int alignment=TL_ALIGN_LEFT) -> TreeListColumnInfo + + + + + + + + + GetAlignment() -> int + + + GetText() -> String + + + GetImage() -> int + + + GetSelectedImage() -> int + + + GetWidth() -> size_t + + + SetAlignment(int alignment) + + + + + + SetText(String text) + + + + + + SetImage(int image) + + + + + + SetSelectedImage(int image) + + + + + + SetWidth(size_t with) + + + + + + + + + __init__(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=TR_DEFAULT_STYLE, + Validator validator=DefaultValidator, + String name=TreeListCtrlNameStr) -> TreeListCtrl + + + + + + + + + + + + PreTreeListCtrl() -> TreeListCtrl + + + Create(Window parent, int id=-1, Point pos=DefaultPosition, + Size size=DefaultSize, long style=TR_DEFAULT_STYLE, + Validator validator=DefaultValidator, + String name=TreeListCtrlNameStr) -> bool + + + + + + + + + + + + _setCallbackInfo(PyObject self, PyObject _class) + + + + + + + GetCount() -> size_t + + + GetIndent() -> unsigned int + + + SetIndent(unsigned int indent) + + + + + + GetSpacing() -> unsigned int + + + SetSpacing(unsigned int spacing) + + + + + + GetLineSpacing() -> unsigned int + + + SetLineSpacing(unsigned int spacing) + + + + + + GetImageList() -> ImageList + + + GetStateImageList() -> ImageList + + + GetButtonsImageList() -> ImageList + + + SetImageList(ImageList imageList) + + + + + + SetStateImageList(ImageList imageList) + + + + + + SetButtonsImageList(ImageList imageList) + + + + + + AssignImageList(ImageList imageList) + + + + + + AssignStateImageList(ImageList imageList) + + + + + + AssignButtonsImageList(ImageList imageList) + + + + + + AddColumn(String text) + + + + + + AddColumnInfo(TreeListColumnInfo col) + + + + + + InsertColumn(size_t before, String text) + + + + + + + InsertColumnInfo(size_t before, TreeListColumnInfo col) + + + + + + + RemoveColumn(size_t column) + + + + + + GetColumnCount() -> size_t + + + SetColumnWidth(size_t column, size_t width) + + + + + + + GetColumnWidth(size_t column) -> int + + + + + + SetMainColumn(size_t column) + + + + + + GetMainColumn() -> size_t + + + SetColumnText(size_t column, String text) + + + + + + + GetColumnText(size_t column) -> String + + + + + + SetColumn(size_t column, TreeListColumnInfo info) + + + + + + + GetColumn(size_t column) -> TreeListColumnInfo + + + + + + SetColumnAlignment(size_t column, int align) + + + + + + + GetColumnAlignment(size_t column) -> int + + + + + + SetColumnImage(size_t column, int image) + + + + + + + GetColumnImage(size_t column) -> int + + + + + + GetItemText(TreeItemId item, int column=-1) -> String + + + + + + + GetItemImage(TreeItemId item, int column=-1, int which=TreeItemIcon_Normal) -> int + + + + + + + + SetItemText(TreeItemId item, String text, int column=-1) + + + + + + + + SetItemImage(TreeItemId item, int image, int column=-1, int which=TreeItemIcon_Normal) + + + + + + + + + GetItemData(TreeItemId item) -> TreeItemData + + + + + + SetItemData(TreeItemId item, TreeItemData data) + + + + + + + GetItemPyData(TreeItemId item) -> PyObject + + + + + + SetItemPyData(TreeItemId item, PyObject obj) + + + + + + + SetItemHasChildren(TreeItemId item, bool has=True) + + + + + + + SetItemBold(TreeItemId item, bool bold=True) + + + + + + + SetItemTextColour(TreeItemId item, Colour col) + + + + + + + SetItemBackgroundColour(TreeItemId item, Colour col) + + + + + + + SetItemFont(TreeItemId item, Font font) + + + + + + + GetItemBold(TreeItemId item) -> bool + + + + + + GetItemTextColour(TreeItemId item) -> Colour + + + + + + GetItemBackgroundColour(TreeItemId item) -> Colour + + + + + + GetItemFont(TreeItemId item) -> Font + + + + + + IsVisible(TreeItemId item) -> bool + + + + + + ItemHasChildren(TreeItemId item) -> bool + + + + + + IsExpanded(TreeItemId item) -> bool + + + + + + IsSelected(TreeItemId item) -> bool + + + + + + IsBold(TreeItemId item) -> bool + + + + + + GetChildrenCount(TreeItemId item, bool recursively=True) -> size_t + + + + + + + GetRootItem() -> TreeItemId + + + GetSelection() -> TreeItemId + + + GetSelections() -> PyObject + + + GetItemParent(TreeItemId item) -> TreeItemId + + + + + + GetFirstChild(TreeItemId item) -> PyObject + + + + + + GetNextChild(TreeItemId item, long cookie) -> PyObject + + + + + + + GetLastChild(TreeItemId item) -> TreeItemId + + + + + + GetNextSibling(TreeItemId item) -> TreeItemId + + + + + + GetPrevSibling(TreeItemId item) -> TreeItemId + + + + + + GetFirstVisibleItem() -> TreeItemId + + + GetNextVisible(TreeItemId item) -> TreeItemId + + + + + + GetPrevVisible(TreeItemId item) -> TreeItemId + + + + + + GetNext(TreeItemId item) -> TreeItemId + + + + + + AddRoot(String text, int image=-1, int selectedImage=-1, TreeItemData data=None) -> TreeItemId + + + + + + + + + PrependItem(TreeItemId parent, String text, int image=-1, int selectedImage=-1, + TreeItemData data=None) -> TreeItemId + + + + + + + + + + InsertItem(TreeItemId parent, TreeItemId idPrevious, String text, + int image=-1, int selectedImage=-1, TreeItemData data=None) -> TreeItemId + + + + + + + + + + + InsertItemBefore(TreeItemId parent, size_t index, String text, int image=-1, + int selectedImage=-1, TreeItemData data=None) -> TreeItemId + + + + + + + + + + + AppendItem(TreeItemId parent, String text, int image=-1, int selectedImage=-1, + TreeItemData data=None) -> TreeItemId + + + + + + + + + + Delete(TreeItemId item) + + + + + + DeleteChildren(TreeItemId item) + + + + + + DeleteAllItems() + + + Expand(TreeItemId item) + + + + + + ExpandAll(TreeItemId item) + + + + + + Collapse(TreeItemId item) + + + + + + CollapseAndReset(TreeItemId item) + + + + + + Toggle(TreeItemId item) + + + + + + Unselect() + + + UnselectAll() + + + SelectItem(TreeItemId item, bool unselect_others=True, bool extended_select=False) + + + + + + + + EnsureVisible(TreeItemId item) + + + + + + ScrollTo(TreeItemId item) + + + + + + HitTest(Point point, int OUTPUT, int OUTPUT) -> TreeItemId + + + + + + + + GetBoundingRect(TreeItemId item, bool textOnly=False) -> PyObject + + + + + + + EditLabel(TreeItemId item) + + + + + + Edit(TreeItemId item) + + + + + + SortChildren(TreeItemId item) + + + + + + GetItemSelectedImage(TreeItemId item) -> int + + + + + + SetItemSelectedImage(TreeItemId item, int image) + + + + + + + GetHeaderWindow() -> Window + + + GetMainWindow() -> Window + + +