if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DynamicSashSplitEvent
_gizmos.DynamicSashSplitEvent_swigregister(DynamicSashSplitEventPtr)
+cvar = _gizmos.cvar
+DynamicSashNameStr = cvar.DynamicSashNameStr
+EditableListBoxNameStr = cvar.EditableListBoxNameStr
+TreeListCtrlNameStr = cvar.TreeListCtrlNameStr
class DynamicSashUnifyEvent(core.CommandEvent):
def __repr__(self):
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxCLIP_CHILDREN|wxDS_MANAGE_SCROLLBARS|wxDS_DRAG_CORNER,
- wxString name=wxPyDynamicSashNameStr) -> DynamicSashWindow
+ String name=DynamicSashNameStr) -> DynamicSashWindow
"""
newobj = _gizmos.new_DynamicSashWindow(*args, **kwargs)
self.this = newobj.this
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxCLIP_CHILDREN|wxDS_MANAGE_SCROLLBARS|wxDS_DRAG_CORNER,
- wxString name=wxPyDynamicSashNameStr) -> bool
+ String name=DynamicSashNameStr) -> bool
"""
return _gizmos.DynamicSashWindow_Create(*args, **kwargs)
return "<%s.%s; proxy of C++ wxEditableListBox instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString label, Point pos=DefaultPosition,
+ __init__(Window parent, int id, String label, Point pos=DefaultPosition,
Size size=DefaultSize, long style=wxEL_ALLOW_NEW|wxEL_ALLOW_EDIT|wxEL_ALLOW_DELETE,
- wxString name=wxPyEditableListBoxNameStr) -> EditableListBox
+ String name=EditableListBoxNameStr) -> EditableListBox
"""
newobj = _gizmos.new_EditableListBox(*args, **kwargs)
self.this = newobj.this
return _gizmos.LEDNumberCtrl_Create(*args, **kwargs)
def GetAlignment(*args, **kwargs):
- """GetAlignment() -> wxLEDValueAlign"""
+ """GetAlignment() -> int"""
return _gizmos.LEDNumberCtrl_GetAlignment(*args, **kwargs)
def GetDrawFaded(*args, **kwargs):
return _gizmos.LEDNumberCtrl_GetDrawFaded(*args, **kwargs)
def GetValue(*args, **kwargs):
- """GetValue() -> wxString"""
+ """GetValue() -> String"""
return _gizmos.LEDNumberCtrl_GetValue(*args, **kwargs)
def SetAlignment(*args, **kwargs):
- """SetAlignment(wxLEDValueAlign Alignment, bool Redraw=true)"""
+ """SetAlignment(int Alignment, bool Redraw=true)"""
return _gizmos.LEDNumberCtrl_SetAlignment(*args, **kwargs)
def SetDrawFaded(*args, **kwargs):
return _gizmos.LEDNumberCtrl_SetDrawFaded(*args, **kwargs)
def SetValue(*args, **kwargs):
- """SetValue(wxString Value, bool Redraw=true)"""
+ """SetValue(String Value, bool Redraw=true)"""
return _gizmos.LEDNumberCtrl_SetValue(*args, **kwargs)
return "<%s.%s; proxy of C++ wxTreeListColumnInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(wxString text=wxPyEmptyString, int image=-1, size_t width=100,
- wxTreeListColumnAlign alignment=TL_ALIGN_LEFT) -> TreeListColumnInfo
+ __init__(String text=EmptyString, int image=-1, size_t width=100,
+ int alignment=TL_ALIGN_LEFT) -> TreeListColumnInfo
"""
newobj = _gizmos.new_TreeListColumnInfo(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetAlignment(*args, **kwargs):
- """GetAlignment() -> wxTreeListColumnAlign"""
+ """GetAlignment() -> int"""
return _gizmos.TreeListColumnInfo_GetAlignment(*args, **kwargs)
def GetText(*args, **kwargs):
- """GetText() -> wxString"""
+ """GetText() -> String"""
return _gizmos.TreeListColumnInfo_GetText(*args, **kwargs)
def GetImage(*args, **kwargs):
return _gizmos.TreeListColumnInfo_GetWidth(*args, **kwargs)
def SetAlignment(*args, **kwargs):
- """SetAlignment(wxTreeListColumnAlign alignment)"""
+ """SetAlignment(int alignment)"""
return _gizmos.TreeListColumnInfo_SetAlignment(*args, **kwargs)
def SetText(*args, **kwargs):
- """SetText(wxString text)"""
+ """SetText(String text)"""
return _gizmos.TreeListColumnInfo_SetText(*args, **kwargs)
def SetImage(*args, **kwargs):
__init__(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=TR_DEFAULT_STYLE,
Validator validator=DefaultValidator,
- wxString name=wxPyTreeListCtrlNameStr) -> TreeListCtrl
+ String name=TreeListCtrlNameStr) -> TreeListCtrl
"""
newobj = _gizmos.new_TreeListCtrl(*args, **kwargs)
self.this = newobj.this
Create(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=TR_DEFAULT_STYLE,
Validator validator=DefaultValidator,
- wxString name=wxPyTreeListCtrlNameStr) -> bool
+ String name=TreeListCtrlNameStr) -> bool
"""
return _gizmos.TreeListCtrl_Create(*args, **kwargs)
return _gizmos.TreeListCtrl_SetLineSpacing(*args, **kwargs)
def GetImageList(*args, **kwargs):
- """GetImageList() -> wxImageList"""
+ """GetImageList() -> ImageList"""
return _gizmos.TreeListCtrl_GetImageList(*args, **kwargs)
def GetStateImageList(*args, **kwargs):
- """GetStateImageList() -> wxImageList"""
+ """GetStateImageList() -> ImageList"""
return _gizmos.TreeListCtrl_GetStateImageList(*args, **kwargs)
def GetButtonsImageList(*args, **kwargs):
- """GetButtonsImageList() -> wxImageList"""
+ """GetButtonsImageList() -> ImageList"""
return _gizmos.TreeListCtrl_GetButtonsImageList(*args, **kwargs)
def SetImageList(*args, **kwargs):
- """SetImageList(wxImageList imageList)"""
+ """SetImageList(ImageList imageList)"""
return _gizmos.TreeListCtrl_SetImageList(*args, **kwargs)
def SetStateImageList(*args, **kwargs):
- """SetStateImageList(wxImageList imageList)"""
+ """SetStateImageList(ImageList imageList)"""
return _gizmos.TreeListCtrl_SetStateImageList(*args, **kwargs)
def SetButtonsImageList(*args, **kwargs):
- """SetButtonsImageList(wxImageList imageList)"""
+ """SetButtonsImageList(ImageList imageList)"""
return _gizmos.TreeListCtrl_SetButtonsImageList(*args, **kwargs)
def AssignImageList(*args, **kwargs):
- """AssignImageList(wxImageList imageList)"""
+ """AssignImageList(ImageList imageList)"""
val = _gizmos.TreeListCtrl_AssignImageList(*args, **kwargs)
args[1].thisown = 0
return val
def AssignStateImageList(*args, **kwargs):
- """AssignStateImageList(wxImageList imageList)"""
+ """AssignStateImageList(ImageList imageList)"""
val = _gizmos.TreeListCtrl_AssignStateImageList(*args, **kwargs)
args[1].thisown = 0
return val
def AssignButtonsImageList(*args, **kwargs):
- """AssignButtonsImageList(wxImageList imageList)"""
+ """AssignButtonsImageList(ImageList imageList)"""
val = _gizmos.TreeListCtrl_AssignButtonsImageList(*args, **kwargs)
args[1].thisown = 0
return val
def AddColumn(*args, **kwargs):
- """AddColumn(wxString text)"""
+ """AddColumn(String text)"""
return _gizmos.TreeListCtrl_AddColumn(*args, **kwargs)
def AddColumnInfo(*args, **kwargs):
return _gizmos.TreeListCtrl_AddColumnInfo(*args, **kwargs)
def InsertColumn(*args, **kwargs):
- """InsertColumn(size_t before, wxString text)"""
+ """InsertColumn(size_t before, String text)"""
return _gizmos.TreeListCtrl_InsertColumn(*args, **kwargs)
def InsertColumnInfo(*args, **kwargs):
return _gizmos.TreeListCtrl_GetMainColumn(*args, **kwargs)
def SetColumnText(*args, **kwargs):
- """SetColumnText(size_t column, wxString text)"""
+ """SetColumnText(size_t column, String text)"""
return _gizmos.TreeListCtrl_SetColumnText(*args, **kwargs)
def GetColumnText(*args, **kwargs):
- """GetColumnText(size_t column) -> wxString"""
+ """GetColumnText(size_t column) -> String"""
return _gizmos.TreeListCtrl_GetColumnText(*args, **kwargs)
def SetColumn(*args, **kwargs):
return _gizmos.TreeListCtrl_GetColumn(*args, **kwargs)
def SetColumnAlignment(*args, **kwargs):
- """SetColumnAlignment(size_t column, wxTreeListColumnAlign align)"""
+ """SetColumnAlignment(size_t column, int align)"""
return _gizmos.TreeListCtrl_SetColumnAlignment(*args, **kwargs)
def GetColumnAlignment(*args, **kwargs):
- """GetColumnAlignment(size_t column) -> wxTreeListColumnAlign"""
+ """GetColumnAlignment(size_t column) -> int"""
return _gizmos.TreeListCtrl_GetColumnAlignment(*args, **kwargs)
def SetColumnImage(*args, **kwargs):
return _gizmos.TreeListCtrl_GetColumnImage(*args, **kwargs)
def GetItemText(*args, **kwargs):
- """GetItemText(TreeItemId item, int column=-1) -> wxString"""
+ """GetItemText(TreeItemId item, int column=-1) -> String"""
return _gizmos.TreeListCtrl_GetItemText(*args, **kwargs)
def GetItemImage(*args, **kwargs):
- """GetItemImage(TreeItemId item, int column=-1, wxTreeItemIcon which=TreeItemIcon_Normal) -> int"""
+ """GetItemImage(TreeItemId item, int column=-1, int which=TreeItemIcon_Normal) -> int"""
return _gizmos.TreeListCtrl_GetItemImage(*args, **kwargs)
def SetItemText(*args, **kwargs):
- """SetItemText(TreeItemId item, wxString text, int column=-1)"""
+ """SetItemText(TreeItemId item, String text, int column=-1)"""
return _gizmos.TreeListCtrl_SetItemText(*args, **kwargs)
def SetItemImage(*args, **kwargs):
- """SetItemImage(TreeItemId item, int image, int column=-1, wxTreeItemIcon which=TreeItemIcon_Normal)"""
+ """SetItemImage(TreeItemId item, int image, int column=-1, int which=TreeItemIcon_Normal)"""
return _gizmos.TreeListCtrl_SetItemImage(*args, **kwargs)
def GetItemData(*args, **kwargs):
return _gizmos.TreeListCtrl_SetItemBold(*args, **kwargs)
def SetItemTextColour(*args, **kwargs):
- """SetItemTextColour(TreeItemId item, wxColour col)"""
+ """SetItemTextColour(TreeItemId item, Colour col)"""
return _gizmos.TreeListCtrl_SetItemTextColour(*args, **kwargs)
def SetItemBackgroundColour(*args, **kwargs):
- """SetItemBackgroundColour(TreeItemId item, wxColour col)"""
+ """SetItemBackgroundColour(TreeItemId item, Colour col)"""
return _gizmos.TreeListCtrl_SetItemBackgroundColour(*args, **kwargs)
def SetItemFont(*args, **kwargs):
- """SetItemFont(TreeItemId item, wxFont font)"""
+ """SetItemFont(TreeItemId item, Font font)"""
return _gizmos.TreeListCtrl_SetItemFont(*args, **kwargs)
def GetItemBold(*args, **kwargs):
return _gizmos.TreeListCtrl_GetItemBold(*args, **kwargs)
def GetItemTextColour(*args, **kwargs):
- """GetItemTextColour(TreeItemId item) -> wxColour"""
+ """GetItemTextColour(TreeItemId item) -> Colour"""
return _gizmos.TreeListCtrl_GetItemTextColour(*args, **kwargs)
def GetItemBackgroundColour(*args, **kwargs):
- """GetItemBackgroundColour(TreeItemId item) -> wxColour"""
+ """GetItemBackgroundColour(TreeItemId item) -> Colour"""
return _gizmos.TreeListCtrl_GetItemBackgroundColour(*args, **kwargs)
def GetItemFont(*args, **kwargs):
- """GetItemFont(TreeItemId item) -> wxFont"""
+ """GetItemFont(TreeItemId item) -> Font"""
return _gizmos.TreeListCtrl_GetItemFont(*args, **kwargs)
def IsVisible(*args, **kwargs):
return _gizmos.TreeListCtrl_GetNext(*args, **kwargs)
def AddRoot(*args, **kwargs):
- """
- AddRoot(wxString text, int image=-1, int selectedImage=-1,
- TreeItemData data=None) -> TreeItemId
- """
+ """AddRoot(String text, int image=-1, int selectedImage=-1, TreeItemData data=None) -> TreeItemId"""
return _gizmos.TreeListCtrl_AddRoot(*args, **kwargs)
def PrependItem(*args, **kwargs):
"""
- PrependItem(TreeItemId parent, wxString text, int image=-1, int selectedImage=-1,
+ PrependItem(TreeItemId parent, String text, int image=-1, int selectedImage=-1,
TreeItemData data=None) -> TreeItemId
"""
return _gizmos.TreeListCtrl_PrependItem(*args, **kwargs)
def InsertItem(*args, **kwargs):
"""
- InsertItem(TreeItemId parent, TreeItemId idPrevious, wxString text,
+ InsertItem(TreeItemId parent, TreeItemId idPrevious, String text,
int image=-1, int selectedImage=-1, TreeItemData data=None) -> TreeItemId
"""
return _gizmos.TreeListCtrl_InsertItem(*args, **kwargs)
def InsertItemBefore(*args, **kwargs):
"""
- InsertItemBefore(TreeItemId parent, size_t index, wxString text, int image=-1,
+ InsertItemBefore(TreeItemId parent, size_t index, String text, int image=-1,
int selectedImage=-1, TreeItemData data=None) -> TreeItemId
"""
return _gizmos.TreeListCtrl_InsertItemBefore(*args, **kwargs)
def AppendItem(*args, **kwargs):
"""
- AppendItem(TreeItemId parent, wxString text, int image=-1, int selectedImage=-1,
+ AppendItem(TreeItemId parent, String text, int image=-1, int selectedImage=-1,
TreeItemData data=None) -> TreeItemId
"""
return _gizmos.TreeListCtrl_AppendItem(*args, **kwargs)
#include "treelistctrl.h"
#include "wx/wxPython/pytree.h"
-
- static const wxString wxPyDynamicSashNameStr(wxT("dynamicSashWindow"));
- static const wxString wxPyEditableListBoxNameStr(wxT("editableListBox"));
- static const wxString wxPyTreeListCtrlNameStr(wxT("treelistctrl"));
- static const wxString wxPyEmptyString(wxT(""));
+ static const wxString wxPyDynamicSashNameStr(wxT("dynamicSashWindow"));
+ static const wxString wxPyEditableListBoxNameStr(wxT("editableListBox"));
+ static const wxString wxPyTreeListCtrlNameStr(wxT("treelistctrl"));
+ static const wxString wxPyEmptyString(wxEmptyString);
PyObject *wxEditableListBox_GetStrings(wxEditableListBox *self){
wxArrayString strings;
self->GetStrings(strings);
#ifdef __cplusplus
extern "C" {
#endif
+static int _wrap_DynamicSashNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable DynamicSashNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_DynamicSashNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyDynamicSashNameStr)->c_str(), (&wxPyDynamicSashNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyDynamicSashNameStr)->c_str(), (&wxPyDynamicSashNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_EditableListBoxNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable EditableListBoxNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_EditableListBoxNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyEditableListBoxNameStr)->c_str(), (&wxPyEditableListBoxNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyEditableListBoxNameStr)->c_str(), (&wxPyEditableListBoxNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_TreeListCtrlNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable TreeListCtrlNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_TreeListCtrlNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyTreeListCtrlNameStr)->c_str(), (&wxPyTreeListCtrlNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyTreeListCtrlNameStr)->c_str(), (&wxPyTreeListCtrlNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_DynamicSashSplitEvent(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxObject *arg1 = (wxObject *) 0 ;
}
SWIG_InstallConstants(d,swig_const_table);
+ PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
+ SWIG_addvarlink(SWIG_globals,(char*)"DynamicSashNameStr",_wrap_DynamicSashNameStr_get, _wrap_DynamicSashNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"EditableListBoxNameStr",_wrap_EditableListBoxNameStr_get, _wrap_EditableListBoxNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"TreeListCtrlNameStr",_wrap_TreeListCtrlNameStr_get, _wrap_TreeListCtrlNameStr_set);
wxPyPtrTypeMap_Add("wxTreeCompanionWindow", "wxPyTreeCompanionWindow");
return _glcanvas.GLContext_SetCurrent(*args, **kwargs)
def SetColour(*args, **kwargs):
- """SetColour(wxString colour)"""
+ """SetColour(String colour)"""
return _glcanvas.GLContext_SetColour(*args, **kwargs)
def SwapBuffers(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = GLContext
_glcanvas.GLContext_swigregister(GLContextPtr)
+cvar = _glcanvas.cvar
+GLCanvasNameStr = cvar.GLCanvasNameStr
WX_GL_RGBA = _glcanvas.WX_GL_RGBA
WX_GL_BUFFER_SIZE = _glcanvas.WX_GL_BUFFER_SIZE
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id=-1, Point pos=DefaultPosition,
- Size size=DefaultSize, long style=0, wxString name=wxPyGLCanvasNameStr,
- int attribList=None,
- wxPalette palette=wxNullPalette) -> GLCanvas
+ Size size=DefaultSize, long style=0, String name=GLCanvasNameStr,
+ int attribList=None, wxPalette palette=wxNullPalette) -> GLCanvas
"""
newobj = _glcanvas.new_GLCanvas(*args, **kwargs)
self.this = newobj.this
return _glcanvas.GLCanvas_SetCurrent(*args, **kwargs)
def SetColour(*args, **kwargs):
- """SetColour(wxString colour)"""
+ """SetColour(String colour)"""
return _glcanvas.GLCanvas_SetColour(*args, **kwargs)
def SwapBuffers(*args, **kwargs):
"""
wxGLCanvasWithContext(Window parent, GLContext shared=None, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize,
- long style=0, wxString name=wxPyGLCanvasNameStr,
+ long style=0, String name=GLCanvasNameStr,
int attribList=None, wxPalette palette=wxNullPalette) -> GLCanvas
"""
val = _glcanvas.new_wxGLCanvasWithContext(*args, **kwargs)
#include <wx/glcanvas.h>
- static const wxString wxPyGLCanvasNameStr(wxT("GLCanvas"));
- static const wxString wxPyEmptyString(wxT(""));
+ static const wxString wxPyGLCanvasNameStr(wxT("GLCanvas"));
+ static const wxString wxPyEmptyString(wxEmptyString);
#ifdef __cplusplus
extern "C" {
#endif
+static int _wrap_GLCanvasNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable GLCanvasNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_GLCanvasNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyGLCanvasNameStr)->c_str(), (&wxPyGLCanvasNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyGLCanvasNameStr)->c_str(), (&wxPyGLCanvasNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_GLContext(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
bool arg1 ;
}
SWIG_InstallConstants(d,swig_const_table);
+ PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
+ SWIG_addvarlink(SWIG_globals,(char*)"GLCanvasNameStr",_wrap_GLCanvasNameStr_get, _wrap_GLCanvasNameStr_set);
self.thisown = 1
del newobj.thisown
def SetText(*args, **kwargs):
- """SetText(wxString s)"""
+ """SetText(String s)"""
return _ogl.ShapeRegion_SetText(*args, **kwargs)
def SetFont(*args, **kwargs):
- """SetFont(wxFont f)"""
+ """SetFont(Font f)"""
return _ogl.ShapeRegion_SetFont(*args, **kwargs)
def SetMinSize(*args, **kwargs):
return _ogl.ShapeRegion_SetFormatMode(*args, **kwargs)
def SetName(*args, **kwargs):
- """SetName(wxString s)"""
+ """SetName(String s)"""
return _ogl.ShapeRegion_SetName(*args, **kwargs)
def SetColour(*args, **kwargs):
- """SetColour(wxString col)"""
+ """SetColour(String col)"""
return _ogl.ShapeRegion_SetColour(*args, **kwargs)
def GetText(*args, **kwargs):
- """GetText() -> wxString"""
+ """GetText() -> String"""
return _ogl.ShapeRegion_GetText(*args, **kwargs)
def GetFont(*args, **kwargs):
- """GetFont() -> wxFont"""
+ """GetFont() -> Font"""
return _ogl.ShapeRegion_GetFont(*args, **kwargs)
def GetMinSize(*args, **kwargs):
return _ogl.ShapeRegion_GetFormatMode(*args, **kwargs)
def GetName(*args, **kwargs):
- """GetName() -> wxString"""
+ """GetName() -> String"""
return _ogl.ShapeRegion_GetName(*args, **kwargs)
def GetColour(*args, **kwargs):
- """GetColour() -> wxString"""
+ """GetColour() -> String"""
return _ogl.ShapeRegion_GetColour(*args, **kwargs)
def GetActualColourObject(*args, **kwargs):
- """GetActualColourObject() -> wxColour"""
+ """GetActualColourObject() -> Colour"""
return _ogl.ShapeRegion_GetActualColourObject(*args, **kwargs)
def GetFormattedText(*args, **kwargs):
return _ogl.ShapeRegion_GetFormattedText(*args, **kwargs)
def GetPenColour(*args, **kwargs):
- """GetPenColour() -> wxString"""
+ """GetPenColour() -> String"""
return _ogl.ShapeRegion_GetPenColour(*args, **kwargs)
def GetPenStyle(*args, **kwargs):
return _ogl.ShapeRegion_SetPenStyle(*args, **kwargs)
def SetPenColour(*args, **kwargs):
- """SetPenColour(wxString col)"""
+ """SetPenColour(String col)"""
return _ogl.ShapeRegion_SetPenColour(*args, **kwargs)
def GetActualPen(*args, **kwargs):
return _ogl.PyShapeEvtHandler_base_OnDelete(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyShapeEvtHandler_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyShapeEvtHandler_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=False)"""
+ """base_OnDrawBranches(DC dc, bool erase=False)"""
return _ogl.PyShapeEvtHandler_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyShapeEvtHandler_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyShapeEvtHandler_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyShapeEvtHandler_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyShapeEvtHandler_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyShapeEvtHandler_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyShapeEvtHandler_base_OnMovePost(*args, **kwargs)
return _ogl.PyShapeEvtHandler_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyShapeEvtHandler_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyShapeEvtHandler_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyShapeEvtHandler_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyShapeEvtHandler_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
return _ogl.PyShape_MakeControlPoints(*args, **kwargs)
def DeleteControlPoints(*args, **kwargs):
- """DeleteControlPoints(wxDC dc=None)"""
+ """DeleteControlPoints(DC dc=None)"""
return _ogl.PyShape_DeleteControlPoints(*args, **kwargs)
def ResetControlPoints(*args, **kwargs):
return _ogl.PyShape_CalculateSize(*args, **kwargs)
def Select(*args, **kwargs):
- """Select(bool select=True, wxDC dc=None)"""
+ """Select(bool select=True, DC dc=None)"""
return _ogl.PyShape_Select(*args, **kwargs)
def SetHighlight(*args, **kwargs):
return _ogl.PyShape_IsShown(*args, **kwargs)
def Move(*args, **kwargs):
- """Move(wxDC dc, double x1, double y1, bool display=True)"""
+ """Move(DC dc, double x1, double y1, bool display=True)"""
return _ogl.PyShape_Move(*args, **kwargs)
def Erase(*args, **kwargs):
- """Erase(wxDC dc)"""
+ """Erase(DC dc)"""
return _ogl.PyShape_Erase(*args, **kwargs)
def EraseContents(*args, **kwargs):
- """EraseContents(wxDC dc)"""
+ """EraseContents(DC dc)"""
return _ogl.PyShape_EraseContents(*args, **kwargs)
def Draw(*args, **kwargs):
- """Draw(wxDC dc)"""
+ """Draw(DC dc)"""
return _ogl.PyShape_Draw(*args, **kwargs)
def Flash(*args, **kwargs):
return _ogl.PyShape_Flash(*args, **kwargs)
def MoveLinks(*args, **kwargs):
- """MoveLinks(wxDC dc)"""
+ """MoveLinks(DC dc)"""
return _ogl.PyShape_MoveLinks(*args, **kwargs)
def DrawContents(*args, **kwargs):
- """DrawContents(wxDC dc)"""
+ """DrawContents(DC dc)"""
return _ogl.PyShape_DrawContents(*args, **kwargs)
def SetSize(*args, **kwargs):
return _ogl.PyShape_GetLinePosition(*args, **kwargs)
def AddText(*args, **kwargs):
- """AddText(wxString string)"""
+ """AddText(String string)"""
return _ogl.PyShape_AddText(*args, **kwargs)
def GetPen(*args, **kwargs):
return _ogl.PyShape_SetDefaultRegionSize(*args, **kwargs)
def FormatText(*args, **kwargs):
- """FormatText(wxDC dc, wxString s, int regionId=0)"""
+ """FormatText(DC dc, String s, int regionId=0)"""
return _ogl.PyShape_FormatText(*args, **kwargs)
def SetFormatMode(*args, **kwargs):
return _ogl.PyShape_GetFormatMode(*args, **kwargs)
def SetFont(*args, **kwargs):
- """SetFont(wxFont font, int regionId=0)"""
+ """SetFont(Font font, int regionId=0)"""
return _ogl.PyShape_SetFont(*args, **kwargs)
def GetFont(*args, **kwargs):
- """GetFont(int regionId=0) -> wxFont"""
+ """GetFont(int regionId=0) -> Font"""
return _ogl.PyShape_GetFont(*args, **kwargs)
def SetTextColour(*args, **kwargs):
- """SetTextColour(wxString colour, int regionId=0)"""
+ """SetTextColour(String colour, int regionId=0)"""
return _ogl.PyShape_SetTextColour(*args, **kwargs)
def GetTextColour(*args, **kwargs):
- """GetTextColour(int regionId=0) -> wxString"""
+ """GetTextColour(int regionId=0) -> String"""
return _ogl.PyShape_GetTextColour(*args, **kwargs)
def GetNumberOfTextRegions(*args, **kwargs):
return _ogl.PyShape_GetNumberOfTextRegions(*args, **kwargs)
def SetRegionName(*args, **kwargs):
- """SetRegionName(wxString name, int regionId=0)"""
+ """SetRegionName(String name, int regionId=0)"""
return _ogl.PyShape_SetRegionName(*args, **kwargs)
def GetRegionName(*args, **kwargs):
- """GetRegionName(int regionId) -> wxString"""
+ """GetRegionName(int regionId) -> String"""
return _ogl.PyShape_GetRegionName(*args, **kwargs)
def GetRegionId(*args, **kwargs):
- """GetRegionId(wxString name) -> int"""
+ """GetRegionId(String name) -> int"""
return _ogl.PyShape_GetRegionId(*args, **kwargs)
def NameRegions(*args, **kwargs):
- """NameRegions(wxString parentName=wxPyEmptyString)"""
+ """NameRegions(String parentName=EmptyString)"""
return _ogl.PyShape_NameRegions(*args, **kwargs)
def GetRegions(*args, **kwargs):
return _ogl.PyShape_AssignNewIds(*args, **kwargs)
def FindRegion(*args, **kwargs):
- """FindRegion(wxString regionName, int OUTPUT) -> PyShape"""
+ """FindRegion(String regionName, int OUTPUT) -> PyShape"""
return _ogl.PyShape_FindRegion(*args, **kwargs)
def FindRegionNames(*args, **kwargs):
return _ogl.PyShape_AttachmentSortTest(*args, **kwargs)
def EraseLinks(*args, **kwargs):
- """EraseLinks(wxDC dc, int attachment=-1, bool recurse=False)"""
+ """EraseLinks(DC dc, int attachment=-1, bool recurse=False)"""
return _ogl.PyShape_EraseLinks(*args, **kwargs)
def DrawLinks(*args, **kwargs):
- """DrawLinks(wxDC dc, int attachment=-1, bool recurse=False)"""
+ """DrawLinks(DC dc, int attachment=-1, bool recurse=False)"""
return _ogl.PyShape_DrawLinks(*args, **kwargs)
def MoveLineToNewAttachment(*args, **kwargs):
- """MoveLineToNewAttachment(wxDC dc, PyLineShape to_move, double x, double y) -> bool"""
+ """MoveLineToNewAttachment(DC dc, PyLineShape to_move, double x, double y) -> bool"""
return _ogl.PyShape_MoveLineToNewAttachment(*args, **kwargs)
def ApplyAttachmentOrdering(*args, **kwargs):
return _ogl.PyShape_ClearAttachments(*args, **kwargs)
def Recentre(*args, **kwargs):
- """Recentre(wxDC dc)"""
+ """Recentre(DC dc)"""
return _ogl.PyShape_Recentre(*args, **kwargs)
def ClearPointList(*args, **kwargs):
return _ogl.PyShape_base_OnDelete(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyShape_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyShape_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=False)"""
+ """base_OnDrawBranches(DC dc, bool erase=False)"""
return _ogl.PyShape_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyShape_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyShape_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyShape_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyShape_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyShape_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyShape_base_OnMovePost(*args, **kwargs)
return _ogl.PyShape_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyShape_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyShape_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyShape_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyShape_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
except: pass
def Draw(*args, **kwargs):
- """Draw(wxDC dc, double xoffset, double yoffset)"""
+ """Draw(DC dc, double xoffset, double yoffset)"""
return _ogl.PseudoMetaFile_Draw(*args, **kwargs)
def Clear(*args, **kwargs):
return _ogl.PseudoMetaFile_Rotate(*args, **kwargs)
def LoadFromMetaFile(*args, **kwargs):
- """LoadFromMetaFile(wxString filename, double width, double height) -> bool"""
+ """LoadFromMetaFile(String filename, double width, double height) -> bool"""
return _ogl.PseudoMetaFile_LoadFromMetaFile(*args, **kwargs)
def GetBounds(*args, **kwargs):
return _ogl.PseudoMetaFile_DrawPoint(*args, **kwargs)
def DrawText(*args, **kwargs):
- """DrawText(wxString text, Point pt)"""
+ """DrawText(String text, Point pt)"""
return _ogl.PseudoMetaFile_DrawText(*args, **kwargs)
def DrawLines(*args, **kwargs):
return _ogl.PseudoMetaFile_SetBrush(*args, **kwargs)
def SetFont(*args, **kwargs):
- """SetFont(wxFont font)"""
+ """SetFont(Font font)"""
return _ogl.PseudoMetaFile_SetFont(*args, **kwargs)
def SetTextColour(*args, **kwargs):
- """SetTextColour(wxColour colour)"""
+ """SetTextColour(Colour colour)"""
return _ogl.PseudoMetaFile_SetTextColour(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
- """SetBackgroundColour(wxColour colour)"""
+ """SetBackgroundColour(Colour colour)"""
return _ogl.PseudoMetaFile_SetBackgroundColour(*args, **kwargs)
def SetBackgroundMode(*args, **kwargs):
return _ogl.PyRectangleShape_base_OnDelete(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyRectangleShape_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyRectangleShape_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=FALSE)"""
+ """base_OnDrawBranches(DC dc, bool erase=FALSE)"""
return _ogl.PyRectangleShape_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyRectangleShape_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyRectangleShape_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyRectangleShape_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyRectangleShape_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyRectangleShape_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyRectangleShape_base_OnMovePost(*args, **kwargs)
return _ogl.PyRectangleShape_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyRectangleShape_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyRectangleShape_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyRectangleShape_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyRectangleShape_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
return _ogl.PyControlPoint_base_OnDelete(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyControlPoint_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyControlPoint_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=FALSE)"""
+ """base_OnDrawBranches(DC dc, bool erase=FALSE)"""
return _ogl.PyControlPoint_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyControlPoint_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyControlPoint_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyControlPoint_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyControlPoint_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyControlPoint_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyControlPoint_base_OnMovePost(*args, **kwargs)
return _ogl.PyControlPoint_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyControlPoint_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyControlPoint_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyControlPoint_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyControlPoint_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
return _ogl.PyBitmapShape__setCallbackInfo(*args, **kwargs)
def GetBitmap(*args, **kwargs):
- """GetBitmap() -> wxBitmap"""
+ """GetBitmap() -> Bitmap"""
return _ogl.PyBitmapShape_GetBitmap(*args, **kwargs)
def GetFilename(*args, **kwargs):
- """GetFilename() -> wxString"""
+ """GetFilename() -> String"""
return _ogl.PyBitmapShape_GetFilename(*args, **kwargs)
def SetBitmap(*args, **kwargs):
- """SetBitmap(wxBitmap bitmap)"""
+ """SetBitmap(Bitmap bitmap)"""
return _ogl.PyBitmapShape_SetBitmap(*args, **kwargs)
def SetFilename(*args, **kwargs):
- """SetFilename(wxString filename)"""
+ """SetFilename(String filename)"""
return _ogl.PyBitmapShape_SetFilename(*args, **kwargs)
def base_OnDelete(*args, **kwargs):
return _ogl.PyBitmapShape_base_OnDelete(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyBitmapShape_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyBitmapShape_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=FALSE)"""
+ """base_OnDrawBranches(DC dc, bool erase=FALSE)"""
return _ogl.PyBitmapShape_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyBitmapShape_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyBitmapShape_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyBitmapShape_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyBitmapShape_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyBitmapShape_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyBitmapShape_base_OnMovePost(*args, **kwargs)
return _ogl.PyBitmapShape_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyBitmapShape_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyBitmapShape_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyBitmapShape_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyBitmapShape_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
return _ogl.PyDrawnShape_DrawSpline(*args, **kwargs)
def DrawText(*args, **kwargs):
- """DrawText(wxString text, Point point)"""
+ """DrawText(String text, Point point)"""
return _ogl.PyDrawnShape_DrawText(*args, **kwargs)
def GetAngle(*args, **kwargs):
return _ogl.PyDrawnShape_GetRotation(*args, **kwargs)
def LoadFromMetaFile(*args, **kwargs):
- """LoadFromMetaFile(wxString filename) -> bool"""
+ """LoadFromMetaFile(String filename) -> bool"""
return _ogl.PyDrawnShape_LoadFromMetaFile(*args, **kwargs)
def Rotate(*args, **kwargs):
return _ogl.PyDrawnShape_SetClippingRect(*args, **kwargs)
def SetDrawnBackgroundColour(*args, **kwargs):
- """SetDrawnBackgroundColour(wxColour colour)"""
+ """SetDrawnBackgroundColour(Colour colour)"""
return _ogl.PyDrawnShape_SetDrawnBackgroundColour(*args, **kwargs)
def SetDrawnBackgroundMode(*args, **kwargs):
return _ogl.PyDrawnShape_SetDrawnBrush(*args, **kwargs)
def SetDrawnFont(*args, **kwargs):
- """SetDrawnFont(wxFont font)"""
+ """SetDrawnFont(Font font)"""
return _ogl.PyDrawnShape_SetDrawnFont(*args, **kwargs)
def SetDrawnPen(*args, **kwargs):
return _ogl.PyDrawnShape_SetDrawnPen(*args, **kwargs)
def SetDrawnTextColour(*args, **kwargs):
- """SetDrawnTextColour(wxColour colour)"""
+ """SetDrawnTextColour(Colour colour)"""
return _ogl.PyDrawnShape_SetDrawnTextColour(*args, **kwargs)
def Scale(*args, **kwargs):
return _ogl.PyDrawnShape_base_OnDelete(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyDrawnShape_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyDrawnShape_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=FALSE)"""
+ """base_OnDrawBranches(DC dc, bool erase=FALSE)"""
return _ogl.PyDrawnShape_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyDrawnShape_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyDrawnShape_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyDrawnShape_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyDrawnShape_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyDrawnShape_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyDrawnShape_base_OnMovePost(*args, **kwargs)
return _ogl.PyDrawnShape_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyDrawnShape_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyDrawnShape_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyDrawnShape_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyDrawnShape_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
return _ogl.PyCompositeShape_base_OnDelete(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyCompositeShape_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyCompositeShape_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=FALSE)"""
+ """base_OnDrawBranches(DC dc, bool erase=FALSE)"""
return _ogl.PyCompositeShape_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyCompositeShape_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyCompositeShape_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyCompositeShape_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyCompositeShape_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyCompositeShape_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyCompositeShape_base_OnMovePost(*args, **kwargs)
return _ogl.PyCompositeShape_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyCompositeShape_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyCompositeShape_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyCompositeShape_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyCompositeShape_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
return _ogl.PyDividedShape_base_OnDelete(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyDividedShape_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyDividedShape_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=FALSE)"""
+ """base_OnDrawBranches(DC dc, bool erase=FALSE)"""
return _ogl.PyDividedShape_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyDividedShape_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyDividedShape_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyDividedShape_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyDividedShape_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyDividedShape_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyDividedShape_base_OnMovePost(*args, **kwargs)
return _ogl.PyDividedShape_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyDividedShape_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyDividedShape_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyDividedShape_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyDividedShape_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
return _ogl.PyDivisionShape_GetLeftSide(*args, **kwargs)
def GetLeftSideColour(*args, **kwargs):
- """GetLeftSideColour() -> wxString"""
+ """GetLeftSideColour() -> String"""
return _ogl.PyDivisionShape_GetLeftSideColour(*args, **kwargs)
def GetLeftSidePen(*args, **kwargs):
return _ogl.PyDivisionShape_SetLeftSide(*args, **kwargs)
def SetLeftSideColour(*args, **kwargs):
- """SetLeftSideColour(wxString colour)"""
+ """SetLeftSideColour(String colour)"""
return _ogl.PyDivisionShape_SetLeftSideColour(*args, **kwargs)
def SetLeftSidePen(*args, **kwargs):
return _ogl.PyDivisionShape_SetTopSide(*args, **kwargs)
def SetTopSideColour(*args, **kwargs):
- """SetTopSideColour(wxString colour)"""
+ """SetTopSideColour(String colour)"""
return _ogl.PyDivisionShape_SetTopSideColour(*args, **kwargs)
def SetTopSidePen(*args, **kwargs):
return _ogl.PyDivisionShape_base_OnDelete(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyDivisionShape_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyDivisionShape_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=FALSE)"""
+ """base_OnDrawBranches(DC dc, bool erase=FALSE)"""
return _ogl.PyDivisionShape_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyDivisionShape_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyDivisionShape_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyDivisionShape_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyDivisionShape_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyDivisionShape_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyDivisionShape_base_OnMovePost(*args, **kwargs)
return _ogl.PyDivisionShape_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyDivisionShape_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyDivisionShape_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyDivisionShape_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyDivisionShape_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
return _ogl.PyEllipseShape__setCallbackInfo(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyEllipseShape_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyEllipseShape_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=FALSE)"""
+ """base_OnDrawBranches(DC dc, bool erase=FALSE)"""
return _ogl.PyEllipseShape_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyEllipseShape_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyEllipseShape_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyEllipseShape_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyEllipseShape_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyEllipseShape_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyEllipseShape_base_OnMovePost(*args, **kwargs)
return _ogl.PyEllipseShape_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyEllipseShape_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyEllipseShape_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyEllipseShape_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyEllipseShape_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
return _ogl.PyCircleShape__setCallbackInfo(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyCircleShape_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyCircleShape_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=FALSE)"""
+ """base_OnDrawBranches(DC dc, bool erase=FALSE)"""
return _ogl.PyCircleShape_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyCircleShape_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyCircleShape_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyCircleShape_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyCircleShape_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyCircleShape_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyCircleShape_base_OnMovePost(*args, **kwargs)
return _ogl.PyCircleShape_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyCircleShape_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyCircleShape_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyCircleShape_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyCircleShape_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
def __init__(self, *args, **kwargs):
"""
__init__(int type=0, int end=0, double size=0.0, double dist=0.0,
- wxString name=wxPyEmptyString, PseudoMetaFile mf=None,
+ String name=EmptyString, PseudoMetaFile mf=None,
long arrowId=-1) -> ArrowHead
"""
newobj = _ogl.new_ArrowHead(*args, **kwargs)
return _ogl.ArrowHead_GetSize(*args, **kwargs)
def GetName(*args, **kwargs):
- """GetName() -> wxString"""
+ """GetName() -> String"""
return _ogl.ArrowHead_GetName(*args, **kwargs)
def SetXOffset(*args, **kwargs):
def AddArrow(*args, **kwargs):
"""
AddArrow(int type, int end=ARROW_POSITION_END, double arrowSize=10.0,
- double xOffset=0.0, wxString name=wxPyEmptyString,
+ double xOffset=0.0, String name=EmptyString,
PseudoMetaFile mf=None, long arrowId=-1)
"""
return _ogl.PyLineShape_AddArrow(*args, **kwargs)
return _ogl.PyLineShape_AddArrowOrdered(*args, **kwargs)
def ClearArrow(*args, **kwargs):
- """ClearArrow(wxString name) -> bool"""
+ """ClearArrow(String name) -> bool"""
return _ogl.PyLineShape_ClearArrow(*args, **kwargs)
def ClearArrowsAtPosition(*args, **kwargs):
return _ogl.PyLineShape_ClearArrowsAtPosition(*args, **kwargs)
def DrawArrow(*args, **kwargs):
- """DrawArrow(wxDC dc, ArrowHead arrow, double xOffset, bool proportionalOffset)"""
+ """DrawArrow(DC dc, ArrowHead arrow, double xOffset, bool proportionalOffset)"""
return _ogl.PyLineShape_DrawArrow(*args, **kwargs)
def DeleteArrowHeadId(*args, **kwargs):
return _ogl.PyLineShape_DeleteArrowHeadId(*args, **kwargs)
def DeleteArrowHead(*args, **kwargs):
- """DeleteArrowHead(int position, wxString name) -> bool"""
+ """DeleteArrowHead(int position, String name) -> bool"""
return _ogl.PyLineShape_DeleteArrowHead(*args, **kwargs)
def DeleteLineControlPoint(*args, **kwargs):
return _ogl.PyLineShape_DeleteLineControlPoint(*args, **kwargs)
def DrawArrows(*args, **kwargs):
- """DrawArrows(wxDC dc)"""
+ """DrawArrows(DC dc)"""
return _ogl.PyLineShape_DrawArrows(*args, **kwargs)
def DrawRegion(*args, **kwargs):
- """DrawRegion(wxDC dc, ShapeRegion region, double x, double y)"""
+ """DrawRegion(DC dc, ShapeRegion region, double x, double y)"""
return _ogl.PyLineShape_DrawRegion(*args, **kwargs)
def EraseRegion(*args, **kwargs):
- """EraseRegion(wxDC dc, ShapeRegion region, double x, double y)"""
+ """EraseRegion(DC dc, ShapeRegion region, double x, double y)"""
return _ogl.PyLineShape_EraseRegion(*args, **kwargs)
def FindArrowHeadId(*args, **kwargs):
return _ogl.PyLineShape_FindArrowHeadId(*args, **kwargs)
def FindArrowHead(*args, **kwargs):
- """FindArrowHead(int position, wxString name) -> ArrowHead"""
+ """FindArrowHead(int position, String name) -> ArrowHead"""
return _ogl.PyLineShape_FindArrowHead(*args, **kwargs)
def FindLineEndPoints(*args, **kwargs):
return _ogl.PyLineShape_Initialise(*args, **kwargs)
def InsertLineControlPoint(*args, **kwargs):
- """InsertLineControlPoint(wxDC dc)"""
+ """InsertLineControlPoint(DC dc)"""
return _ogl.PyLineShape_InsertLineControlPoint(*args, **kwargs)
def IsEnd(*args, **kwargs):
return _ogl.PyLineShape_SetTo(*args, **kwargs)
def Straighten(*args, **kwargs):
- """Straighten(wxDC dc=None)"""
+ """Straighten(DC dc=None)"""
return _ogl.PyLineShape_Straighten(*args, **kwargs)
def Unlink(*args, **kwargs):
return _ogl.PyLineShape_Unlink(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyLineShape_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyLineShape_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=FALSE)"""
+ """base_OnDrawBranches(DC dc, bool erase=FALSE)"""
return _ogl.PyLineShape_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyLineShape_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyLineShape_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyLineShape_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyLineShape_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyLineShape_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyLineShape_base_OnMovePost(*args, **kwargs)
return _ogl.PyLineShape_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyLineShape_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyLineShape_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyLineShape_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyLineShape_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
return _ogl.PyPolygonShape_UpdateOriginalPoints(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyPolygonShape_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyPolygonShape_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=FALSE)"""
+ """base_OnDrawBranches(DC dc, bool erase=FALSE)"""
return _ogl.PyPolygonShape_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyPolygonShape_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyPolygonShape_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyPolygonShape_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyPolygonShape_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyPolygonShape_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyPolygonShape_base_OnMovePost(*args, **kwargs)
return _ogl.PyPolygonShape_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyPolygonShape_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyPolygonShape_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyPolygonShape_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyPolygonShape_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
return _ogl.PyTextShape_base_OnDelete(*args, **kwargs)
def base_OnDraw(*args, **kwargs):
- """base_OnDraw(wxDC dc)"""
+ """base_OnDraw(DC dc)"""
return _ogl.PyTextShape_base_OnDraw(*args, **kwargs)
def base_OnDrawContents(*args, **kwargs):
- """base_OnDrawContents(wxDC dc)"""
+ """base_OnDrawContents(DC dc)"""
return _ogl.PyTextShape_base_OnDrawContents(*args, **kwargs)
def base_OnDrawBranches(*args, **kwargs):
- """base_OnDrawBranches(wxDC dc, bool erase=FALSE)"""
+ """base_OnDrawBranches(DC dc, bool erase=FALSE)"""
return _ogl.PyTextShape_base_OnDrawBranches(*args, **kwargs)
def base_OnMoveLinks(*args, **kwargs):
- """base_OnMoveLinks(wxDC dc)"""
+ """base_OnMoveLinks(DC dc)"""
return _ogl.PyTextShape_base_OnMoveLinks(*args, **kwargs)
def base_OnErase(*args, **kwargs):
- """base_OnErase(wxDC dc)"""
+ """base_OnErase(DC dc)"""
return _ogl.PyTextShape_base_OnErase(*args, **kwargs)
def base_OnEraseContents(*args, **kwargs):
- """base_OnEraseContents(wxDC dc)"""
+ """base_OnEraseContents(DC dc)"""
return _ogl.PyTextShape_base_OnEraseContents(*args, **kwargs)
def base_OnHighlight(*args, **kwargs):
- """base_OnHighlight(wxDC dc)"""
+ """base_OnHighlight(DC dc)"""
return _ogl.PyTextShape_base_OnHighlight(*args, **kwargs)
def base_OnLeftClick(*args, **kwargs):
def base_OnMovePre(*args, **kwargs):
"""
- base_OnMovePre(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePre(DC dc, double x, double y, double old_x, double old_y,
bool display=True) -> bool
"""
return _ogl.PyTextShape_base_OnMovePre(*args, **kwargs)
def base_OnMovePost(*args, **kwargs):
"""
- base_OnMovePost(wxDC dc, double x, double y, double old_x, double old_y,
+ base_OnMovePost(DC dc, double x, double y, double old_x, double old_y,
bool display=True)
"""
return _ogl.PyTextShape_base_OnMovePost(*args, **kwargs)
return _ogl.PyTextShape_base_OnEndDragRight(*args, **kwargs)
def base_OnDrawOutline(*args, **kwargs):
- """base_OnDrawOutline(wxDC dc, double x, double y, double w, double h)"""
+ """base_OnDrawOutline(DC dc, double x, double y, double w, double h)"""
return _ogl.PyTextShape_base_OnDrawOutline(*args, **kwargs)
def base_OnDrawControlPoints(*args, **kwargs):
- """base_OnDrawControlPoints(wxDC dc)"""
+ """base_OnDrawControlPoints(DC dc)"""
return _ogl.PyTextShape_base_OnDrawControlPoints(*args, **kwargs)
def base_OnEraseControlPoints(*args, **kwargs):
- """base_OnEraseControlPoints(wxDC dc)"""
+ """base_OnEraseControlPoints(DC dc)"""
return _ogl.PyTextShape_base_OnEraseControlPoints(*args, **kwargs)
def base_OnMoveLink(*args, **kwargs):
- """base_OnMoveLink(wxDC dc, bool moveControlPoints=True)"""
+ """base_OnMoveLink(DC dc, bool moveControlPoints=True)"""
return _ogl.PyTextShape_base_OnMoveLink(*args, **kwargs)
def base_OnSizingDragLeft(*args, **kwargs):
return _ogl.Diagram_AddShape(*args, **kwargs)
def Clear(*args, **kwargs):
- """Clear(wxDC dc)"""
+ """Clear(DC dc)"""
return _ogl.Diagram_Clear(*args, **kwargs)
def DeleteAllShapes(*args, **kwargs):
return _ogl.Diagram_DeleteAllShapes(*args, **kwargs)
def DrawOutline(*args, **kwargs):
- """DrawOutline(wxDC dc, double x1, double y1, double x2, double y2)"""
+ """DrawOutline(DC dc, double x1, double y1, double x2, double y2)"""
return _ogl.Diagram_DrawOutline(*args, **kwargs)
def FindShape(*args, **kwargs):
return _ogl.Diagram_InsertShape(*args, **kwargs)
def RecentreAll(*args, **kwargs):
- """RecentreAll(wxDC dc)"""
+ """RecentreAll(DC dc)"""
return _ogl.Diagram_RecentreAll(*args, **kwargs)
def Redraw(*args, **kwargs):
- """Redraw(wxDC dc)"""
+ """Redraw(DC dc)"""
return _ogl.Diagram_Redraw(*args, **kwargs)
def RemoveAllShapes(*args, **kwargs):
"""
__init__(Window parent=None, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=BORDER,
- wxString name=wxPyShapeCanvasNameStr) -> PyShapeCanvas
+ String name=wxPyShapeCanvasNameStr) -> PyShapeCanvas
"""
newobj = _ogl.new_PyShapeCanvas(*args, **kwargs)
self.this = newobj.this
return _ogl.PyShapeCanvas_base_OnRightClick(*args, **kwargs)
def Redraw(*args, **kwargs):
- """Redraw(wxDC dc)"""
+ """Redraw(DC dc)"""
return _ogl.PyShapeCanvas_Redraw(*args, **kwargs)
def RemoveShape(*args, **kwargs):
#include "oglhelpers.h"
- static const wxString wxPyEmptyString(wxT(""));
-
+ static const wxString wxPyEmptyString(wxEmptyString);
static PyObject* t_output_helper(PyObject* target, PyObject* o) {
PyObject* o2;
%rename(GenericFindWindowAtPoint) wxGenericFindWindowAtPoint;
%rename(FindWindowAtPoint) wxFindWindowAtPoint;
%rename(GetTopLevelParent) wxGetTopLevelParent;
+%rename(GetKeyState) wxGetKeyState;
%rename(WakeUpMainThread) wxWakeUpMainThread;
%rename(MutexGuiEnter) wxMutexGuiEnter;
%rename(MutexGuiLeave) wxMutexGuiLeave;
return "<%s.%s; proxy of C++ wxCalendarDateAttr instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(wxColour colText, wxColour colBack=wxNullColour, wxColour colBorder=wxNullColour,
- wxFont font=wxNullFont,
- wxCalendarDateBorder border=CAL_BORDER_NONE) -> CalendarDateAttr
+ __init__(Colour colText, Colour colBack=wxNullColour, Colour colBorder=wxNullColour,
+ Font font=wxNullFont,
+ int border=CAL_BORDER_NONE) -> CalendarDateAttr
"""
newobj = _calendar.new_CalendarDateAttr(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def SetTextColour(*args, **kwargs):
- """SetTextColour(wxColour colText)"""
+ """SetTextColour(Colour colText)"""
return _calendar.CalendarDateAttr_SetTextColour(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
- """SetBackgroundColour(wxColour colBack)"""
+ """SetBackgroundColour(Colour colBack)"""
return _calendar.CalendarDateAttr_SetBackgroundColour(*args, **kwargs)
def SetBorderColour(*args, **kwargs):
- """SetBorderColour(wxColour col)"""
+ """SetBorderColour(Colour col)"""
return _calendar.CalendarDateAttr_SetBorderColour(*args, **kwargs)
def SetFont(*args, **kwargs):
- """SetFont(wxFont font)"""
+ """SetFont(Font font)"""
return _calendar.CalendarDateAttr_SetFont(*args, **kwargs)
def SetBorder(*args, **kwargs):
- """SetBorder(wxCalendarDateBorder border)"""
+ """SetBorder(int border)"""
return _calendar.CalendarDateAttr_SetBorder(*args, **kwargs)
def SetHoliday(*args, **kwargs):
return _calendar.CalendarDateAttr_IsHoliday(*args, **kwargs)
def GetTextColour(*args, **kwargs):
- """GetTextColour() -> wxColour"""
+ """GetTextColour() -> Colour"""
return _calendar.CalendarDateAttr_GetTextColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
- """GetBackgroundColour() -> wxColour"""
+ """GetBackgroundColour() -> Colour"""
return _calendar.CalendarDateAttr_GetBackgroundColour(*args, **kwargs)
def GetBorderColour(*args, **kwargs):
- """GetBorderColour() -> wxColour"""
+ """GetBorderColour() -> Colour"""
return _calendar.CalendarDateAttr_GetBorderColour(*args, **kwargs)
def GetFont(*args, **kwargs):
- """GetFont() -> wxFont"""
+ """GetFont() -> Font"""
return _calendar.CalendarDateAttr_GetFont(*args, **kwargs)
def GetBorder(*args, **kwargs):
- """GetBorder() -> wxCalendarDateBorder"""
+ """GetBorder() -> int"""
return _calendar.CalendarDateAttr_GetBorder(*args, **kwargs)
_calendar.CalendarDateAttr_swigregister(CalendarDateAttrPtr)
def CalendarDateAttrBorder(*args, **kwargs):
- """CalendarDateAttrBorder(wxCalendarDateBorder border, wxColour colBorder=wxNullColour) -> CalendarDateAttr"""
+ """CalendarDateAttrBorder(int border, Colour colBorder=wxNullColour) -> CalendarDateAttr"""
val = _calendar.new_CalendarDateAttrBorder(*args, **kwargs)
val.thisown = 1
return val
return _calendar.CalendarEvent_SetDate(*args, **kwargs)
def SetWeekDay(*args, **kwargs):
- """SetWeekDay(wxDateTime::WeekDay wd)"""
+ """SetWeekDay(int wd)"""
return _calendar.CalendarEvent_SetWeekDay(*args, **kwargs)
def GetWeekDay(*args, **kwargs):
- """GetWeekDay() -> wxDateTime::WeekDay"""
+ """GetWeekDay() -> int"""
return _calendar.CalendarEvent_GetWeekDay(*args, **kwargs)
__init__(Window parent, int id, DateTime date=wxDefaultDateTime,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxCAL_SHOW_HOLIDAYS|wxWANTS_CHARS,
- wxString name=wxPyCalendarNameStr) -> CalendarCtrl
+ String name=CalendarNameStr) -> CalendarCtrl
"""
newobj = _calendar.new_CalendarCtrl(*args, **kwargs)
self.this = newobj.this
Create(Window parent, int id, DateTime date=wxDefaultDateTime,
Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxCAL_SHOW_HOLIDAYS|wxWANTS_CHARS,
- wxString name=wxPyCalendarNameStr) -> bool
+ String name=CalendarNameStr) -> bool
"""
return _calendar.CalendarCtrl_Create(*args, **kwargs)
return _calendar.CalendarCtrl_EnableHolidayDisplay(*args, **kwargs)
def SetHeaderColours(*args, **kwargs):
- """SetHeaderColours(wxColour colFg, wxColour colBg)"""
+ """SetHeaderColours(Colour colFg, Colour colBg)"""
return _calendar.CalendarCtrl_SetHeaderColours(*args, **kwargs)
def GetHeaderColourFg(*args, **kwargs):
- """GetHeaderColourFg() -> wxColour"""
+ """GetHeaderColourFg() -> Colour"""
return _calendar.CalendarCtrl_GetHeaderColourFg(*args, **kwargs)
def GetHeaderColourBg(*args, **kwargs):
- """GetHeaderColourBg() -> wxColour"""
+ """GetHeaderColourBg() -> Colour"""
return _calendar.CalendarCtrl_GetHeaderColourBg(*args, **kwargs)
def SetHighlightColours(*args, **kwargs):
- """SetHighlightColours(wxColour colFg, wxColour colBg)"""
+ """SetHighlightColours(Colour colFg, Colour colBg)"""
return _calendar.CalendarCtrl_SetHighlightColours(*args, **kwargs)
def GetHighlightColourFg(*args, **kwargs):
- """GetHighlightColourFg() -> wxColour"""
+ """GetHighlightColourFg() -> Colour"""
return _calendar.CalendarCtrl_GetHighlightColourFg(*args, **kwargs)
def GetHighlightColourBg(*args, **kwargs):
- """GetHighlightColourBg() -> wxColour"""
+ """GetHighlightColourBg() -> Colour"""
return _calendar.CalendarCtrl_GetHighlightColourBg(*args, **kwargs)
def SetHolidayColours(*args, **kwargs):
- """SetHolidayColours(wxColour colFg, wxColour colBg)"""
+ """SetHolidayColours(Colour colFg, Colour colBg)"""
return _calendar.CalendarCtrl_SetHolidayColours(*args, **kwargs)
def GetHolidayColourFg(*args, **kwargs):
- """GetHolidayColourFg() -> wxColour"""
+ """GetHolidayColourFg() -> Colour"""
return _calendar.CalendarCtrl_GetHolidayColourFg(*args, **kwargs)
def GetHolidayColourBg(*args, **kwargs):
- """GetHolidayColourBg() -> wxColour"""
+ """GetHolidayColourBg() -> Colour"""
return _calendar.CalendarCtrl_GetHolidayColourBg(*args, **kwargs)
def GetAttr(*args, **kwargs):
return _calendar.CalendarCtrl_ResetAttr(*args, **kwargs)
def HitTest(*args, **kwargs):
- """HitTest(Point pos, DateTime date=None, wxDateTime::WeekDay wd=None) -> wxCalendarHitTestResult"""
+ """HitTest(Point pos, DateTime date=None, int wd=None) -> int"""
return _calendar.CalendarCtrl_HitTest(*args, **kwargs)
def Enable(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = CalendarCtrl
_calendar.CalendarCtrl_swigregister(CalendarCtrlPtr)
+cvar = _calendar.cvar
+CalendarNameStr = cvar.CalendarNameStr
def PreCalendarCtrl(*args, **kwargs):
"""PreCalendarCtrl() -> CalendarCtrl"""
#include <wx/calctrl.h>
-
- DECLARE_DEF_STRING(CalendarNameStr);
-
+ static const wxString wxPyCalendarNameStr(wxCalendarNameStr);
#ifdef __cplusplus
extern "C" {
#endif
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_CalendarNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable CalendarNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_CalendarNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyCalendarNameStr)->c_str(), (&wxPyCalendarNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyCalendarNameStr)->c_str(), (&wxPyCalendarNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_CalendarCtrl(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
PyDict_SetItemString(d, "wxEVT_CALENDAR_MONTH_CHANGED", PyInt_FromLong(wxEVT_CALENDAR_MONTH_CHANGED));
PyDict_SetItemString(d, "wxEVT_CALENDAR_YEAR_CHANGED", PyInt_FromLong(wxEVT_CALENDAR_YEAR_CHANGED));
PyDict_SetItemString(d, "wxEVT_CALENDAR_WEEKDAY_CLICKED", PyInt_FromLong(wxEVT_CALENDAR_WEEKDAY_CLICKED));
+ PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
+ SWIG_addvarlink(SWIG_globals,(char*)"CalendarNameStr",_wrap_CalendarNameStr_get, _wrap_CalendarNameStr_set);
}
return "<%s.%s; proxy of C++ wxButton instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString label, Point pos=DefaultPosition,
+ __init__(Window parent, int id, String label, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- Validator validator=DefaultValidator,
- wxString name=wxPyButtonNameStr) -> Button
+ Validator validator=DefaultValidator, String name=ButtonNameStr) -> Button
Create and show a button.
"""
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxString label, Point pos=DefaultPosition,
+ Create(Window parent, int id, String label, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- Validator validator=DefaultValidator,
- wxString name=wxPyButtonNameStr) -> bool
+ Validator validator=DefaultValidator, String name=ButtonNameStr) -> bool
Acutally create the GUI Button for 2-phase creation.
"""
return _controls.Button_SetDefault(*args, **kwargs)
def SetImageLabel(*args, **kwargs):
- """SetImageLabel(wxBitmap bitmap)"""
+ """SetImageLabel(Bitmap bitmap)"""
return _controls.Button_SetImageLabel(*args, **kwargs)
def SetImageMargins(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Button
_controls.Button_swigregister(ButtonPtr)
+cvar = _controls.cvar
+ButtonNameStr = cvar.ButtonNameStr
def PreButton(*args, **kwargs):
"""
return "<%s.%s; proxy of C++ wxBitmapButton instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxBitmap bitmap, Point pos=DefaultPosition,
+ __init__(Window parent, int id, Bitmap bitmap, Point pos=DefaultPosition,
Size size=DefaultSize, long style=BU_AUTODRAW,
Validator validator=DefaultValidator,
- wxString name=wxPyButtonNameStr) -> BitmapButton
+ String name=ButtonNameStr) -> BitmapButton
Create and show a button.
"""
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxBitmap bitmap, Point pos=DefaultPosition,
+ Create(Window parent, int id, Bitmap bitmap, Point pos=DefaultPosition,
Size size=DefaultSize, long style=BU_AUTODRAW,
Validator validator=DefaultValidator,
- wxString name=wxPyButtonNameStr) -> bool
+ String name=ButtonNameStr) -> bool
Acutally create the GUI BitmapButton for 2-phase creation.
"""
def GetBitmapLabel(*args, **kwargs):
"""
- GetBitmapLabel() -> wxBitmap
+ GetBitmapLabel() -> Bitmap
Returns the label bitmap (the one passed to the constructor).
"""
def GetBitmapDisabled(*args, **kwargs):
"""
- GetBitmapDisabled() -> wxBitmap
+ GetBitmapDisabled() -> Bitmap
Returns the bitmap for the disabled state.
"""
def GetBitmapFocus(*args, **kwargs):
"""
- GetBitmapFocus() -> wxBitmap
+ GetBitmapFocus() -> Bitmap
Returns the bitmap for the focused state.
"""
def GetBitmapSelected(*args, **kwargs):
"""
- GetBitmapSelected() -> wxBitmap
+ GetBitmapSelected() -> Bitmap
Returns the bitmap for the selected state.
"""
def SetBitmapDisabled(*args, **kwargs):
"""
- SetBitmapDisabled(wxBitmap bitmap)
+ SetBitmapDisabled(Bitmap bitmap)
Sets the bitmap for the disabled button appearance.
"""
def SetBitmapFocus(*args, **kwargs):
"""
- SetBitmapFocus(wxBitmap bitmap)
+ SetBitmapFocus(Bitmap bitmap)
Sets the bitmap for the button appearance when it has the keyboard focus.
"""
def SetBitmapSelected(*args, **kwargs):
"""
- SetBitmapSelected(wxBitmap bitmap)
+ SetBitmapSelected(Bitmap bitmap)
Sets the bitmap for the selected (depressed) button appearance.
"""
def SetBitmapLabel(*args, **kwargs):
"""
- SetBitmapLabel(wxBitmap bitmap)
+ 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.
return "<%s.%s; proxy of C++ wxCheckBox instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString label, Point pos=DefaultPosition,
+ __init__(Window parent, int id, String label, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- Validator validator=DefaultValidator,
- wxString name=wxPyCheckBoxNameStr) -> CheckBox
+ Validator validator=DefaultValidator, String name=CheckBoxNameStr) -> CheckBox
"""
newobj = _controls.new_CheckBox(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxString label, Point pos=DefaultPosition,
+ Create(Window parent, int id, String label, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- Validator validator=DefaultValidator,
- wxString name=wxPyCheckBoxNameStr) -> bool
+ Validator validator=DefaultValidator, String name=CheckBoxNameStr) -> bool
"""
return _controls.CheckBox_Create(*args, **kwargs)
return _controls.CheckBox_SetValue(*args, **kwargs)
def Get3StateValue(*args, **kwargs):
- """Get3StateValue() -> wxCheckBoxState"""
+ """Get3StateValue() -> int"""
return _controls.CheckBox_Get3StateValue(*args, **kwargs)
def Set3StateValue(*args, **kwargs):
- """Set3StateValue(wxCheckBoxState state)"""
+ """Set3StateValue(int state)"""
return _controls.CheckBox_Set3StateValue(*args, **kwargs)
def Is3State(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = CheckBox
_controls.CheckBox_swigregister(CheckBoxPtr)
+CheckBoxNameStr = cvar.CheckBoxNameStr
def PreCheckBox(*args, **kwargs):
"""PreCheckBox() -> CheckBox"""
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- int choices=0, wxString choices_array=None,
+ int choices=0, String choices_array=None,
long style=0, Validator validator=DefaultValidator,
- wxString name=wxPyChoiceNameStr) -> Choice
+ String name=ChoiceNameStr) -> Choice
"""
newobj = _controls.new_Choice(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- int choices=0, wxString choices_array=None,
+ int choices=0, String choices_array=None,
long style=0, Validator validator=DefaultValidator,
- wxString name=wxPyChoiceNameStr) -> bool
+ String name=ChoiceNameStr) -> bool
"""
return _controls.Choice_Create(*args, **kwargs)
return _controls.Choice_SetSelection(*args, **kwargs)
def SetStringSelection(*args, **kwargs):
- """SetStringSelection(wxString string)"""
+ """SetStringSelection(String string)"""
return _controls.Choice_SetStringSelection(*args, **kwargs)
def SetString(*args, **kwargs):
- """SetString(int n, wxString s)"""
+ """SetString(int n, String s)"""
return _controls.Choice_SetString(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Choice
_controls.Choice_swigregister(ChoicePtr)
+ChoiceNameStr = cvar.ChoiceNameStr
def PreChoice(*args, **kwargs):
"""PreChoice() -> Choice"""
return "<%s.%s; proxy of C++ wxComboBox instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString value=wxPyEmptyString,
- Point pos=DefaultPosition, Size size=DefaultSize,
- int choices=0, wxString choices_array=None,
+ __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,
- wxString name=wxPyComboBoxNameStr) -> ComboBox
+ String name=ComboBoxNameStr) -> ComboBox
"""
newobj = _controls.new_ComboBox(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxString value=wxPyEmptyString,
- Point pos=DefaultPosition, Size size=DefaultSize,
- int choices=0, wxString choices_array=None,
+ 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,
- wxString name=wxPyComboBoxNameStr) -> bool
+ String name=ComboBoxNameStr) -> bool
"""
return _controls.ComboBox_Create(*args, **kwargs)
def GetValue(*args, **kwargs):
- """GetValue() -> wxString"""
+ """GetValue() -> String"""
return _controls.ComboBox_GetValue(*args, **kwargs)
def SetValue(*args, **kwargs):
- """SetValue(wxString value)"""
+ """SetValue(String value)"""
return _controls.ComboBox_SetValue(*args, **kwargs)
def Copy(*args, **kwargs):
return _controls.ComboBox_GetLastPosition(*args, **kwargs)
def Replace(*args, **kwargs):
- """Replace(long from, long to, wxString value)"""
+ """Replace(long from, long to, String value)"""
return _controls.ComboBox_Replace(*args, **kwargs)
def SetSelection(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ComboBox
_controls.ComboBox_swigregister(ComboBoxPtr)
+ComboBoxNameStr = cvar.ComboBoxNameStr
def PreComboBox(*args, **kwargs):
"""PreComboBox() -> ComboBox"""
__init__(Window parent, int id, int range, Point pos=DefaultPosition,
Size size=DefaultSize, long style=GA_HORIZONTAL,
Validator validator=DefaultValidator,
- wxString name=wxPyGaugeNameStr) -> Gauge
+ String name=GaugeNameStr) -> Gauge
"""
newobj = _controls.new_Gauge(*args, **kwargs)
self.this = newobj.this
Create(Window parent, int id, int range, Point pos=DefaultPosition,
Size size=DefaultSize, long style=GA_HORIZONTAL,
Validator validator=DefaultValidator,
- wxString name=wxPyGaugeNameStr) -> bool
+ String name=GaugeNameStr) -> bool
"""
return _controls.Gauge_Create(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Gauge
_controls.Gauge_swigregister(GaugePtr)
+GaugeNameStr = cvar.GaugeNameStr
def PreGauge(*args, **kwargs):
"""PreGauge() -> Gauge"""
return "<%s.%s; proxy of C++ wxStaticBox instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString label, Point pos=DefaultPosition,
+ __init__(Window parent, int id, String label, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- wxString name=wxPyStaticBoxNameStr) -> StaticBox
+ String name=StaticBoxNameStr) -> StaticBox
"""
newobj = _controls.new_StaticBox(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxString label, Point pos=DefaultPosition,
+ Create(Window parent, int id, String label, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- wxString name=wxPyStaticBoxNameStr) -> bool
+ String name=StaticBoxNameStr) -> bool
"""
return _controls.StaticBox_Create(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = StaticBox
_controls.StaticBox_swigregister(StaticBoxPtr)
+StaticBitmapNameStr = cvar.StaticBitmapNameStr
+StaticBoxNameStr = cvar.StaticBoxNameStr
+StaticTextNameStr = cvar.StaticTextNameStr
def PreStaticBox(*args, **kwargs):
"""PreStaticBox() -> StaticBox"""
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=LI_HORIZONTAL,
- wxString name=wxPyStaticTextNameStr) -> StaticLine
+ String name=StaticTextNameStr) -> StaticLine
"""
newobj = _controls.new_StaticLine(*args, **kwargs)
self.this = newobj.this
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=LI_HORIZONTAL,
- wxString name=wxPyStaticTextNameStr) -> bool
+ String name=StaticTextNameStr) -> bool
"""
return _controls.StaticLine_Create(*args, **kwargs)
return "<%s.%s; proxy of C++ wxStaticText instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString label, Point pos=DefaultPosition,
+ __init__(Window parent, int id, String label, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- wxString name=wxPyStaticTextNameStr) -> StaticText
+ String name=StaticTextNameStr) -> StaticText
"""
newobj = _controls.new_StaticText(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxString label, Point pos=DefaultPosition,
+ Create(Window parent, int id, String label, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- wxString name=wxPyStaticTextNameStr) -> bool
+ String name=StaticTextNameStr) -> bool
"""
return _controls.StaticText_Create(*args, **kwargs)
return "<%s.%s; proxy of C++ wxStaticBitmap instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxBitmap bitmap, Point pos=DefaultPosition,
+ __init__(Window parent, int id, Bitmap bitmap, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- wxString name=wxPyStaticBitmapNameStr) -> StaticBitmap
+ String name=StaticBitmapNameStr) -> StaticBitmap
"""
newobj = _controls.new_StaticBitmap(*args, **kwargs)
self.this = newobj.this
del newobj.thisown
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxBitmap bitmap, Point pos=DefaultPosition,
+ Create(Window parent, int id, Bitmap bitmap, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- wxString name=wxPyStaticBitmapNameStr) -> bool
+ String name=StaticBitmapNameStr) -> bool
"""
return _controls.StaticBitmap_Create(*args, **kwargs)
def GetBitmap(*args, **kwargs):
- """GetBitmap() -> wxBitmap"""
+ """GetBitmap() -> Bitmap"""
return _controls.StaticBitmap_GetBitmap(*args, **kwargs)
def SetBitmap(*args, **kwargs):
- """SetBitmap(wxBitmap bitmap)"""
+ """SetBitmap(Bitmap bitmap)"""
return _controls.StaticBitmap_SetBitmap(*args, **kwargs)
def SetIcon(*args, **kwargs):
- """SetIcon(wxIcon icon)"""
+ """SetIcon(Icon icon)"""
return _controls.StaticBitmap_SetIcon(*args, **kwargs)
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- int choices=0, wxString choices_array=None,
+ int choices=0, String choices_array=None,
long style=0, Validator validator=DefaultValidator,
- wxString name=wxPyListBoxNameStr) -> ListBox
+ String name=ListBoxNameStr) -> ListBox
"""
newobj = _controls.new_ListBox(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- int choices=0, wxString choices_array=None,
+ int choices=0, String choices_array=None,
long style=0, Validator validator=DefaultValidator,
- wxString name=wxPyListBoxNameStr) -> bool
+ String name=ListBoxNameStr) -> bool
"""
return _controls.ListBox_Create(*args, **kwargs)
def Insert(*args, **kwargs):
- """Insert(wxString item, int pos, PyObject clientData=None)"""
+ """Insert(String item, int pos, PyObject clientData=None)"""
return _controls.ListBox_Insert(*args, **kwargs)
def InsertItems(*args, **kwargs):
return _controls.ListBox_DeselectAll(*args, **kwargs)
def SetStringSelection(*args, **kwargs):
- """SetStringSelection(wxString s, bool select=True) -> bool"""
+ """SetStringSelection(String s, bool select=True) -> bool"""
return _controls.ListBox_SetStringSelection(*args, **kwargs)
def GetSelections(*args, **kwargs):
return _controls.ListBox_SetFirstItem(*args, **kwargs)
def SetFirstItemStr(*args, **kwargs):
- """SetFirstItemStr(wxString s)"""
+ """SetFirstItemStr(String s)"""
return _controls.ListBox_SetFirstItemStr(*args, **kwargs)
def EnsureVisible(*args, **kwargs):
return _controls.ListBox_EnsureVisible(*args, **kwargs)
def AppendAndEnsureVisible(*args, **kwargs):
- """AppendAndEnsureVisible(wxString s)"""
+ """AppendAndEnsureVisible(String s)"""
return _controls.ListBox_AppendAndEnsureVisible(*args, **kwargs)
def IsSorted(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ListBox
_controls.ListBox_swigregister(ListBoxPtr)
+ListBoxNameStr = cvar.ListBoxNameStr
def PreListBox(*args, **kwargs):
"""PreListBox() -> ListBox"""
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- int choices=0, wxString choices_array=None,
+ int choices=0, String choices_array=None,
long style=0, Validator validator=DefaultValidator,
- wxString name=wxPyListBoxNameStr) -> CheckListBox
+ String name=ListBoxNameStr) -> CheckListBox
"""
newobj = _controls.new_CheckListBox(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- int choices=0, wxString choices_array=None,
+ int choices=0, String choices_array=None,
long style=0, Validator validator=DefaultValidator,
- wxString name=wxPyListBoxNameStr) -> bool
+ String name=ListBoxNameStr) -> bool
"""
return _controls.CheckListBox_Create(*args, **kwargs)
def __init__(self, *args):
"""
__init__() -> TextAttr
- __init__(wxColour colText, wxColour colBack=wxNullColour, wxFont font=wxNullFont,
- wxTextAttrAlignment alignment=TEXT_ALIGNMENT_DEFAULT) -> TextAttr
+ __init__(Colour colText, Colour colBack=wxNullColour, Font font=wxNullFont,
+ int alignment=TEXT_ALIGNMENT_DEFAULT) -> TextAttr
"""
newobj = _controls.new_TextAttr(*args)
self.this = newobj.this
return _controls.TextAttr_Init(*args, **kwargs)
def SetTextColour(*args, **kwargs):
- """SetTextColour(wxColour colText)"""
+ """SetTextColour(Colour colText)"""
return _controls.TextAttr_SetTextColour(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
- """SetBackgroundColour(wxColour colBack)"""
+ """SetBackgroundColour(Colour colBack)"""
return _controls.TextAttr_SetBackgroundColour(*args, **kwargs)
def SetFont(*args, **kwargs):
- """SetFont(wxFont font, long flags=TEXT_ATTR_FONT)"""
+ """SetFont(Font font, long flags=TEXT_ATTR_FONT)"""
return _controls.TextAttr_SetFont(*args, **kwargs)
def SetAlignment(*args, **kwargs):
- """SetAlignment(wxTextAttrAlignment alignment)"""
+ """SetAlignment(int alignment)"""
return _controls.TextAttr_SetAlignment(*args, **kwargs)
def SetTabs(*args, **kwargs):
return _controls.TextAttr_HasFlag(*args, **kwargs)
def GetTextColour(*args, **kwargs):
- """GetTextColour() -> wxColour"""
+ """GetTextColour() -> Colour"""
return _controls.TextAttr_GetTextColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
- """GetBackgroundColour() -> wxColour"""
+ """GetBackgroundColour() -> Colour"""
return _controls.TextAttr_GetBackgroundColour(*args, **kwargs)
def GetFont(*args, **kwargs):
- """GetFont() -> wxFont"""
+ """GetFont() -> Font"""
return _controls.TextAttr_GetFont(*args, **kwargs)
def GetAlignment(*args, **kwargs):
- """GetAlignment() -> wxTextAttrAlignment"""
+ """GetAlignment() -> int"""
return _controls.TextAttr_GetAlignment(*args, **kwargs)
def GetTabs(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = TextAttr
_controls.TextAttr_swigregister(TextAttrPtr)
+TextCtrlNameStr = cvar.TextCtrlNameStr
def TextAttr_Combine(*args, **kwargs):
"""TextAttr_Combine(TextAttr attr, TextAttr attrDef, TextCtrl text) -> TextAttr"""
return "<%s.%s; proxy of C++ wxTextCtrl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString value=wxPyEmptyString,
- Point pos=DefaultPosition, Size size=DefaultSize,
+ __init__(Window parent, int id, String value=EmptyString, Point pos=DefaultPosition,
+ Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
- wxString name=wxPyTextCtrlNameStr) -> TextCtrl
+ String name=TextCtrlNameStr) -> TextCtrl
"""
newobj = _controls.new_TextCtrl(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxString value=wxPyEmptyString,
- Point pos=DefaultPosition, Size size=DefaultSize,
+ Create(Window parent, int id, String value=EmptyString, Point pos=DefaultPosition,
+ Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
- wxString name=wxPyTextCtrlNameStr) -> bool
+ String name=TextCtrlNameStr) -> bool
"""
return _controls.TextCtrl_Create(*args, **kwargs)
def GetValue(*args, **kwargs):
- """GetValue() -> wxString"""
+ """GetValue() -> String"""
return _controls.TextCtrl_GetValue(*args, **kwargs)
def SetValue(*args, **kwargs):
- """SetValue(wxString value)"""
+ """SetValue(String value)"""
return _controls.TextCtrl_SetValue(*args, **kwargs)
def GetRange(*args, **kwargs):
- """GetRange(long from, long to) -> wxString"""
+ """GetRange(long from, long to) -> String"""
return _controls.TextCtrl_GetRange(*args, **kwargs)
def GetLineLength(*args, **kwargs):
return _controls.TextCtrl_GetLineLength(*args, **kwargs)
def GetLineText(*args, **kwargs):
- """GetLineText(long lineNo) -> wxString"""
+ """GetLineText(long lineNo) -> String"""
return _controls.TextCtrl_GetLineText(*args, **kwargs)
def GetNumberOfLines(*args, **kwargs):
return _controls.TextCtrl_GetSelection(*args, **kwargs)
def GetStringSelection(*args, **kwargs):
- """GetStringSelection() -> wxString"""
+ """GetStringSelection() -> String"""
return _controls.TextCtrl_GetStringSelection(*args, **kwargs)
def Clear(*args, **kwargs):
return _controls.TextCtrl_Clear(*args, **kwargs)
def Replace(*args, **kwargs):
- """Replace(long from, long to, wxString value)"""
+ """Replace(long from, long to, String value)"""
return _controls.TextCtrl_Replace(*args, **kwargs)
def Remove(*args, **kwargs):
return _controls.TextCtrl_Remove(*args, **kwargs)
def LoadFile(*args, **kwargs):
- """LoadFile(wxString file) -> bool"""
+ """LoadFile(String file) -> bool"""
return _controls.TextCtrl_LoadFile(*args, **kwargs)
def SaveFile(*args, **kwargs):
- """SaveFile(wxString file=wxPyEmptyString) -> bool"""
+ """SaveFile(String file=EmptyString) -> bool"""
return _controls.TextCtrl_SaveFile(*args, **kwargs)
def MarkDirty(*args, **kwargs):
return _controls.TextCtrl_SetMaxLength(*args, **kwargs)
def WriteText(*args, **kwargs):
- """WriteText(wxString text)"""
+ """WriteText(String text)"""
return _controls.TextCtrl_WriteText(*args, **kwargs)
def AppendText(*args, **kwargs):
- """AppendText(wxString text)"""
+ """AppendText(String text)"""
return _controls.TextCtrl_AppendText(*args, **kwargs)
def EmulateKeyPress(*args, **kwargs):
return _controls.TextCtrl_HideNativeCaret(*args, **kwargs)
def write(*args, **kwargs):
- """write(wxString text)"""
+ """write(String text)"""
return _controls.TextCtrl_write(*args, **kwargs)
def GetString(*args, **kwargs):
- """GetString(long from, long to) -> wxString"""
+ """GetString(long from, long to) -> String"""
return _controls.TextCtrl_GetString(*args, **kwargs)
"""
__init__(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=SB_HORIZONTAL,
- Validator validator=DefaultValidator, wxString name=wxPyScrollBarNameStr) -> ScrollBar
+ Validator validator=DefaultValidator, String name=ScrollBarNameStr) -> ScrollBar
"""
newobj = _controls.new_ScrollBar(*args, **kwargs)
self.this = newobj.this
"""
Create(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=SB_HORIZONTAL,
- Validator validator=DefaultValidator, wxString name=wxPyScrollBarNameStr) -> bool
+ Validator validator=DefaultValidator, String name=ScrollBarNameStr) -> bool
"""
return _controls.ScrollBar_Create(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ScrollBar
_controls.ScrollBar_swigregister(ScrollBarPtr)
+ScrollBarNameStr = cvar.ScrollBarNameStr
def PreScrollBar(*args, **kwargs):
"""PreScrollBar() -> ScrollBar"""
"""
__init__(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=SP_HORIZONTAL,
- wxString name=wxPySPIN_BUTTON_NAME) -> SpinButton
+ String name=SPIN_BUTTON_NAME) -> SpinButton
"""
newobj = _controls.new_SpinButton(*args, **kwargs)
self.this = newobj.this
"""
Create(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=SP_HORIZONTAL,
- wxString name=wxPySPIN_BUTTON_NAME) -> bool
+ String name=SPIN_BUTTON_NAME) -> bool
"""
return _controls.SpinButton_Create(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = SpinButton
_controls.SpinButton_swigregister(SpinButtonPtr)
+SPIN_BUTTON_NAME = cvar.SPIN_BUTTON_NAME
+SpinCtrlNameStr = cvar.SpinCtrlNameStr
def PreSpinButton(*args, **kwargs):
"""PreSpinButton() -> SpinButton"""
return "<%s.%s; proxy of C++ wxSpinCtrl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id=-1, wxString value=wxPyEmptyString,
+ __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, wxString name=wxPySpinCtrlNameStr) -> SpinCtrl
+ long style=SP_ARROW_KEYS, int min=0, int max=100,
+ int initial=0, String name=SpinCtrlNameStr) -> SpinCtrl
"""
newobj = _controls.new_SpinCtrl(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id=-1, wxString value=wxPyEmptyString,
+ 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, wxString name=wxPySpinCtrlNameStr) -> bool
+ long style=SP_ARROW_KEYS, int min=0, int max=100,
+ int initial=0, String name=SpinCtrlNameStr) -> bool
"""
return _controls.SpinCtrl_Create(*args, **kwargs)
return _controls.SpinCtrl_SetValue(*args, **kwargs)
def SetValueString(*args, **kwargs):
- """SetValueString(wxString text)"""
+ """SetValueString(String text)"""
return _controls.SpinCtrl_SetValueString(*args, **kwargs)
def SetRange(*args, **kwargs):
return "<%s.%s; proxy of C++ wxRadioBox instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString label, Point point=DefaultPosition,
+ __init__(Window parent, int id, String label, Point point=DefaultPosition,
Size size=DefaultSize, int choices=0,
- wxString choices_array=None, int majorDimension=0,
+ String choices_array=None, int majorDimension=0,
long style=RA_HORIZONTAL, Validator validator=DefaultValidator,
- wxString name=wxPyRadioBoxNameStr) -> RadioBox
+ String name=RadioBoxNameStr) -> RadioBox
"""
newobj = _controls.new_RadioBox(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxString label, Point point=DefaultPosition,
+ Create(Window parent, int id, String label, Point point=DefaultPosition,
Size size=DefaultSize, int choices=0,
- wxString choices_array=None, int majorDimension=0,
+ String choices_array=None, int majorDimension=0,
long style=RA_HORIZONTAL, Validator validator=DefaultValidator,
- wxString name=wxPyRadioBoxNameStr) -> bool
+ String name=RadioBoxNameStr) -> bool
"""
return _controls.RadioBox_Create(*args, **kwargs)
return _controls.RadioBox_GetSelection(*args, **kwargs)
def GetStringSelection(*args, **kwargs):
- """GetStringSelection() -> wxString"""
+ """GetStringSelection() -> String"""
return _controls.RadioBox_GetStringSelection(*args, **kwargs)
def SetStringSelection(*args, **kwargs):
- """SetStringSelection(wxString s) -> bool"""
+ """SetStringSelection(String s) -> bool"""
return _controls.RadioBox_SetStringSelection(*args, **kwargs)
def GetCount(*args, **kwargs):
return _controls.RadioBox_GetCount(*args, **kwargs)
def FindString(*args, **kwargs):
- """FindString(wxString s) -> int"""
+ """FindString(String s) -> int"""
return _controls.RadioBox_FindString(*args, **kwargs)
def GetString(*args, **kwargs):
- """GetString(int n) -> wxString"""
+ """GetString(int n) -> String"""
return _controls.RadioBox_GetString(*args, **kwargs)
def SetString(*args, **kwargs):
- """SetString(int n, wxString label)"""
+ """SetString(int n, String label)"""
return _controls.RadioBox_SetString(*args, **kwargs)
GetItemLabel = GetString
return _controls.RadioBox_GetRowCount(*args, **kwargs)
def GetNextItem(*args, **kwargs):
- """GetNextItem(int item, wxDirection dir, long style) -> int"""
+ """GetNextItem(int item, int dir, long style) -> int"""
return _controls.RadioBox_GetNextItem(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = RadioBox
_controls.RadioBox_swigregister(RadioBoxPtr)
+RadioBoxNameStr = cvar.RadioBoxNameStr
+RadioButtonNameStr = cvar.RadioButtonNameStr
def PreRadioBox(*args, **kwargs):
"""PreRadioBox() -> RadioBox"""
return "<%s.%s; proxy of C++ wxRadioButton instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString label, Point pos=DefaultPosition,
+ __init__(Window parent, int id, String label, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- Validator validator=DefaultValidator,
- wxString name=wxPyRadioButtonNameStr) -> RadioButton
+ Validator validator=DefaultValidator, String name=RadioButtonNameStr) -> RadioButton
"""
newobj = _controls.new_RadioButton(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxString label, Point pos=DefaultPosition,
+ Create(Window parent, int id, String label, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- Validator validator=DefaultValidator,
- wxString name=wxPyRadioButtonNameStr) -> bool
+ Validator validator=DefaultValidator, String name=RadioButtonNameStr) -> bool
"""
return _controls.RadioButton_Create(*args, **kwargs)
__init__(Window parent, int id, int value, int minValue, int maxValue,
Point point=DefaultPosition, Size size=DefaultSize,
long style=SL_HORIZONTAL, Validator validator=DefaultValidator,
- wxString name=wxPySliderNameStr) -> Slider
+ String name=SliderNameStr) -> Slider
"""
newobj = _controls.new_Slider(*args, **kwargs)
self.this = newobj.this
Create(Window parent, int id, int value, int minValue, int maxValue,
Point point=DefaultPosition, Size size=DefaultSize,
long style=SL_HORIZONTAL, Validator validator=DefaultValidator,
- wxString name=wxPySliderNameStr) -> bool
+ String name=SliderNameStr) -> bool
"""
return _controls.Slider_Create(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Slider
_controls.Slider_swigregister(SliderPtr)
+SliderNameStr = cvar.SliderNameStr
def PreSlider(*args, **kwargs):
"""PreSlider() -> Slider"""
return "<%s.%s; proxy of C++ wxToggleButton instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString label, Point pos=DefaultPosition,
+ __init__(Window parent, int id, String label, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- Validator validator=DefaultValidator,
- wxString name=wxPyToggleButtonNameStr) -> ToggleButton
+ Validator validator=DefaultValidator, String name=ToggleButtonNameStr) -> ToggleButton
"""
newobj = _controls.new_ToggleButton(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxString label, Point pos=DefaultPosition,
+ Create(Window parent, int id, String label, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- Validator validator=DefaultValidator,
- wxString name=wxPyToggleButtonNameStr) -> bool
+ Validator validator=DefaultValidator, String name=ToggleButtonNameStr) -> bool
"""
return _controls.ToggleButton_Create(*args, **kwargs)
return _controls.ToggleButton_GetValue(*args, **kwargs)
def SetLabel(*args, **kwargs):
- """SetLabel(wxString label)"""
+ """SetLabel(String label)"""
return _controls.ToggleButton_SetLabel(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ToggleButton
_controls.ToggleButton_swigregister(ToggleButtonPtr)
+ToggleButtonNameStr = cvar.ToggleButtonNameStr
def PreToggleButton(*args, **kwargs):
"""PreToggleButton() -> ToggleButton"""
return _controls.BookCtrl_GetSelection(*args, **kwargs)
def SetPageText(*args, **kwargs):
- """SetPageText(size_t n, wxString strText) -> bool"""
+ """SetPageText(size_t n, String strText) -> bool"""
return _controls.BookCtrl_SetPageText(*args, **kwargs)
def GetPageText(*args, **kwargs):
- """GetPageText(size_t n) -> wxString"""
+ """GetPageText(size_t n) -> String"""
return _controls.BookCtrl_GetPageText(*args, **kwargs)
def SetImageList(*args, **kwargs):
- """SetImageList(wxImageList imageList)"""
+ """SetImageList(ImageList imageList)"""
return _controls.BookCtrl_SetImageList(*args, **kwargs)
def AssignImageList(*args, **kwargs):
- """AssignImageList(wxImageList imageList)"""
+ """AssignImageList(ImageList imageList)"""
val = _controls.BookCtrl_AssignImageList(*args, **kwargs)
args[1].thisown = 0
return val
def GetImageList(*args, **kwargs):
- """GetImageList() -> wxImageList"""
+ """GetImageList() -> ImageList"""
return _controls.BookCtrl_GetImageList(*args, **kwargs)
def GetPageImage(*args, **kwargs):
return _controls.BookCtrl_DeleteAllPages(*args, **kwargs)
def AddPage(*args, **kwargs):
- """AddPage(Window page, wxString text, bool select=False, int imageId=-1) -> bool"""
+ """AddPage(Window page, String text, bool select=False, int imageId=-1) -> bool"""
return _controls.BookCtrl_AddPage(*args, **kwargs)
def InsertPage(*args, **kwargs):
"""
- InsertPage(size_t n, Window page, wxString text, bool select=False,
+ InsertPage(size_t n, Window page, String text, bool select=False,
int imageId=-1) -> bool
"""
return _controls.BookCtrl_InsertPage(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = BookCtrl
_controls.BookCtrl_swigregister(BookCtrlPtr)
+NOTEBOOK_NAME = cvar.NOTEBOOK_NAME
class BookCtrlEvent(core.NotifyEvent):
def __repr__(self):
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- long style=0, wxString name=wxPyNOTEBOOK_NAME) -> Notebook
+ long style=0, String name=NOTEBOOK_NAME) -> Notebook
"""
newobj = _controls.new_Notebook(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- long style=0, wxString name=wxPyNOTEBOOK_NAME) -> bool
+ long style=0, String name=NOTEBOOK_NAME) -> bool
"""
return _controls.Notebook_Create(*args, **kwargs)
return _controls.Notebook_CalcSizeFromPage(*args, **kwargs)
def ApplyThemeBackground(*args, **kwargs):
- """ApplyThemeBackground(Window window, wxColour colour)"""
+ """ApplyThemeBackground(Window window, Colour colour)"""
return _controls.Notebook_ApplyThemeBackground(*args, **kwargs)
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- long style=0, wxString name=wxPyEmptyString) -> Listbook
+ long style=0, String name=EmptyString) -> Listbook
"""
newobj = _controls.new_Listbook(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- long style=0, wxString name=wxPyEmptyString) -> bool
+ long style=0, String name=EmptyString) -> bool
"""
return _controls.Listbook_Create(*args, **kwargs)
return _controls.ToolBarToolBase_GetStyle(*args, **kwargs)
def GetKind(*args, **kwargs):
- """GetKind() -> wxItemKind"""
+ """GetKind() -> int"""
return _controls.ToolBarToolBase_GetKind(*args, **kwargs)
def IsEnabled(*args, **kwargs):
return _controls.ToolBarToolBase_CanBeToggled(*args, **kwargs)
def GetNormalBitmap(*args, **kwargs):
- """GetNormalBitmap() -> wxBitmap"""
+ """GetNormalBitmap() -> Bitmap"""
return _controls.ToolBarToolBase_GetNormalBitmap(*args, **kwargs)
def GetDisabledBitmap(*args, **kwargs):
- """GetDisabledBitmap() -> wxBitmap"""
+ """GetDisabledBitmap() -> Bitmap"""
return _controls.ToolBarToolBase_GetDisabledBitmap(*args, **kwargs)
def GetBitmap(*args, **kwargs):
- """GetBitmap() -> wxBitmap"""
+ """GetBitmap() -> Bitmap"""
return _controls.ToolBarToolBase_GetBitmap(*args, **kwargs)
def GetLabel(*args, **kwargs):
- """GetLabel() -> wxString"""
+ """GetLabel() -> String"""
return _controls.ToolBarToolBase_GetLabel(*args, **kwargs)
def GetShortHelp(*args, **kwargs):
- """GetShortHelp() -> wxString"""
+ """GetShortHelp() -> String"""
return _controls.ToolBarToolBase_GetShortHelp(*args, **kwargs)
def GetLongHelp(*args, **kwargs):
- """GetLongHelp() -> wxString"""
+ """GetLongHelp() -> String"""
return _controls.ToolBarToolBase_GetLongHelp(*args, **kwargs)
def Enable(*args, **kwargs):
return _controls.ToolBarToolBase_SetToggle(*args, **kwargs)
def SetShortHelp(*args, **kwargs):
- """SetShortHelp(wxString help) -> bool"""
+ """SetShortHelp(String help) -> bool"""
return _controls.ToolBarToolBase_SetShortHelp(*args, **kwargs)
def SetLongHelp(*args, **kwargs):
- """SetLongHelp(wxString help) -> bool"""
+ """SetLongHelp(String help) -> bool"""
return _controls.ToolBarToolBase_SetLongHelp(*args, **kwargs)
def SetNormalBitmap(*args, **kwargs):
- """SetNormalBitmap(wxBitmap bmp)"""
+ """SetNormalBitmap(Bitmap bmp)"""
return _controls.ToolBarToolBase_SetNormalBitmap(*args, **kwargs)
def SetDisabledBitmap(*args, **kwargs):
- """SetDisabledBitmap(wxBitmap bmp)"""
+ """SetDisabledBitmap(Bitmap bmp)"""
return _controls.ToolBarToolBase_SetDisabledBitmap(*args, **kwargs)
def SetLabel(*args, **kwargs):
- """SetLabel(wxString label)"""
+ """SetLabel(String label)"""
return _controls.ToolBarToolBase_SetLabel(*args, **kwargs)
def Detach(*args, **kwargs):
return "<%s.%s; proxy of C++ wxToolBarBase instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def DoAddTool(*args, **kwargs):
"""
- DoAddTool(int id, wxString label, wxBitmap bitmap, wxBitmap bmpDisabled=wxNullBitmap,
- wxItemKind kind=ITEM_NORMAL,
- wxString shortHelp=wxPyEmptyString,
- wxString longHelp=wxPyEmptyString, PyObject clientData=None) -> ToolBarToolBase
+ DoAddTool(int id, String label, Bitmap bitmap, Bitmap bmpDisabled=wxNullBitmap,
+ int kind=ITEM_NORMAL, String shortHelp=EmptyString,
+ String longHelp=EmptyString,
+ PyObject clientData=None) -> ToolBarToolBase
"""
return _controls.ToolBarBase_DoAddTool(*args, **kwargs)
def DoInsertTool(*args, **kwargs):
"""
- DoInsertTool(size_t pos, int id, wxString label, wxBitmap bitmap,
- wxBitmap bmpDisabled=wxNullBitmap, wxItemKind kind=ITEM_NORMAL,
- wxString shortHelp=wxPyEmptyString,
- wxString longHelp=wxPyEmptyString,
+ 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
"""
return _controls.ToolBarBase_DoInsertTool(*args, **kwargs)
return self.DoAddTool(id, '', bitmap, bmpDisabled, wx.ITEM_RADIO,
shortHelp, longHelp, clientData)
+ def AddToolItem(*args, **kwargs):
+ """AddToolItem(ToolBarToolBase tool) -> ToolBarToolBase"""
+ return _controls.ToolBarBase_AddToolItem(*args, **kwargs)
+
+ def InsertToolItem(*args, **kwargs):
+ """InsertToolItem(size_t pos, ToolBarToolBase tool) -> ToolBarToolBase"""
+ return _controls.ToolBarBase_InsertToolItem(*args, **kwargs)
+
def AddControl(*args, **kwargs):
"""AddControl(Control control) -> ToolBarToolBase"""
return _controls.ToolBarBase_AddControl(*args, **kwargs)
return _controls.ToolBarBase_GetToolEnabled(*args, **kwargs)
def SetToolShortHelp(*args, **kwargs):
- """SetToolShortHelp(int id, wxString helpString)"""
+ """SetToolShortHelp(int id, String helpString)"""
return _controls.ToolBarBase_SetToolShortHelp(*args, **kwargs)
def GetToolShortHelp(*args, **kwargs):
- """GetToolShortHelp(int id) -> wxString"""
+ """GetToolShortHelp(int id) -> String"""
return _controls.ToolBarBase_GetToolShortHelp(*args, **kwargs)
def SetToolLongHelp(*args, **kwargs):
- """SetToolLongHelp(int id, wxString helpString)"""
+ """SetToolLongHelp(int id, String helpString)"""
return _controls.ToolBarBase_SetToolLongHelp(*args, **kwargs)
def GetToolLongHelp(*args, **kwargs):
- """GetToolLongHelp(int id) -> wxString"""
+ """GetToolLongHelp(int id) -> String"""
return _controls.ToolBarBase_GetToolLongHelp(*args, **kwargs)
def SetMarginsXY(*args, **kwargs):
"""FindToolForPosition(int x, int y) -> ToolBarToolBase"""
return _controls.ToolBarBase_FindToolForPosition(*args, **kwargs)
+ def FindById(*args, **kwargs):
+ """FindById(int toolid) -> ToolBarToolBase"""
+ return _controls.ToolBarBase_FindById(*args, **kwargs)
+
def IsVertical(*args, **kwargs):
"""IsVertical() -> bool"""
return _controls.ToolBarBase_IsVertical(*args, **kwargs)
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxNO_BORDER|wxTB_HORIZONTAL,
- wxString name=wxPyToolBarNameStr) -> ToolBar
+ String name=wxPyToolBarNameStr) -> ToolBar
"""
newobj = _controls.new_ToolBar(*args, **kwargs)
self.this = newobj.this
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxNO_BORDER|wxTB_HORIZONTAL,
- wxString name=wxPyToolBarNameStr) -> bool
+ String name=wxPyToolBarNameStr) -> bool
"""
return _controls.ToolBar_Create(*args, **kwargs)
return "<%s.%s; proxy of C++ wxListItemAttr instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(wxColour colText=wxNullColour, wxColour colBack=wxNullColour,
- wxFont font=wxNullFont) -> ListItemAttr
+ __init__(Colour colText=wxNullColour, Colour colBack=wxNullColour,
+ Font font=wxNullFont) -> ListItemAttr
"""
newobj = _controls.new_ListItemAttr(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def SetTextColour(*args, **kwargs):
- """SetTextColour(wxColour colText)"""
+ """SetTextColour(Colour colText)"""
return _controls.ListItemAttr_SetTextColour(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
- """SetBackgroundColour(wxColour colBack)"""
+ """SetBackgroundColour(Colour colBack)"""
return _controls.ListItemAttr_SetBackgroundColour(*args, **kwargs)
def SetFont(*args, **kwargs):
- """SetFont(wxFont font)"""
+ """SetFont(Font font)"""
return _controls.ListItemAttr_SetFont(*args, **kwargs)
def HasTextColour(*args, **kwargs):
return _controls.ListItemAttr_HasFont(*args, **kwargs)
def GetTextColour(*args, **kwargs):
- """GetTextColour() -> wxColour"""
+ """GetTextColour() -> Colour"""
return _controls.ListItemAttr_GetTextColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
- """GetBackgroundColour() -> wxColour"""
+ """GetBackgroundColour() -> Colour"""
return _controls.ListItemAttr_GetBackgroundColour(*args, **kwargs)
def GetFont(*args, **kwargs):
- """GetFont() -> wxFont"""
+ """GetFont() -> Font"""
return _controls.ListItemAttr_GetFont(*args, **kwargs)
def Destroy(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ListItemAttr
_controls.ListItemAttr_swigregister(ListItemAttrPtr)
+ListCtrlNameStr = cvar.ListCtrlNameStr
#---------------------------------------------------------------------------
return _controls.ListItem_SetStateMask(*args, **kwargs)
def SetText(*args, **kwargs):
- """SetText(wxString text)"""
+ """SetText(String text)"""
return _controls.ListItem_SetText(*args, **kwargs)
def SetImage(*args, **kwargs):
return _controls.ListItem_SetWidth(*args, **kwargs)
def SetAlign(*args, **kwargs):
- """SetAlign(wxListColumnFormat align)"""
+ """SetAlign(int align)"""
return _controls.ListItem_SetAlign(*args, **kwargs)
def SetTextColour(*args, **kwargs):
- """SetTextColour(wxColour colText)"""
+ """SetTextColour(Colour colText)"""
return _controls.ListItem_SetTextColour(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
- """SetBackgroundColour(wxColour colBack)"""
+ """SetBackgroundColour(Colour colBack)"""
return _controls.ListItem_SetBackgroundColour(*args, **kwargs)
def SetFont(*args, **kwargs):
- """SetFont(wxFont font)"""
+ """SetFont(Font font)"""
return _controls.ListItem_SetFont(*args, **kwargs)
def GetMask(*args, **kwargs):
return _controls.ListItem_GetState(*args, **kwargs)
def GetText(*args, **kwargs):
- """GetText() -> wxString"""
+ """GetText() -> String"""
return _controls.ListItem_GetText(*args, **kwargs)
def GetImage(*args, **kwargs):
return _controls.ListItem_GetWidth(*args, **kwargs)
def GetAlign(*args, **kwargs):
- """GetAlign() -> wxListColumnFormat"""
+ """GetAlign() -> int"""
return _controls.ListItem_GetAlign(*args, **kwargs)
def GetAttributes(*args, **kwargs):
return _controls.ListItem_HasAttributes(*args, **kwargs)
def GetTextColour(*args, **kwargs):
- """GetTextColour() -> wxColour"""
+ """GetTextColour() -> Colour"""
return _controls.ListItem_GetTextColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
- """GetBackgroundColour() -> wxColour"""
+ """GetBackgroundColour() -> Colour"""
return _controls.ListItem_GetBackgroundColour(*args, **kwargs)
def GetFont(*args, **kwargs):
- """GetFont() -> wxFont"""
+ """GetFont() -> Font"""
return _controls.ListItem_GetFont(*args, **kwargs)
m_mask = property(_controls.ListItem_m_mask_get, _controls.ListItem_m_mask_set)
GetPosition = GetPoint
def GetLabel(*args, **kwargs):
- """GetLabel() -> wxString"""
+ """GetLabel() -> String"""
return _controls.ListEvent_GetLabel(*args, **kwargs)
def GetText(*args, **kwargs):
- """GetText() -> wxString"""
+ """GetText() -> String"""
return _controls.ListEvent_GetText(*args, **kwargs)
def GetImage(*args, **kwargs):
"""
__init__(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=LC_ICON,
- Validator validator=DefaultValidator, wxString name=wxPyListCtrlNameStr) -> ListCtrl
+ Validator validator=DefaultValidator, String name=ListCtrlNameStr) -> ListCtrl
"""
newobj = _controls.new_ListCtrl(*args, **kwargs)
self.this = newobj.this
"""
Create(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=LC_ICON,
- Validator validator=DefaultValidator, wxString name=wxPyListCtrlNameStr) -> bool
+ Validator validator=DefaultValidator, String name=ListCtrlNameStr) -> bool
"""
return _controls.ListCtrl_Create(*args, **kwargs)
return _controls.ListCtrl__setCallbackInfo(*args, **kwargs)
def SetForegroundColour(*args, **kwargs):
- """SetForegroundColour(wxColour col) -> bool"""
+ """SetForegroundColour(Colour col) -> bool"""
return _controls.ListCtrl_SetForegroundColour(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
- """SetBackgroundColour(wxColour col) -> bool"""
+ """SetBackgroundColour(Colour col) -> bool"""
return _controls.ListCtrl_SetBackgroundColour(*args, **kwargs)
def GetColumn(*args, **kwargs):
return _controls.ListCtrl_SetItem(*args, **kwargs)
def SetStringItem(*args, **kwargs):
- """SetStringItem(long index, int col, wxString label, int imageId=-1) -> long"""
+ """SetStringItem(long index, int col, String label, int imageId=-1) -> long"""
return _controls.ListCtrl_SetStringItem(*args, **kwargs)
def GetItemState(*args, **kwargs):
return _controls.ListCtrl_SetItemImage(*args, **kwargs)
def GetItemText(*args, **kwargs):
- """GetItemText(long item) -> wxString"""
+ """GetItemText(long item) -> String"""
return _controls.ListCtrl_GetItemText(*args, **kwargs)
def SetItemText(*args, **kwargs):
- """SetItemText(long item, wxString str)"""
+ """SetItemText(long item, String str)"""
return _controls.ListCtrl_SetItemText(*args, **kwargs)
def GetItemData(*args, **kwargs):
return _controls.ListCtrl_GetSelectedItemCount(*args, **kwargs)
def GetTextColour(*args, **kwargs):
- """GetTextColour() -> wxColour"""
+ """GetTextColour() -> Colour"""
return _controls.ListCtrl_GetTextColour(*args, **kwargs)
def SetTextColour(*args, **kwargs):
- """SetTextColour(wxColour col)"""
+ """SetTextColour(Colour col)"""
return _controls.ListCtrl_SetTextColour(*args, **kwargs)
def GetTopItem(*args, **kwargs):
return _controls.ListCtrl_GetNextItem(*args, **kwargs)
def GetImageList(*args, **kwargs):
- """GetImageList(int which) -> wxImageList"""
+ """GetImageList(int which) -> ImageList"""
return _controls.ListCtrl_GetImageList(*args, **kwargs)
def SetImageList(*args, **kwargs):
- """SetImageList(wxImageList imageList, int which)"""
+ """SetImageList(ImageList imageList, int which)"""
return _controls.ListCtrl_SetImageList(*args, **kwargs)
def AssignImageList(*args, **kwargs):
- """AssignImageList(wxImageList imageList, int which)"""
+ """AssignImageList(ImageList imageList, int which)"""
val = _controls.ListCtrl_AssignImageList(*args, **kwargs)
args[1].thisown = 0
return val
return _controls.ListCtrl_EnsureVisible(*args, **kwargs)
def FindItem(*args, **kwargs):
- """FindItem(long start, wxString str, bool partial=False) -> long"""
+ """FindItem(long start, String str, bool partial=False) -> long"""
return _controls.ListCtrl_FindItem(*args, **kwargs)
def FindItemData(*args, **kwargs):
return _controls.ListCtrl_InsertItem(*args, **kwargs)
def InsertStringItem(*args, **kwargs):
- """InsertStringItem(long index, wxString label) -> long"""
+ """InsertStringItem(long index, String label) -> long"""
return _controls.ListCtrl_InsertStringItem(*args, **kwargs)
def InsertImageItem(*args, **kwargs):
return _controls.ListCtrl_InsertImageItem(*args, **kwargs)
def InsertImageStringItem(*args, **kwargs):
- """InsertImageStringItem(long index, wxString label, int imageIndex) -> long"""
+ """InsertImageStringItem(long index, String label, int imageIndex) -> long"""
return _controls.ListCtrl_InsertImageStringItem(*args, **kwargs)
def InsertColumnInfo(*args, **kwargs):
def InsertColumn(*args, **kwargs):
"""
- InsertColumn(long col, wxString heading, int format=LIST_FORMAT_LEFT,
+ InsertColumn(long col, String heading, int format=LIST_FORMAT_LEFT,
int width=-1) -> long
"""
return _controls.ListCtrl_InsertColumn(*args, **kwargs)
return _controls.ListCtrl_ScrollList(*args, **kwargs)
def SetItemTextColour(*args, **kwargs):
- """SetItemTextColour(long item, wxColour col)"""
+ """SetItemTextColour(long item, Colour col)"""
return _controls.ListCtrl_SetItemTextColour(*args, **kwargs)
def GetItemTextColour(*args, **kwargs):
- """GetItemTextColour(long item) -> wxColour"""
+ """GetItemTextColour(long item) -> Colour"""
return _controls.ListCtrl_GetItemTextColour(*args, **kwargs)
def SetItemBackgroundColour(*args, **kwargs):
- """SetItemBackgroundColour(long item, wxColour col)"""
+ """SetItemBackgroundColour(long item, Colour col)"""
return _controls.ListCtrl_SetItemBackgroundColour(*args, **kwargs)
def GetItemBackgroundColour(*args, **kwargs):
- """GetItemBackgroundColour(long item) -> wxColour"""
+ """GetItemBackgroundColour(long item) -> Colour"""
return _controls.ListCtrl_GetItemBackgroundColour(*args, **kwargs)
#
"""
__init__(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=LC_REPORT,
- Validator validator=DefaultValidator, wxString name=wxPyListCtrlNameStr) -> ListView
+ Validator validator=DefaultValidator, String name=ListCtrlNameStr) -> ListView
"""
newobj = _controls.new_ListView(*args, **kwargs)
self.this = newobj.this
"""
Create(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=LC_REPORT,
- Validator validator=DefaultValidator, wxString name=wxPyListCtrlNameStr) -> bool
+ Validator validator=DefaultValidator, String name=ListCtrlNameStr) -> bool
"""
return _controls.ListView_Create(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = TreeItemId
_controls.TreeItemId_swigregister(TreeItemIdPtr)
+TreeCtrlNameStr = cvar.TreeCtrlNameStr
class TreeItemData(object):
def __repr__(self):
return _controls.TreeEvent_SetKeyEvent(*args, **kwargs)
def GetLabel(*args, **kwargs):
- """GetLabel() -> wxString"""
+ """GetLabel() -> String"""
return _controls.TreeEvent_GetLabel(*args, **kwargs)
def SetLabel(*args, **kwargs):
- """SetLabel(wxString label)"""
+ """SetLabel(String label)"""
return _controls.TreeEvent_SetLabel(*args, **kwargs)
def IsEditCancelled(*args, **kwargs):
return _controls.TreeEvent_SetEditCanceled(*args, **kwargs)
def SetToolTip(*args, **kwargs):
- """SetToolTip(wxString toolTip)"""
+ """SetToolTip(String toolTip)"""
return _controls.TreeEvent_SetToolTip(*args, **kwargs)
__init__(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=TR_DEFAULT_STYLE,
Validator validator=DefaultValidator,
- wxString name=wxPy_TreeCtrlNameStr) -> TreeCtrl
+ String name=TreeCtrlNameStr) -> TreeCtrl
"""
newobj = _controls.new_TreeCtrl(*args, **kwargs)
self.this = newobj.this
Create(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=TR_DEFAULT_STYLE,
Validator validator=DefaultValidator,
- wxString name=wxPy_TreeCtrlNameStr) -> bool
+ String name=TreeCtrlNameStr) -> bool
"""
return _controls.TreeCtrl_Create(*args, **kwargs)
return _controls.TreeCtrl_SetSpacing(*args, **kwargs)
def GetImageList(*args, **kwargs):
- """GetImageList() -> wxImageList"""
+ """GetImageList() -> ImageList"""
return _controls.TreeCtrl_GetImageList(*args, **kwargs)
def GetStateImageList(*args, **kwargs):
- """GetStateImageList() -> wxImageList"""
+ """GetStateImageList() -> ImageList"""
return _controls.TreeCtrl_GetStateImageList(*args, **kwargs)
def SetImageList(*args, **kwargs):
- """SetImageList(wxImageList imageList)"""
+ """SetImageList(ImageList imageList)"""
return _controls.TreeCtrl_SetImageList(*args, **kwargs)
def SetStateImageList(*args, **kwargs):
- """SetStateImageList(wxImageList imageList)"""
+ """SetStateImageList(ImageList imageList)"""
return _controls.TreeCtrl_SetStateImageList(*args, **kwargs)
def AssignImageList(*args, **kwargs):
- """AssignImageList(wxImageList imageList)"""
+ """AssignImageList(ImageList imageList)"""
val = _controls.TreeCtrl_AssignImageList(*args, **kwargs)
args[1].thisown = 0
return val
def AssignStateImageList(*args, **kwargs):
- """AssignStateImageList(wxImageList imageList)"""
+ """AssignStateImageList(ImageList imageList)"""
val = _controls.TreeCtrl_AssignStateImageList(*args, **kwargs)
args[1].thisown = 0
return val
def GetItemText(*args, **kwargs):
- """GetItemText(TreeItemId item) -> wxString"""
+ """GetItemText(TreeItemId item) -> String"""
return _controls.TreeCtrl_GetItemText(*args, **kwargs)
def GetItemImage(*args, **kwargs):
- """GetItemImage(TreeItemId item, wxTreeItemIcon which=TreeItemIcon_Normal) -> int"""
+ """GetItemImage(TreeItemId item, int which=TreeItemIcon_Normal) -> int"""
return _controls.TreeCtrl_GetItemImage(*args, **kwargs)
def GetItemData(*args, **kwargs):
GetPyData = GetItemPyData
def GetItemTextColour(*args, **kwargs):
- """GetItemTextColour(TreeItemId item) -> wxColour"""
+ """GetItemTextColour(TreeItemId item) -> Colour"""
return _controls.TreeCtrl_GetItemTextColour(*args, **kwargs)
def GetItemBackgroundColour(*args, **kwargs):
- """GetItemBackgroundColour(TreeItemId item) -> wxColour"""
+ """GetItemBackgroundColour(TreeItemId item) -> Colour"""
return _controls.TreeCtrl_GetItemBackgroundColour(*args, **kwargs)
def GetItemFont(*args, **kwargs):
- """GetItemFont(TreeItemId item) -> wxFont"""
+ """GetItemFont(TreeItemId item) -> Font"""
return _controls.TreeCtrl_GetItemFont(*args, **kwargs)
def SetItemText(*args, **kwargs):
- """SetItemText(TreeItemId item, wxString text)"""
+ """SetItemText(TreeItemId item, String text)"""
return _controls.TreeCtrl_SetItemText(*args, **kwargs)
def SetItemImage(*args, **kwargs):
- """SetItemImage(TreeItemId item, int image, wxTreeItemIcon which=TreeItemIcon_Normal)"""
+ """SetItemImage(TreeItemId item, int image, int which=TreeItemIcon_Normal)"""
return _controls.TreeCtrl_SetItemImage(*args, **kwargs)
def SetItemData(*args, **kwargs):
return _controls.TreeCtrl_SetItemDropHighlight(*args, **kwargs)
def SetItemTextColour(*args, **kwargs):
- """SetItemTextColour(TreeItemId item, wxColour col)"""
+ """SetItemTextColour(TreeItemId item, Colour col)"""
return _controls.TreeCtrl_SetItemTextColour(*args, **kwargs)
def SetItemBackgroundColour(*args, **kwargs):
- """SetItemBackgroundColour(TreeItemId item, wxColour col)"""
+ """SetItemBackgroundColour(TreeItemId item, Colour col)"""
return _controls.TreeCtrl_SetItemBackgroundColour(*args, **kwargs)
def SetItemFont(*args, **kwargs):
- """SetItemFont(TreeItemId item, wxFont font)"""
+ """SetItemFont(TreeItemId item, Font font)"""
return _controls.TreeCtrl_SetItemFont(*args, **kwargs)
def IsVisible(*args, **kwargs):
return _controls.TreeCtrl_GetPrevVisible(*args, **kwargs)
def AddRoot(*args, **kwargs):
- """
- AddRoot(wxString text, int image=-1, int selectedImage=-1,
- TreeItemData data=None) -> TreeItemId
- """
+ """AddRoot(String text, int image=-1, int selectedImage=-1, TreeItemData data=None) -> TreeItemId"""
return _controls.TreeCtrl_AddRoot(*args, **kwargs)
def PrependItem(*args, **kwargs):
"""
- PrependItem(TreeItemId parent, wxString text, int image=-1, int selectedImage=-1,
+ PrependItem(TreeItemId parent, String text, int image=-1, int selectedImage=-1,
TreeItemData data=None) -> TreeItemId
"""
return _controls.TreeCtrl_PrependItem(*args, **kwargs)
def InsertItem(*args, **kwargs):
"""
- InsertItem(TreeItemId parent, TreeItemId idPrevious, wxString text,
+ InsertItem(TreeItemId parent, TreeItemId idPrevious, String text,
int image=-1, int selectedImage=-1, TreeItemData data=None) -> TreeItemId
"""
return _controls.TreeCtrl_InsertItem(*args, **kwargs)
def InsertItemBefore(*args, **kwargs):
"""
- InsertItemBefore(TreeItemId parent, size_t index, wxString text, int image=-1,
+ InsertItemBefore(TreeItemId parent, size_t index, String text, int image=-1,
int selectedImage=-1, TreeItemData data=None) -> TreeItemId
"""
return _controls.TreeCtrl_InsertItemBefore(*args, **kwargs)
def AppendItem(*args, **kwargs):
"""
- AppendItem(TreeItemId parent, wxString text, int image=-1, int selectedImage=-1,
+ AppendItem(TreeItemId parent, String text, int image=-1, int selectedImage=-1,
TreeItemData data=None) -> TreeItemId
"""
return _controls.TreeCtrl_AppendItem(*args, **kwargs)
return "<%s.%s; proxy of C++ wxGenericDirCtrl instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id=-1, wxString dir=wxPyDirDialogDefaultFolderStr,
- Point pos=DefaultPosition,
- Size size=DefaultSize, long style=wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER,
- wxString filter=wxPyEmptyString,
- int defaultFilter=0, wxString name=wxPy_TreeCtrlNameStr) -> GenericDirCtrl
+ __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
"""
newobj = _controls.new_GenericDirCtrl(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id=-1, wxString dir=wxPyDirDialogDefaultFolderStr,
- Point pos=DefaultPosition,
- Size size=DefaultSize, long style=wxDIRCTRL_3D_INTERNAL|wxSUNKEN_BORDER,
- wxString filter=wxPyEmptyString,
- int defaultFilter=0, wxString name=wxPy_TreeCtrlNameStr) -> bool
+ 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
"""
return _controls.GenericDirCtrl_Create(*args, **kwargs)
def ExpandPath(*args, **kwargs):
- """ExpandPath(wxString path) -> bool"""
+ """ExpandPath(String path) -> bool"""
return _controls.GenericDirCtrl_ExpandPath(*args, **kwargs)
def GetDefaultPath(*args, **kwargs):
- """GetDefaultPath() -> wxString"""
+ """GetDefaultPath() -> String"""
return _controls.GenericDirCtrl_GetDefaultPath(*args, **kwargs)
def SetDefaultPath(*args, **kwargs):
- """SetDefaultPath(wxString path)"""
+ """SetDefaultPath(String path)"""
return _controls.GenericDirCtrl_SetDefaultPath(*args, **kwargs)
def GetPath(*args, **kwargs):
- """GetPath() -> wxString"""
+ """GetPath() -> String"""
return _controls.GenericDirCtrl_GetPath(*args, **kwargs)
def GetFilePath(*args, **kwargs):
- """GetFilePath() -> wxString"""
+ """GetFilePath() -> String"""
return _controls.GenericDirCtrl_GetFilePath(*args, **kwargs)
def SetPath(*args, **kwargs):
- """SetPath(wxString path)"""
+ """SetPath(String path)"""
return _controls.GenericDirCtrl_SetPath(*args, **kwargs)
def ShowHidden(*args, **kwargs):
return _controls.GenericDirCtrl_GetShowHidden(*args, **kwargs)
def GetFilter(*args, **kwargs):
- """GetFilter() -> wxString"""
+ """GetFilter() -> String"""
return _controls.GenericDirCtrl_GetFilter(*args, **kwargs)
def SetFilter(*args, **kwargs):
- """SetFilter(wxString filter)"""
+ """SetFilter(String filter)"""
return _controls.GenericDirCtrl_SetFilter(*args, **kwargs)
def GetFilterIndex(*args, **kwargs):
return _controls.GenericDirCtrl_GetRootId(*args, **kwargs)
def GetTreeCtrl(*args, **kwargs):
- """GetTreeCtrl() -> wxTreeCtrl"""
+ """GetTreeCtrl() -> TreeCtrl"""
return _controls.GenericDirCtrl_GetTreeCtrl(*args, **kwargs)
def GetFilterListCtrl(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = GenericDirCtrl
_controls.GenericDirCtrl_swigregister(GenericDirCtrlPtr)
+DirDialogDefaultFolderStr = cvar.DirDialogDefaultFolderStr
def PreGenericDirCtrl(*args, **kwargs):
"""PreGenericDirCtrl() -> GenericDirCtrl"""
return _controls.DirFilterListCtrl_Create(*args, **kwargs)
def FillFilterList(*args, **kwargs):
- """FillFilterList(wxString filter, int defaultFilter)"""
+ """FillFilterList(String filter, int defaultFilter)"""
return _controls.DirFilterListCtrl_FillFilterList(*args, **kwargs)
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
- wxString name=wxPyControlNameStr) -> PyControl
+ String name=ControlNameStr) -> PyControl
"""
newobj = _controls.new_PyControl(*args, **kwargs)
self.this = newobj.this
return _controls.HelpEvent_SetPosition(*args, **kwargs)
def GetLink(*args, **kwargs):
- """GetLink() -> wxString"""
+ """GetLink() -> String"""
return _controls.HelpEvent_GetLink(*args, **kwargs)
def SetLink(*args, **kwargs):
- """SetLink(wxString link)"""
+ """SetLink(String link)"""
return _controls.HelpEvent_SetLink(*args, **kwargs)
def GetTarget(*args, **kwargs):
- """GetTarget() -> wxString"""
+ """GetTarget() -> String"""
return _controls.HelpEvent_GetTarget(*args, **kwargs)
def SetTarget(*args, **kwargs):
- """SetTarget(wxString target)"""
+ """SetTarget(String target)"""
return _controls.HelpEvent_SetTarget(*args, **kwargs)
Get = staticmethod(Get)
def GetHelp(*args, **kwargs):
- """GetHelp(Window window) -> wxString"""
+ """GetHelp(Window window) -> String"""
return _controls.HelpProvider_GetHelp(*args, **kwargs)
def ShowHelp(*args, **kwargs):
return _controls.HelpProvider_ShowHelp(*args, **kwargs)
def AddHelp(*args, **kwargs):
- """AddHelp(Window window, wxString text)"""
+ """AddHelp(Window window, String text)"""
return _controls.HelpProvider_AddHelp(*args, **kwargs)
def AddHelpById(*args, **kwargs):
- """AddHelpById(int id, wxString text)"""
+ """AddHelpById(int id, String text)"""
return _controls.HelpProvider_AddHelpById(*args, **kwargs)
def Destroy(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxGenericDragImage instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxBitmap image, wxCursor cursor=wxNullCursor) -> DragImage"""
+ """__init__(Bitmap image, Cursor cursor=wxNullCursor) -> DragImage"""
newobj = _controls.new_DragImage(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def SetBackingBitmap(*args, **kwargs):
- """SetBackingBitmap(wxBitmap bitmap)"""
+ """SetBackingBitmap(Bitmap bitmap)"""
return _controls.DragImage_SetBackingBitmap(*args, **kwargs)
def BeginDrag(*args, **kwargs):
return _controls.DragImage_GetImageRect(*args, **kwargs)
def DoDrawImage(*args, **kwargs):
- """DoDrawImage(wxDC dc, Point pos) -> bool"""
+ """DoDrawImage(DC dc, Point pos) -> bool"""
return _controls.DragImage_DoDrawImage(*args, **kwargs)
def UpdateBackingFromWindow(*args, **kwargs):
- """
- UpdateBackingFromWindow(wxDC windowDC, wxMemoryDC destDC, Rect sourceRect,
- Rect destRect) -> bool
- """
+ """UpdateBackingFromWindow(DC windowDC, MemoryDC destDC, Rect sourceRect, Rect destRect) -> bool"""
return _controls.DragImage_UpdateBackingFromWindow(*args, **kwargs)
def RedrawImage(*args, **kwargs):
_controls.DragImage_swigregister(DragImagePtr)
def DragIcon(*args, **kwargs):
- """DragIcon(wxIcon image, wxCursor cursor=wxNullCursor) -> DragImage"""
+ """DragIcon(Icon image, Cursor cursor=wxNullCursor) -> DragImage"""
val = _controls.new_DragIcon(*args, **kwargs)
val.thisown = 1
return val
def DragString(*args, **kwargs):
- """DragString(wxString str, wxCursor cursor=wxNullCursor) -> DragImage"""
+ """DragString(String str, Cursor cursor=wxNullCursor) -> DragImage"""
val = _controls.new_DragString(*args, **kwargs)
val.thisown = 1
return val
#include "wx/wxPython/wxPython.h"
#include "wx/wxPython/pyclasses.h"
- DECLARE_DEF_STRING(PanelNameStr);
- DECLARE_DEF_STRING(EmptyString);
- DECLARE_DEF_STRING(ControlNameStr);
-
-
-
- DECLARE_DEF_STRING(ButtonNameStr);
-
-
- DECLARE_DEF_STRING(CheckBoxNameStr);
-
-
- DECLARE_DEF_STRING(ChoiceNameStr);
-
-
- DECLARE_DEF_STRING(ComboBoxNameStr);
-
-
- DECLARE_DEF_STRING(GaugeNameStr);
-
-
- DECLARE_DEF_STRING(StaticBitmapNameStr);
- DECLARE_DEF_STRING(StaticBoxNameStr);
- DECLARE_DEF_STRING(StaticTextNameStr);
-
+ static const wxString wxPyPanelNameStr(wxPanelNameStr);
+ static const wxString wxPyEmptyString(wxEmptyString);
+ static const wxString wxPyControlNameStr(wxControlNameStr);
+ static const wxString wxPyButtonNameStr(wxButtonNameStr);
+ static const wxString wxPyCheckBoxNameStr(wxCheckBoxNameStr);
+ static const wxString wxPyChoiceNameStr(wxChoiceNameStr);
+ static const wxString wxPyComboBoxNameStr(wxComboBoxNameStr);
+ static const wxString wxPyGaugeNameStr(wxGaugeNameStr);
+ static const wxString wxPyStaticBitmapNameStr(wxStaticBitmapNameStr);
+ static const wxString wxPyStaticBoxNameStr(wxStaticBoxNameStr);
+ static const wxString wxPyStaticTextNameStr(wxStaticTextNameStr);
#include <wx/checklst.h>
- DECLARE_DEF_STRING(ListBoxNameStr);
+ static const wxString wxPyListBoxNameStr(wxListBoxNameStr);
void wxListBox_Insert(wxListBox *self,wxString const &item,int pos,PyObject *clientData){
if (clientData) {
wxPyClientData* data = new wxPyClientData(clientData);
}
return tup;
}
-
- DECLARE_DEF_STRING(TextCtrlNameStr);
-
+ static const wxString wxPyTextCtrlNameStr(wxTextCtrlNameStr);
static PyObject* t_output_helper(PyObject* target, PyObject* o) {
PyObject* o2;
wxString wxTextCtrl_GetString(wxTextCtrl *self,long from,long to){
return self->GetValue().Mid(from, to - from);
}
-
- DECLARE_DEF_STRING(ScrollBarNameStr);
-
-
- DECLARE_DEF_STRING(SPIN_BUTTON_NAME);
- wxChar* wxSpinCtrlNameStr = _T("wxSpinCtrl");
- DECLARE_DEF_STRING(SpinCtrlNameStr);
-
-
- DECLARE_DEF_STRING(RadioBoxNameStr);
- DECLARE_DEF_STRING(RadioButtonNameStr);
-
+ static const wxString wxPyScrollBarNameStr(wxScrollBarNameStr);
+ static const wxString wxPySPIN_BUTTON_NAME(wxSPIN_BUTTON_NAME);
+ static const wxString wxPySpinCtrlNameStr(wxT(_T("wxSpinCtrl")));
+ static const wxString wxPyRadioBoxNameStr(wxRadioBoxNameStr);
+ static const wxString wxPyRadioButtonNameStr(wxRadioButtonNameStr);
#include <wx/slider.h>
- DECLARE_DEF_STRING(SliderNameStr);
-
-
- wxChar* wxToggleButtonNameStr = _T("wxToggleButton");
- DECLARE_DEF_STRING(ToggleButtonNameStr);
+ static const wxString wxPySliderNameStr(wxSliderNameStr);
+ static const wxString wxPyToggleButtonNameStr(wxT(_T("wxToggleButton")));
#ifdef __WXMAC__
// implement dummy classes and such for wxMac
};
#endif
-
- DECLARE_DEF_STRING(NOTEBOOK_NAME);
-
-
- DECLARE_DEF_STRING(ToolBarNameStr);
-
+ static const wxString wxPyNOTEBOOK_NAME(wxNOTEBOOK_NAME);
+ static const wxString wxPyToolBarNameStr(wxToolBarNameStr);
PyObject *wxToolBarToolBase_GetClientData(wxToolBarToolBase *self){
wxPyUserData* udata = (wxPyUserData*)self->GetClientData();
if (udata) {
#include <wx/listctrl.h>
- const wxChar* wxListCtrlNameStr = _T("wxListCtrl");
- DECLARE_DEF_STRING(ListCtrlNameStr);
+ static const wxString wxPyListCtrlNameStr(wxT(_T("wxListCtrl")));
void wxListItemAttr_Destroy(wxListItemAttr *self){ delete self; }
// Python aware sorting function for wxPyListCtrl
static int wxCALLBACK wxPyListCtrl_SortItems(long item1, long item2, long funcPtr) {
#include <wx/treectrl.h>
#include "wx/wxPython/pytree.h"
-
- const wxChar* wx_TreeCtrlNameStr = _T("wxTreeCtrl");
- DECLARE_DEF_STRING(_TreeCtrlNameStr);
+ static const wxString wxPyTreeCtrlNameStr(wxT(_T("wxTreeCtrl")));
bool wxTreeItemId_operator_ee___(wxTreeItemId *self,wxTreeItemId const *other){
if (!other) return False;
return *self == *other;
else
RETURN_NONE();
}
-
- DECLARE_DEF_STRING(DirDialogDefaultFolderStr);
-
+ static const wxString wxPyDirDialogDefaultFolderStr(wxDirDialogDefaultFolderStr);
// C++ version of Python aware wxControl
class wxPyControl : public wxControl
{
#ifdef __cplusplus
extern "C" {
#endif
+static int _wrap_ButtonNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable ButtonNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_ButtonNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyButtonNameStr)->c_str(), (&wxPyButtonNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyButtonNameStr)->c_str(), (&wxPyButtonNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_Button(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_CheckBoxNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable CheckBoxNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_CheckBoxNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyCheckBoxNameStr)->c_str(), (&wxPyCheckBoxNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyCheckBoxNameStr)->c_str(), (&wxPyCheckBoxNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_CheckBox(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_ChoiceNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable ChoiceNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_ChoiceNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyChoiceNameStr)->c_str(), (&wxPyChoiceNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyChoiceNameStr)->c_str(), (&wxPyChoiceNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_Choice(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_ComboBoxNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable ComboBoxNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_ComboBoxNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyComboBoxNameStr)->c_str(), (&wxPyComboBoxNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyComboBoxNameStr)->c_str(), (&wxPyComboBoxNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_ComboBox(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_GaugeNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable GaugeNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_GaugeNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyGaugeNameStr)->c_str(), (&wxPyGaugeNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyGaugeNameStr)->c_str(), (&wxPyGaugeNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_Gauge(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_StaticBitmapNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable StaticBitmapNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_StaticBitmapNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyStaticBitmapNameStr)->c_str(), (&wxPyStaticBitmapNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyStaticBitmapNameStr)->c_str(), (&wxPyStaticBitmapNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_StaticBoxNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable StaticBoxNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_StaticBoxNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyStaticBoxNameStr)->c_str(), (&wxPyStaticBoxNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyStaticBoxNameStr)->c_str(), (&wxPyStaticBoxNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_StaticTextNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable StaticTextNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_StaticTextNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyStaticTextNameStr)->c_str(), (&wxPyStaticTextNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyStaticTextNameStr)->c_str(), (&wxPyStaticTextNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_StaticBox(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_ListBoxNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable ListBoxNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_ListBoxNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyListBoxNameStr)->c_str(), (&wxPyListBoxNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyListBoxNameStr)->c_str(), (&wxPyListBoxNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_ListBox(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_TextCtrlNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable TextCtrlNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_TextCtrlNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyTextCtrlNameStr)->c_str(), (&wxPyTextCtrlNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyTextCtrlNameStr)->c_str(), (&wxPyTextCtrlNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_TextAttr__SWIG_0(PyObject *self, PyObject *args) {
PyObject *resultobj;
wxTextAttr *result;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_ScrollBarNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable ScrollBarNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_ScrollBarNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyScrollBarNameStr)->c_str(), (&wxPyScrollBarNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyScrollBarNameStr)->c_str(), (&wxPyScrollBarNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_ScrollBar(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_SPIN_BUTTON_NAME_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable SPIN_BUTTON_NAME is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_SPIN_BUTTON_NAME_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPySPIN_BUTTON_NAME)->c_str(), (&wxPySPIN_BUTTON_NAME)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPySPIN_BUTTON_NAME)->c_str(), (&wxPySPIN_BUTTON_NAME)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_SpinCtrlNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable SpinCtrlNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_SpinCtrlNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPySpinCtrlNameStr)->c_str(), (&wxPySpinCtrlNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPySpinCtrlNameStr)->c_str(), (&wxPySpinCtrlNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_SpinButton(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_RadioBoxNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable RadioBoxNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_RadioBoxNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyRadioBoxNameStr)->c_str(), (&wxPyRadioBoxNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyRadioBoxNameStr)->c_str(), (&wxPyRadioBoxNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_RadioButtonNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable RadioButtonNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_RadioButtonNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyRadioButtonNameStr)->c_str(), (&wxPyRadioButtonNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyRadioButtonNameStr)->c_str(), (&wxPyRadioButtonNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_RadioBox(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_SliderNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable SliderNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_SliderNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPySliderNameStr)->c_str(), (&wxPySliderNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPySliderNameStr)->c_str(), (&wxPySliderNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_Slider(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_ToggleButtonNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable ToggleButtonNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_ToggleButtonNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyToggleButtonNameStr)->c_str(), (&wxPyToggleButtonNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyToggleButtonNameStr)->c_str(), (&wxPyToggleButtonNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_ToggleButton(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_NOTEBOOK_NAME_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable NOTEBOOK_NAME is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_NOTEBOOK_NAME_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyNOTEBOOK_NAME)->c_str(), (&wxPyNOTEBOOK_NAME)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyNOTEBOOK_NAME)->c_str(), (&wxPyNOTEBOOK_NAME)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_BookCtrl_GetPageCount(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxBookCtrl *arg1 = (wxBookCtrl *) 0 ;
}
+static PyObject *_wrap_ToolBarBase_AddToolItem(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj;
+ wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
+ wxToolBarToolBase *arg2 = (wxToolBarToolBase *) 0 ;
+ wxToolBarToolBase *result;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ char *kwnames[] = {
+ (char *) "self",(char *) "tool", NULL
+ };
+
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ToolBarBase_AddToolItem",kwnames,&obj0,&obj1)) goto fail;
+ if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxToolBarBase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+ if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_wxToolBarToolBase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (wxToolBarToolBase *)(arg1)->AddTool(arg2);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ {
+ resultobj = wxPyMake_wxObject(result);
+ }
+ return resultobj;
+ fail:
+ return NULL;
+}
+
+
+static PyObject *_wrap_ToolBarBase_InsertToolItem(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj;
+ wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
+ size_t arg2 ;
+ wxToolBarToolBase *arg3 = (wxToolBarToolBase *) 0 ;
+ wxToolBarToolBase *result;
+ PyObject * obj0 = 0 ;
+ PyObject * obj1 = 0 ;
+ PyObject * obj2 = 0 ;
+ char *kwnames[] = {
+ (char *) "self",(char *) "pos",(char *) "tool", NULL
+ };
+
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ToolBarBase_InsertToolItem",kwnames,&obj0,&obj1,&obj2)) goto fail;
+ if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxToolBarBase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+ arg2 = (size_t) PyInt_AsLong(obj1);
+ if (PyErr_Occurred()) SWIG_fail;
+ if ((SWIG_ConvertPtr(obj2,(void **) &arg3, SWIGTYPE_p_wxToolBarToolBase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (wxToolBarToolBase *)(arg1)->InsertTool(arg2,arg3);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ {
+ resultobj = wxPyMake_wxObject(result);
+ }
+ return resultobj;
+ fail:
+ return NULL;
+}
+
+
static PyObject *_wrap_ToolBarBase_AddControl(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
}
+static PyObject *_wrap_ToolBarBase_FindById(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj;
+ wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
+ int arg2 ;
+ wxToolBarToolBase *result;
+ PyObject * obj0 = 0 ;
+ char *kwnames[] = {
+ (char *) "self",(char *) "toolid", NULL
+ };
+
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"Oi:ToolBarBase_FindById",kwnames,&obj0,&arg2)) goto fail;
+ if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxToolBarBase,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (wxToolBarToolBase *)((wxToolBarBase const *)arg1)->FindById(arg2);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ {
+ resultobj = wxPyMake_wxObject(result);
+ }
+ return resultobj;
+ fail:
+ return NULL;
+}
+
+
static PyObject *_wrap_ToolBarBase_IsVertical(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxToolBarBase *arg1 = (wxToolBarBase *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_ListCtrlNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable ListCtrlNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_ListCtrlNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyListCtrlNameStr)->c_str(), (&wxPyListCtrlNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyListCtrlNameStr)->c_str(), (&wxPyListCtrlNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_ListItemAttr(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxColour const &arg1_defvalue = wxNullColour ;
static PyObject *_wrap_ListItem_m_text_set(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxListItem *arg1 = (wxListItem *) 0 ;
- wxString arg2 ;
+ wxString *arg2 = (wxString *) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *kwnames[] = {
if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ListItem_m_text_set",kwnames,&obj0,&obj1)) goto fail;
if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxListItem,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
- {
- wxString* sptr = wxString_in_helper(obj1);
- if (sptr == NULL) SWIG_fail;
- arg2 = *sptr;
- delete sptr;
- }
- if (arg1) (arg1)->m_text = arg2;
+ if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_wxString,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+ if (arg1) (arg1)->m_text = *arg2;
Py_INCREF(Py_None); resultobj = Py_None;
return resultobj;
static PyObject *_wrap_ListItem_m_text_get(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxListItem *arg1 = (wxListItem *) 0 ;
- wxString result;
+ wxString *result;
PyObject * obj0 = 0 ;
char *kwnames[] = {
(char *) "self", NULL
if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:ListItem_m_text_get",kwnames,&obj0)) goto fail;
if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxListItem,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
- result = ((arg1)->m_text);
+ result = (wxString *)& ((arg1)->m_text);
{
#if wxUSE_UNICODE
- resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
+ resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
#else
- resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
+ resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
#endif
}
return resultobj;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_TreeCtrlNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable TreeCtrlNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_TreeCtrlNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyTreeCtrlNameStr)->c_str(), (&wxPyTreeCtrlNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyTreeCtrlNameStr)->c_str(), (&wxPyTreeCtrlNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_TreeItemId(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxTreeItemId *result;
long arg5 = (long) wxTR_DEFAULT_STYLE ;
wxValidator const &arg6_defvalue = wxDefaultValidator ;
wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
- wxString const &arg7_defvalue = wxPy_TreeCtrlNameStr ;
+ wxString const &arg7_defvalue = wxPyTreeCtrlNameStr ;
wxString *arg7 = (wxString *) &arg7_defvalue ;
wxPyTreeCtrl *result;
wxPoint temp3 ;
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
- resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_wxPyTreeCtrl, 1);
+ {
+ resultobj = wxPyMake_wxObject(result);
+ }
{
if (temp7)
delete arg7;
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
- resultobj = SWIG_NewPointerObj((void *) result, SWIGTYPE_p_wxPyTreeCtrl, 1);
+ {
+ resultobj = wxPyMake_wxObject(result);
+ }
return resultobj;
fail:
return NULL;
long arg6 = (long) wxTR_DEFAULT_STYLE ;
wxValidator const &arg7_defvalue = wxDefaultValidator ;
wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
- wxString const &arg8_defvalue = wxPy_TreeCtrlNameStr ;
+ wxString const &arg8_defvalue = wxPyTreeCtrlNameStr ;
wxString *arg8 = (wxString *) &arg8_defvalue ;
bool result;
wxPoint temp4 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_DirDialogDefaultFolderStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable DirDialogDefaultFolderStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_DirDialogDefaultFolderStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyDirDialogDefaultFolderStr)->c_str(), (&wxPyDirDialogDefaultFolderStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyDirDialogDefaultFolderStr)->c_str(), (&wxPyDirDialogDefaultFolderStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_GenericDirCtrl(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
wxString const &arg7_defvalue = wxPyEmptyString ;
wxString *arg7 = (wxString *) &arg7_defvalue ;
int arg8 = (int) 0 ;
- wxString const &arg9_defvalue = wxPy_TreeCtrlNameStr ;
+ wxString const &arg9_defvalue = wxPyTreeCtrlNameStr ;
wxString *arg9 = (wxString *) &arg9_defvalue ;
wxGenericDirCtrl *result;
bool temp3 = False ;
wxString const &arg8_defvalue = wxPyEmptyString ;
wxString *arg8 = (wxString *) &arg8_defvalue ;
int arg9 = (int) 0 ;
- wxString const &arg10_defvalue = wxPy_TreeCtrlNameStr ;
+ wxString const &arg10_defvalue = wxPyTreeCtrlNameStr ;
wxString *arg10 = (wxString *) &arg10_defvalue ;
bool result;
bool temp4 = False ;
static PyObject *_wrap_GenericDirCtrl_GetTreeCtrl(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxGenericDirCtrl *arg1 = (wxGenericDirCtrl *) 0 ;
- wxTreeCtrl *result;
+ wxPyTreeCtrl *result;
PyObject * obj0 = 0 ;
char *kwnames[] = {
(char *) "self", NULL
if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxGenericDirCtrl,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
- result = (wxTreeCtrl *)((wxGenericDirCtrl const *)arg1)->GetTreeCtrl();
+ result = (wxPyTreeCtrl *)((wxGenericDirCtrl const *)arg1)->GetTreeCtrl();
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
{ (char *)"ToolBarToolBase_swigregister", ToolBarToolBase_swigregister, METH_VARARGS },
{ (char *)"ToolBarBase_DoAddTool", (PyCFunction) _wrap_ToolBarBase_DoAddTool, METH_VARARGS | METH_KEYWORDS },
{ (char *)"ToolBarBase_DoInsertTool", (PyCFunction) _wrap_ToolBarBase_DoInsertTool, METH_VARARGS | METH_KEYWORDS },
+ { (char *)"ToolBarBase_AddToolItem", (PyCFunction) _wrap_ToolBarBase_AddToolItem, METH_VARARGS | METH_KEYWORDS },
+ { (char *)"ToolBarBase_InsertToolItem", (PyCFunction) _wrap_ToolBarBase_InsertToolItem, METH_VARARGS | METH_KEYWORDS },
{ (char *)"ToolBarBase_AddControl", (PyCFunction) _wrap_ToolBarBase_AddControl, METH_VARARGS | METH_KEYWORDS },
{ (char *)"ToolBarBase_InsertControl", (PyCFunction) _wrap_ToolBarBase_InsertControl, METH_VARARGS | METH_KEYWORDS },
{ (char *)"ToolBarBase_FindControl", (PyCFunction) _wrap_ToolBarBase_FindControl, METH_VARARGS | METH_KEYWORDS },
{ (char *)"ToolBarBase_GetToolBitmapSize", (PyCFunction) _wrap_ToolBarBase_GetToolBitmapSize, METH_VARARGS | METH_KEYWORDS },
{ (char *)"ToolBarBase_GetToolSize", (PyCFunction) _wrap_ToolBarBase_GetToolSize, METH_VARARGS | METH_KEYWORDS },
{ (char *)"ToolBarBase_FindToolForPosition", (PyCFunction) _wrap_ToolBarBase_FindToolForPosition, METH_VARARGS | METH_KEYWORDS },
+ { (char *)"ToolBarBase_FindById", (PyCFunction) _wrap_ToolBarBase_FindById, METH_VARARGS | METH_KEYWORDS },
{ (char *)"ToolBarBase_IsVertical", (PyCFunction) _wrap_ToolBarBase_IsVertical, METH_VARARGS | METH_KEYWORDS },
{ (char *)"ToolBarBase_swigregister", ToolBarBase_swigregister, METH_VARARGS },
{ (char *)"new_ToolBar", (PyCFunction) _wrap_new_ToolBar, METH_VARARGS | METH_KEYWORDS },
}
SWIG_InstallConstants(d,swig_const_table);
+ PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
+ SWIG_addvarlink(SWIG_globals,(char*)"ButtonNameStr",_wrap_ButtonNameStr_get, _wrap_ButtonNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"CheckBoxNameStr",_wrap_CheckBoxNameStr_get, _wrap_CheckBoxNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"ChoiceNameStr",_wrap_ChoiceNameStr_get, _wrap_ChoiceNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"ComboBoxNameStr",_wrap_ComboBoxNameStr_get, _wrap_ComboBoxNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"GaugeNameStr",_wrap_GaugeNameStr_get, _wrap_GaugeNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"StaticBitmapNameStr",_wrap_StaticBitmapNameStr_get, _wrap_StaticBitmapNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"StaticBoxNameStr",_wrap_StaticBoxNameStr_get, _wrap_StaticBoxNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"StaticTextNameStr",_wrap_StaticTextNameStr_get, _wrap_StaticTextNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"ListBoxNameStr",_wrap_ListBoxNameStr_get, _wrap_ListBoxNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"TextCtrlNameStr",_wrap_TextCtrlNameStr_get, _wrap_TextCtrlNameStr_set);
PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_UPDATED", PyInt_FromLong(wxEVT_COMMAND_TEXT_UPDATED));
PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_ENTER", PyInt_FromLong(wxEVT_COMMAND_TEXT_ENTER));
PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_URL", PyInt_FromLong(wxEVT_COMMAND_TEXT_URL));
PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_MAXLEN", PyInt_FromLong(wxEVT_COMMAND_TEXT_MAXLEN));
+ SWIG_addvarlink(SWIG_globals,(char*)"ScrollBarNameStr",_wrap_ScrollBarNameStr_get, _wrap_ScrollBarNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"SPIN_BUTTON_NAME",_wrap_SPIN_BUTTON_NAME_get, _wrap_SPIN_BUTTON_NAME_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"SpinCtrlNameStr",_wrap_SpinCtrlNameStr_get, _wrap_SpinCtrlNameStr_set);
PyDict_SetItemString(d, "wxEVT_COMMAND_SPINCTRL_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SPINCTRL_UPDATED));
+ SWIG_addvarlink(SWIG_globals,(char*)"RadioBoxNameStr",_wrap_RadioBoxNameStr_get, _wrap_RadioBoxNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"RadioButtonNameStr",_wrap_RadioButtonNameStr_get, _wrap_RadioButtonNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"SliderNameStr",_wrap_SliderNameStr_get, _wrap_SliderNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"ToggleButtonNameStr",_wrap_ToggleButtonNameStr_get, _wrap_ToggleButtonNameStr_set);
PyDict_SetItemString(d, "wxEVT_COMMAND_TOGGLEBUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOGGLEBUTTON_CLICKED));
+ SWIG_addvarlink(SWIG_globals,(char*)"NOTEBOOK_NAME",_wrap_NOTEBOOK_NAME_get, _wrap_NOTEBOOK_NAME_set);
PyDict_SetItemString(d, "wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGED));
PyDict_SetItemString(d, "wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING", PyInt_FromLong(wxEVT_COMMAND_NOTEBOOK_PAGE_CHANGING));
PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED", PyInt_FromLong(wxEVT_COMMAND_LISTBOOK_PAGE_CHANGED));
PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING", PyInt_FromLong(wxEVT_COMMAND_LISTBOOK_PAGE_CHANGING));
+ SWIG_addvarlink(SWIG_globals,(char*)"ListCtrlNameStr",_wrap_ListCtrlNameStr_get, _wrap_ListCtrlNameStr_set);
PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_BEGIN_DRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_BEGIN_DRAG));
PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_BEGIN_RDRAG", PyInt_FromLong(wxEVT_COMMAND_LIST_BEGIN_RDRAG));
PyDict_SetItemString(d, "wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_LIST_BEGIN_LABEL_EDIT));
// Map renamed classes back to their common name for OOR
wxPyPtrTypeMap_Add("wxListCtrl", "wxPyListCtrl");
+ SWIG_addvarlink(SWIG_globals,(char*)"TreeCtrlNameStr",_wrap_TreeCtrlNameStr_get, _wrap_TreeCtrlNameStr_set);
PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_BEGIN_DRAG", PyInt_FromLong(wxEVT_COMMAND_TREE_BEGIN_DRAG));
PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_BEGIN_RDRAG", PyInt_FromLong(wxEVT_COMMAND_TREE_BEGIN_RDRAG));
PyDict_SetItemString(d, "wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT", PyInt_FromLong(wxEVT_COMMAND_TREE_BEGIN_LABEL_EDIT));
wxPyPtrTypeMap_Add("wxTreeItemData", "wxPyTreeItemData");
wxPyPtrTypeMap_Add("wxTreeCtrl", "wxPyTreeCtrl");
+ SWIG_addvarlink(SWIG_globals,(char*)"DirDialogDefaultFolderStr",_wrap_DirDialogDefaultFolderStr_get, _wrap_DirDialogDefaultFolderStr_set);
PyDict_SetItemString(d, "wxEVT_HELP", PyInt_FromLong(wxEVT_HELP));
PyDict_SetItemString(d, "wxEVT_DETAILED_HELP", PyInt_FromLong(wxEVT_DETAILED_HELP));
return "<%s.%s; proxy of C++ wxObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def GetClassName(*args, **kwargs):
"""
- GetClassName() -> wxString
+ GetClassName() -> String
Returns the class name of the C++ object using wxRTTI.
"""
_core.Object_swigregister(ObjectPtr)
_wxPySetDictionary = _core._wxPySetDictionary
+_wxPyFixStockObjects = _core._wxPyFixStockObjects
+
+cvar = _core.cvar
+EmptyString = cvar.EmptyString
#---------------------------------------------------------------------------
BITMAP_TYPE_INVALID = _core.BITMAP_TYPE_INVALID
BITMAP_TYPE_BMP = _core.BITMAP_TYPE_BMP
-BITMAP_TYPE_BMP_RESOURCE = _core.BITMAP_TYPE_BMP_RESOURCE
-BITMAP_TYPE_RESOURCE = _core.BITMAP_TYPE_RESOURCE
BITMAP_TYPE_ICO = _core.BITMAP_TYPE_ICO
-BITMAP_TYPE_ICO_RESOURCE = _core.BITMAP_TYPE_ICO_RESOURCE
BITMAP_TYPE_CUR = _core.BITMAP_TYPE_CUR
-BITMAP_TYPE_CUR_RESOURCE = _core.BITMAP_TYPE_CUR_RESOURCE
BITMAP_TYPE_XBM = _core.BITMAP_TYPE_XBM
BITMAP_TYPE_XBM_DATA = _core.BITMAP_TYPE_XBM_DATA
BITMAP_TYPE_XPM = _core.BITMAP_TYPE_XPM
BITMAP_TYPE_XPM_DATA = _core.BITMAP_TYPE_XPM_DATA
BITMAP_TYPE_TIF = _core.BITMAP_TYPE_TIF
-BITMAP_TYPE_TIF_RESOURCE = _core.BITMAP_TYPE_TIF_RESOURCE
BITMAP_TYPE_GIF = _core.BITMAP_TYPE_GIF
-BITMAP_TYPE_GIF_RESOURCE = _core.BITMAP_TYPE_GIF_RESOURCE
BITMAP_TYPE_PNG = _core.BITMAP_TYPE_PNG
-BITMAP_TYPE_PNG_RESOURCE = _core.BITMAP_TYPE_PNG_RESOURCE
BITMAP_TYPE_JPEG = _core.BITMAP_TYPE_JPEG
-BITMAP_TYPE_JPEG_RESOURCE = _core.BITMAP_TYPE_JPEG_RESOURCE
BITMAP_TYPE_PNM = _core.BITMAP_TYPE_PNM
-BITMAP_TYPE_PNM_RESOURCE = _core.BITMAP_TYPE_PNM_RESOURCE
BITMAP_TYPE_PCX = _core.BITMAP_TYPE_PCX
-BITMAP_TYPE_PCX_RESOURCE = _core.BITMAP_TYPE_PCX_RESOURCE
BITMAP_TYPE_PICT = _core.BITMAP_TYPE_PICT
-BITMAP_TYPE_PICT_RESOURCE = _core.BITMAP_TYPE_PICT_RESOURCE
BITMAP_TYPE_ICON = _core.BITMAP_TYPE_ICON
-BITMAP_TYPE_ICON_RESOURCE = _core.BITMAP_TYPE_ICON_RESOURCE
BITMAP_TYPE_ANI = _core.BITMAP_TYPE_ANI
BITMAP_TYPE_IFF = _core.BITMAP_TYPE_IFF
BITMAP_TYPE_MACCURSOR = _core.BITMAP_TYPE_MACCURSOR
-BITMAP_TYPE_MACCURSOR_RESOURCE = _core.BITMAP_TYPE_MACCURSOR_RESOURCE
BITMAP_TYPE_ANY = _core.BITMAP_TYPE_ANY
CURSOR_NONE = _core.CURSOR_NONE
CURSOR_ARROW = _core.CURSOR_ARROW
return _core.InputStream_Ungetch(*args, **kwargs)
def SeekI(*args, **kwargs):
- """SeekI(long pos, wxSeekMode mode=FromStart) -> long"""
+ """SeekI(long pos, int mode=FromStart) -> long"""
return _core.InputStream_SeekI(*args, **kwargs)
def TellI(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = InputStream
_core.InputStream_swigregister(InputStreamPtr)
-cvar = _core.cvar
DefaultPosition = cvar.DefaultPosition
DefaultSize = cvar.DefaultSize
return "<%s.%s; proxy of C++ wxFSFile instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(wxInputStream stream, wxString loc, wxString mimetype,
- wxString anchor, wxDateTime modif) -> FSFile
+ __init__(InputStream stream, String loc, String mimetype, String anchor,
+ DateTime modif) -> FSFile
"""
newobj = _core.new_FSFile(*args, **kwargs)
self.this = newobj.this
except: pass
def GetStream(*args, **kwargs):
- """GetStream() -> wxInputStream"""
+ """GetStream() -> InputStream"""
return _core.FSFile_GetStream(*args, **kwargs)
def GetMimeType(*args, **kwargs):
- """GetMimeType() -> wxString"""
+ """GetMimeType() -> String"""
return _core.FSFile_GetMimeType(*args, **kwargs)
def GetLocation(*args, **kwargs):
- """GetLocation() -> wxString"""
+ """GetLocation() -> String"""
return _core.FSFile_GetLocation(*args, **kwargs)
def GetAnchor(*args, **kwargs):
- """GetAnchor() -> wxString"""
+ """GetAnchor() -> String"""
return _core.FSFile_GetAnchor(*args, **kwargs)
def GetModificationTime(*args, **kwargs):
- """GetModificationTime() -> wxDateTime"""
+ """GetModificationTime() -> DateTime"""
return _core.FSFile_GetModificationTime(*args, **kwargs)
return _core.FileSystemHandler__setCallbackInfo(*args, **kwargs)
def CanOpen(*args, **kwargs):
- """CanOpen(wxString location) -> bool"""
+ """CanOpen(String location) -> bool"""
return _core.FileSystemHandler_CanOpen(*args, **kwargs)
def OpenFile(*args, **kwargs):
- """OpenFile(FileSystem fs, wxString location) -> FSFile"""
+ """OpenFile(FileSystem fs, String location) -> FSFile"""
return _core.FileSystemHandler_OpenFile(*args, **kwargs)
def FindFirst(*args, **kwargs):
- """FindFirst(wxString spec, int flags=0) -> wxString"""
+ """FindFirst(String spec, int flags=0) -> String"""
return _core.FileSystemHandler_FindFirst(*args, **kwargs)
def FindNext(*args, **kwargs):
- """FindNext() -> wxString"""
+ """FindNext() -> String"""
return _core.FileSystemHandler_FindNext(*args, **kwargs)
def GetProtocol(*args, **kwargs):
- """GetProtocol(wxString location) -> wxString"""
+ """GetProtocol(String location) -> String"""
return _core.FileSystemHandler_GetProtocol(*args, **kwargs)
def GetLeftLocation(*args, **kwargs):
- """GetLeftLocation(wxString location) -> wxString"""
+ """GetLeftLocation(String location) -> String"""
return _core.FileSystemHandler_GetLeftLocation(*args, **kwargs)
def GetAnchor(*args, **kwargs):
- """GetAnchor(wxString location) -> wxString"""
+ """GetAnchor(String location) -> String"""
return _core.FileSystemHandler_GetAnchor(*args, **kwargs)
def GetRightLocation(*args, **kwargs):
- """GetRightLocation(wxString location) -> wxString"""
+ """GetRightLocation(String location) -> String"""
return _core.FileSystemHandler_GetRightLocation(*args, **kwargs)
def GetMimeTypeFromExt(*args, **kwargs):
- """GetMimeTypeFromExt(wxString location) -> wxString"""
+ """GetMimeTypeFromExt(String location) -> String"""
return _core.FileSystemHandler_GetMimeTypeFromExt(*args, **kwargs)
except: pass
def ChangePathTo(*args, **kwargs):
- """ChangePathTo(wxString location, bool is_dir=False)"""
+ """ChangePathTo(String location, bool is_dir=False)"""
return _core.FileSystem_ChangePathTo(*args, **kwargs)
def GetPath(*args, **kwargs):
- """GetPath() -> wxString"""
+ """GetPath() -> String"""
return _core.FileSystem_GetPath(*args, **kwargs)
def OpenFile(*args, **kwargs):
- """OpenFile(wxString location) -> FSFile"""
+ """OpenFile(String location) -> FSFile"""
return _core.FileSystem_OpenFile(*args, **kwargs)
def FindFirst(*args, **kwargs):
- """FindFirst(wxString spec, int flags=0) -> wxString"""
+ """FindFirst(String spec, int flags=0) -> String"""
return _core.FileSystem_FindFirst(*args, **kwargs)
def FindNext(*args, **kwargs):
- """FindNext() -> wxString"""
+ """FindNext() -> String"""
return _core.FileSystem_FindNext(*args, **kwargs)
def AddHandler(*args, **kwargs):
CleanUpHandlers = staticmethod(CleanUpHandlers)
def FileNameToURL(*args, **kwargs):
- """FileSystem.FileNameToURL(wxString filename) -> wxString"""
+ """FileSystem.FileNameToURL(String filename) -> String"""
return _core.FileSystem_FileNameToURL(*args, **kwargs)
FileNameToURL = staticmethod(FileNameToURL)
return _core.FileSystem_CleanUpHandlers(*args, **kwargs)
def FileSystem_FileNameToURL(*args, **kwargs):
- """FileSystem_FileNameToURL(wxString filename) -> wxString"""
+ """FileSystem_FileNameToURL(String filename) -> String"""
return _core.FileSystem_FileNameToURL(*args, **kwargs)
def FileSystem_URLToFileName(*args, **kwargs):
- """FileSystem_URLToFileName(wxString url) -> wxString"""
+ """FileSystem_URLToFileName(String url) -> String"""
return _core.FileSystem_URLToFileName(*args, **kwargs)
class InternetFSHandler(CPPFileSystemHandler):
def __repr__(self):
self.thisown = 1
del newobj.thisown
def CanOpen(*args, **kwargs):
- """CanOpen(wxString location) -> bool"""
+ """CanOpen(String location) -> bool"""
return _core.InternetFSHandler_CanOpen(*args, **kwargs)
def OpenFile(*args, **kwargs):
- """OpenFile(FileSystem fs, wxString location) -> FSFile"""
+ """OpenFile(FileSystem fs, String location) -> FSFile"""
return _core.InternetFSHandler_OpenFile(*args, **kwargs)
self.thisown = 1
del newobj.thisown
def CanOpen(*args, **kwargs):
- """CanOpen(wxString location) -> bool"""
+ """CanOpen(String location) -> bool"""
return _core.ZipFSHandler_CanOpen(*args, **kwargs)
def OpenFile(*args, **kwargs):
- """OpenFile(FileSystem fs, wxString location) -> FSFile"""
+ """OpenFile(FileSystem fs, String location) -> FSFile"""
return _core.ZipFSHandler_OpenFile(*args, **kwargs)
def FindFirst(*args, **kwargs):
- """FindFirst(wxString spec, int flags=0) -> wxString"""
+ """FindFirst(String spec, int flags=0) -> String"""
return _core.ZipFSHandler_FindFirst(*args, **kwargs)
def FindNext(*args, **kwargs):
- """FindNext() -> wxString"""
+ """FindNext() -> String"""
return _core.ZipFSHandler_FindNext(*args, **kwargs)
def __wxMemoryFSHandler_AddFile_wxImage(*args, **kwargs):
- """__wxMemoryFSHandler_AddFile_wxImage(wxString filename, Image image, long type)"""
+ """__wxMemoryFSHandler_AddFile_wxImage(String filename, Image image, long type)"""
return _core.__wxMemoryFSHandler_AddFile_wxImage(*args, **kwargs)
def __wxMemoryFSHandler_AddFile_wxBitmap(*args, **kwargs):
- """__wxMemoryFSHandler_AddFile_wxBitmap(wxString filename, wxBitmap bitmap, long type)"""
+ """__wxMemoryFSHandler_AddFile_wxBitmap(String filename, Bitmap bitmap, long type)"""
return _core.__wxMemoryFSHandler_AddFile_wxBitmap(*args, **kwargs)
def __wxMemoryFSHandler_AddFile_Data(*args, **kwargs):
- """__wxMemoryFSHandler_AddFile_Data(wxString filename, PyObject data)"""
+ """__wxMemoryFSHandler_AddFile_Data(String filename, PyObject data)"""
return _core.__wxMemoryFSHandler_AddFile_Data(*args, **kwargs)
def MemoryFSHandler_AddFile(filename, a, b=''):
if isinstance(a, wx.Image):
self.thisown = 1
del newobj.thisown
def RemoveFile(*args, **kwargs):
- """MemoryFSHandler.RemoveFile(wxString filename)"""
+ """MemoryFSHandler.RemoveFile(String filename)"""
return _core.MemoryFSHandler_RemoveFile(*args, **kwargs)
RemoveFile = staticmethod(RemoveFile)
AddFile = staticmethod(MemoryFSHandler_AddFile)
def CanOpen(*args, **kwargs):
- """CanOpen(wxString location) -> bool"""
+ """CanOpen(String location) -> bool"""
return _core.MemoryFSHandler_CanOpen(*args, **kwargs)
def OpenFile(*args, **kwargs):
- """OpenFile(FileSystem fs, wxString location) -> FSFile"""
+ """OpenFile(FileSystem fs, String location) -> FSFile"""
return _core.MemoryFSHandler_OpenFile(*args, **kwargs)
def FindFirst(*args, **kwargs):
- """FindFirst(wxString spec, int flags=0) -> wxString"""
+ """FindFirst(String spec, int flags=0) -> String"""
return _core.MemoryFSHandler_FindFirst(*args, **kwargs)
def FindNext(*args, **kwargs):
- """FindNext() -> wxString"""
+ """FindNext() -> String"""
return _core.MemoryFSHandler_FindNext(*args, **kwargs)
_core.MemoryFSHandler_swigregister(MemoryFSHandlerPtr)
def MemoryFSHandler_RemoveFile(*args, **kwargs):
- """MemoryFSHandler_RemoveFile(wxString filename)"""
+ """MemoryFSHandler_RemoveFile(String filename)"""
return _core.MemoryFSHandler_RemoveFile(*args, **kwargs)
#---------------------------------------------------------------------------
def __repr__(self):
return "<%s.%s; proxy of C++ wxImageHandler instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def GetName(*args, **kwargs):
- """GetName() -> wxString"""
+ """GetName() -> String"""
return _core.ImageHandler_GetName(*args, **kwargs)
def GetExtension(*args, **kwargs):
- """GetExtension() -> wxString"""
+ """GetExtension() -> String"""
return _core.ImageHandler_GetExtension(*args, **kwargs)
def GetType(*args, **kwargs):
return _core.ImageHandler_GetType(*args, **kwargs)
def GetMimeType(*args, **kwargs):
- """GetMimeType() -> wxString"""
+ """GetMimeType() -> String"""
return _core.ImageHandler_GetMimeType(*args, **kwargs)
def CanRead(*args, **kwargs):
- """CanRead(wxString name) -> bool"""
+ """CanRead(String name) -> bool"""
return _core.ImageHandler_CanRead(*args, **kwargs)
def SetName(*args, **kwargs):
- """SetName(wxString name)"""
+ """SetName(String name)"""
return _core.ImageHandler_SetName(*args, **kwargs)
def SetExtension(*args, **kwargs):
- """SetExtension(wxString extension)"""
+ """SetExtension(String extension)"""
return _core.ImageHandler_SetExtension(*args, **kwargs)
def SetType(*args, **kwargs):
return _core.ImageHandler_SetType(*args, **kwargs)
def SetMimeType(*args, **kwargs):
- """SetMimeType(wxString mimetype)"""
+ """SetMimeType(String mimetype)"""
return _core.ImageHandler_SetMimeType(*args, **kwargs)
def __repr__(self):
return "<%s.%s; proxy of C++ wxImage instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString name, long type=BITMAP_TYPE_ANY, int index=-1) -> Image"""
+ """__init__(String name, long type=BITMAP_TYPE_ANY, int index=-1) -> Image"""
newobj = _core.new_Image(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _core.Image_SetMaskFromImage(*args, **kwargs)
def CanRead(*args, **kwargs):
- """Image.CanRead(wxString name) -> bool"""
+ """Image.CanRead(String name) -> bool"""
return _core.Image_CanRead(*args, **kwargs)
CanRead = staticmethod(CanRead)
def GetImageCount(*args, **kwargs):
- """Image.GetImageCount(wxString name, long type=BITMAP_TYPE_ANY) -> int"""
+ """Image.GetImageCount(String name, long type=BITMAP_TYPE_ANY) -> int"""
return _core.Image_GetImageCount(*args, **kwargs)
GetImageCount = staticmethod(GetImageCount)
def LoadFile(*args, **kwargs):
- """LoadFile(wxString name, long type=BITMAP_TYPE_ANY, int index=-1) -> bool"""
+ """LoadFile(String name, long type=BITMAP_TYPE_ANY, int index=-1) -> bool"""
return _core.Image_LoadFile(*args, **kwargs)
def LoadMimeFile(*args, **kwargs):
- """LoadMimeFile(wxString name, wxString mimetype, int index=-1) -> bool"""
+ """LoadMimeFile(String name, String mimetype, int index=-1) -> bool"""
return _core.Image_LoadMimeFile(*args, **kwargs)
def SaveFile(*args, **kwargs):
- """SaveFile(wxString name, int type) -> bool"""
+ """SaveFile(String name, int type) -> bool"""
return _core.Image_SaveFile(*args, **kwargs)
def SaveMimeFile(*args, **kwargs):
- """SaveMimeFile(wxString name, wxString mimetype) -> bool"""
+ """SaveMimeFile(String name, String mimetype) -> bool"""
return _core.Image_SaveMimeFile(*args, **kwargs)
def CanReadStream(*args, **kwargs):
- """Image.CanReadStream(wxInputStream stream) -> bool"""
+ """Image.CanReadStream(InputStream stream) -> bool"""
return _core.Image_CanReadStream(*args, **kwargs)
CanReadStream = staticmethod(CanReadStream)
def LoadStream(*args, **kwargs):
- """LoadStream(wxInputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> bool"""
+ """LoadStream(InputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> bool"""
return _core.Image_LoadStream(*args, **kwargs)
def LoadMimeStream(*args, **kwargs):
- """LoadMimeStream(wxInputStream stream, wxString mimetype, int index=-1) -> bool"""
+ """LoadMimeStream(InputStream stream, String mimetype, int index=-1) -> bool"""
return _core.Image_LoadMimeStream(*args, **kwargs)
def Ok(*args, **kwargs):
return _core.Image_ConvertToMono(*args, **kwargs)
def SetOption(*args, **kwargs):
- """SetOption(wxString name, wxString value)"""
+ """SetOption(String name, String value)"""
return _core.Image_SetOption(*args, **kwargs)
def SetOptionInt(*args, **kwargs):
- """SetOptionInt(wxString name, int value)"""
+ """SetOptionInt(String name, int value)"""
return _core.Image_SetOptionInt(*args, **kwargs)
def GetOption(*args, **kwargs):
- """GetOption(wxString name) -> wxString"""
+ """GetOption(String name) -> String"""
return _core.Image_GetOption(*args, **kwargs)
def GetOptionInt(*args, **kwargs):
- """GetOptionInt(wxString name) -> int"""
+ """GetOptionInt(String name) -> int"""
return _core.Image_GetOptionInt(*args, **kwargs)
def HasOption(*args, **kwargs):
- """HasOption(wxString name) -> bool"""
+ """HasOption(String name) -> bool"""
return _core.Image_HasOption(*args, **kwargs)
def CountColours(*args, **kwargs):
InsertHandler = staticmethod(InsertHandler)
def RemoveHandler(*args, **kwargs):
- """Image.RemoveHandler(wxString name) -> bool"""
+ """Image.RemoveHandler(String name) -> bool"""
return _core.Image_RemoveHandler(*args, **kwargs)
RemoveHandler = staticmethod(RemoveHandler)
def GetImageExtWildcard(*args, **kwargs):
- """Image.GetImageExtWildcard() -> wxString"""
+ """Image.GetImageExtWildcard() -> String"""
return _core.Image_GetImageExtWildcard(*args, **kwargs)
GetImageExtWildcard = staticmethod(GetImageExtWildcard)
def ConvertToBitmap(*args, **kwargs):
- """ConvertToBitmap() -> wxBitmap"""
+ """ConvertToBitmap() -> Bitmap"""
return _core.Image_ConvertToBitmap(*args, **kwargs)
def ConvertToMonoBitmap(*args, **kwargs):
- """ConvertToMonoBitmap(unsigned char red, unsigned char green, unsigned char blue) -> wxBitmap"""
+ """ConvertToMonoBitmap(unsigned char red, unsigned char green, unsigned char blue) -> Bitmap"""
return _core.Image_ConvertToMonoBitmap(*args, **kwargs)
def __nonzero__(self): return self.Ok()
_core.Image_swigregister(ImagePtr)
def ImageFromMime(*args, **kwargs):
- """ImageFromMime(wxString name, wxString mimetype, int index=-1) -> Image"""
+ """ImageFromMime(String name, String mimetype, int index=-1) -> Image"""
val = _core.new_ImageFromMime(*args, **kwargs)
val.thisown = 1
return val
def ImageFromStream(*args, **kwargs):
- """ImageFromStream(wxInputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> Image"""
+ """ImageFromStream(InputStream stream, long type=BITMAP_TYPE_ANY, int index=-1) -> Image"""
val = _core.new_ImageFromStream(*args, **kwargs)
val.thisown = 1
return val
def ImageFromStreamMime(*args, **kwargs):
- """ImageFromStreamMime(wxInputStream stream, wxString mimetype, int index=-1) -> Image"""
+ """ImageFromStreamMime(InputStream stream, String mimetype, int index=-1) -> Image"""
val = _core.new_ImageFromStreamMime(*args, **kwargs)
val.thisown = 1
return val
return val
def ImageFromBitmap(*args, **kwargs):
- """ImageFromBitmap(wxBitmap bitmap) -> Image"""
+ """ImageFromBitmap(Bitmap bitmap) -> Image"""
val = _core.new_ImageFromBitmap(*args, **kwargs)
val.thisown = 1
return val
return val
def Image_CanRead(*args, **kwargs):
- """Image_CanRead(wxString name) -> bool"""
+ """Image_CanRead(String name) -> bool"""
return _core.Image_CanRead(*args, **kwargs)
def Image_GetImageCount(*args, **kwargs):
- """Image_GetImageCount(wxString name, long type=BITMAP_TYPE_ANY) -> int"""
+ """Image_GetImageCount(String name, long type=BITMAP_TYPE_ANY) -> int"""
return _core.Image_GetImageCount(*args, **kwargs)
def Image_CanReadStream(*args, **kwargs):
- """Image_CanReadStream(wxInputStream stream) -> bool"""
+ """Image_CanReadStream(InputStream stream) -> bool"""
return _core.Image_CanReadStream(*args, **kwargs)
def Image_AddHandler(*args, **kwargs):
return _core.Image_InsertHandler(*args, **kwargs)
def Image_RemoveHandler(*args, **kwargs):
- """Image_RemoveHandler(wxString name) -> bool"""
+ """Image_RemoveHandler(String name) -> bool"""
return _core.Image_RemoveHandler(*args, **kwargs)
def Image_GetImageExtWildcard(*args, **kwargs):
- """Image_GetImageExtWildcard() -> wxString"""
+ """Image_GetImageExtWildcard() -> String"""
return _core.Image_GetImageExtWildcard(*args, **kwargs)
return _core.CommandEvent_GetSelection(*args, **kwargs)
def SetString(*args, **kwargs):
- """SetString(wxString s)"""
+ """SetString(String s)"""
return _core.CommandEvent_SetString(*args, **kwargs)
def GetString(*args, **kwargs):
- """GetString() -> wxString"""
+ """GetString() -> String"""
return _core.CommandEvent_GetString(*args, **kwargs)
def IsChecked(*args, **kwargs):
return _core.MouseEvent_GetPositionTuple(*args, **kwargs)
def GetLogicalPosition(*args, **kwargs):
- """GetLogicalPosition(wxDC dc) -> Point"""
+ """GetLogicalPosition(DC dc) -> Point"""
return _core.MouseEvent_GetLogicalPosition(*args, **kwargs)
def GetX(*args, **kwargs):
return _core.SetCursorEvent_GetY(*args, **kwargs)
def SetCursor(*args, **kwargs):
- """SetCursor(wxCursor cursor)"""
+ """SetCursor(Cursor cursor)"""
return _core.SetCursorEvent_SetCursor(*args, **kwargs)
def GetCursor(*args, **kwargs):
- """GetCursor() -> wxCursor"""
+ """GetCursor() -> Cursor"""
return _core.SetCursorEvent_GetCursor(*args, **kwargs)
def HasCursor(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxEraseEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(int Id=0, wxDC dc=(wxDC *) NULL) -> EraseEvent"""
+ """__init__(int Id=0, DC dc=(wxDC *) NULL) -> EraseEvent"""
newobj = _core.new_EraseEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetDC(*args, **kwargs):
- """GetDC() -> wxDC"""
+ """GetDC() -> DC"""
return _core.EraseEvent_GetDC(*args, **kwargs)
return _core.UpdateUIEvent_GetEnabled(*args, **kwargs)
def GetText(*args, **kwargs):
- """GetText() -> wxString"""
+ """GetText() -> String"""
return _core.UpdateUIEvent_GetText(*args, **kwargs)
def GetSetText(*args, **kwargs):
return _core.UpdateUIEvent_Enable(*args, **kwargs)
def SetText(*args, **kwargs):
- """SetText(wxString text)"""
+ """SetText(String text)"""
return _core.UpdateUIEvent_SetText(*args, **kwargs)
def SetUpdateInterval(*args, **kwargs):
ResetUpdateTime = staticmethod(ResetUpdateTime)
def SetMode(*args, **kwargs):
- """UpdateUIEvent.SetMode(wxUpdateUIMode mode)"""
+ """UpdateUIEvent.SetMode(int mode)"""
return _core.UpdateUIEvent_SetMode(*args, **kwargs)
SetMode = staticmethod(SetMode)
def GetMode(*args, **kwargs):
- """UpdateUIEvent.GetMode() -> wxUpdateUIMode"""
+ """UpdateUIEvent.GetMode() -> int"""
return _core.UpdateUIEvent_GetMode(*args, **kwargs)
GetMode = staticmethod(GetMode)
return _core.UpdateUIEvent_ResetUpdateTime(*args, **kwargs)
def UpdateUIEvent_SetMode(*args, **kwargs):
- """UpdateUIEvent_SetMode(wxUpdateUIMode mode)"""
+ """UpdateUIEvent_SetMode(int mode)"""
return _core.UpdateUIEvent_SetMode(*args, **kwargs)
def UpdateUIEvent_GetMode(*args, **kwargs):
- """UpdateUIEvent_GetMode() -> wxUpdateUIMode"""
+ """UpdateUIEvent_GetMode() -> int"""
return _core.UpdateUIEvent_GetMode(*args, **kwargs)
#---------------------------------------------------------------------------
return _core.IdleEvent_MoreRequested(*args, **kwargs)
def SetMode(*args, **kwargs):
- """IdleEvent.SetMode(wxIdleMode mode)"""
+ """IdleEvent.SetMode(int mode)"""
return _core.IdleEvent_SetMode(*args, **kwargs)
SetMode = staticmethod(SetMode)
def GetMode(*args, **kwargs):
- """IdleEvent.GetMode() -> wxIdleMode"""
+ """IdleEvent.GetMode() -> int"""
return _core.IdleEvent_GetMode(*args, **kwargs)
GetMode = staticmethod(GetMode)
_core.IdleEvent_swigregister(IdleEventPtr)
def IdleEvent_SetMode(*args, **kwargs):
- """IdleEvent_SetMode(wxIdleMode mode)"""
+ """IdleEvent_SetMode(int mode)"""
return _core.IdleEvent_SetMode(*args, **kwargs)
def IdleEvent_GetMode(*args, **kwargs):
- """IdleEvent_GetMode() -> wxIdleMode"""
+ """IdleEvent_GetMode() -> int"""
return _core.IdleEvent_GetMode(*args, **kwargs)
def IdleEvent_CanSend(*args, **kwargs):
def GetAppName(*args, **kwargs):
"""
- GetAppName() -> wxString
+ GetAppName() -> String
Get the application name.
"""
def SetAppName(*args, **kwargs):
"""
- SetAppName(wxString name)
+ SetAppName(String name)
Set the application name. This value may be used automatically
- by wxConfig and such.
+ by wx.Config and such.
"""
return _core.PyApp_SetAppName(*args, **kwargs)
def GetClassName(*args, **kwargs):
"""
- GetClassName() -> wxString
+ GetClassName() -> String
Get the application's class name.
"""
def SetClassName(*args, **kwargs):
"""
- SetClassName(wxString name)
+ SetClassName(String name)
Set the application's class name. This value may be used for X-resources if
applicable for the platform
def GetVendorName(*args, **kwargs):
"""
- GetVendorName() -> wxString
+ GetVendorName() -> String
Get the application's vendor name.
"""
def SetVendorName(*args, **kwargs):
"""
- SetVendorName(wxString name)
+ SetVendorName(String name)
Set the application's vendor name. This value may be used automatically
- by wxConfig and such.
+ by wx.Config and such.
"""
return _core.PyApp_SetVendorName(*args, **kwargs)
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 wxAppTraits allows us to abstract the
+ which is GUI/console dependent as then wx.AppTraits allows us to abstract the
differences behind the common facade
"""
return _core.PyApp_GetTraits(*args, **kwargs)
"""
ProcessPendingEvents()
- Process all events in the wxPendingEvents list -- it is necessary to call this
+ 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.
"""
Set the OnAssert behaviour for debug and hybrid builds. The following flags
may be or'd together:
- wxPYAPP_ASSERT_SUPPRESS Don't do anything
- wxPYAPP_ASSERT_EXCEPTION Turn it into a Python exception if possible (default)
- wxPYAPP_ASSERT_DIALOG Display a message dialog
- wxPYAPP_ASSERT_LOG Write the assertion info to the wxLog
+ 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
"""
return _core.PyApp_SetAssertMode(*args, **kwargs)
GetMacExitMenuItemId = staticmethod(GetMacExitMenuItemId)
def GetMacHelpMenuTitleName(*args, **kwargs):
- """PyApp.GetMacHelpMenuTitleName() -> wxString"""
+ """PyApp.GetMacHelpMenuTitleName() -> String"""
return _core.PyApp_GetMacHelpMenuTitleName(*args, **kwargs)
GetMacHelpMenuTitleName = staticmethod(GetMacHelpMenuTitleName)
SetMacExitMenuItemId = staticmethod(SetMacExitMenuItemId)
def SetMacHelpMenuTitleName(*args, **kwargs):
- """PyApp.SetMacHelpMenuTitleName(wxString val)"""
+ """PyApp.SetMacHelpMenuTitleName(String val)"""
return _core.PyApp_SetMacHelpMenuTitleName(*args, **kwargs)
SetMacHelpMenuTitleName = staticmethod(SetMacHelpMenuTitleName)
return _core.PyApp_GetMacExitMenuItemId(*args, **kwargs)
def PyApp_GetMacHelpMenuTitleName(*args, **kwargs):
- """PyApp_GetMacHelpMenuTitleName() -> wxString"""
+ """PyApp_GetMacHelpMenuTitleName() -> String"""
return _core.PyApp_GetMacHelpMenuTitleName(*args, **kwargs)
def PyApp_SetMacSupportPCMenuShortcuts(*args, **kwargs):
return _core.PyApp_SetMacExitMenuItemId(*args, **kwargs)
def PyApp_SetMacHelpMenuTitleName(*args, **kwargs):
- """PyApp_SetMacHelpMenuTitleName(wxString val)"""
+ """PyApp_SetMacHelpMenuTitleName(String val)"""
return _core.PyApp_SetMacHelpMenuTitleName(*args, **kwargs)
def PyApp_GetComCtl32Version(*args, **kwargs):
"""
GetApp() -> PyApp
- Return a reference to the current wxApp object.
+ Return a reference to the current wx.App object.
"""
return _core.GetApp(*args, **kwargs)
#----------------------------------------------------------------------
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 = wxTextCtrl(self.frame, -1, "",
- style = wx.TE_MULTILINE | wx.TE_READONLY)
+ 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)
wx.App.__init__(self, 0)
def OnInit(self):
- self.frame = wxFrame(None, -1, "Widget Tester", pos=(0,0), size=self.size)
+ self.frame = wx.Frame(None, -1, "Widget Tester", pos=(0,0), size=self.size)
self.SetTopWindow(self.frame)
return True
def GetAccelFromString(*args, **kwargs):
- """GetAccelFromString(wxString label) -> AcceleratorEntry"""
+ """GetAccelFromString(String label) -> AcceleratorEntry"""
return _core.GetAccelFromString(*args, **kwargs)
#---------------------------------------------------------------------------
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- long style=0, wxString name=PanelNameStr) -> Window
+ long style=0, String name=PanelNameStr) -> Window
"""
newobj = _core.new_Window(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- long style=0, wxString name=PanelNameStr) -> bool
+ long style=0, String name=PanelNameStr) -> bool
"""
return _core.Window_Create(*args, **kwargs)
return _core.Window_IsBeingDeleted(*args, **kwargs)
def SetTitle(*args, **kwargs):
- """SetTitle(wxString title)"""
+ """SetTitle(String title)"""
return _core.Window_SetTitle(*args, **kwargs)
def GetTitle(*args, **kwargs):
- """GetTitle() -> wxString"""
+ """GetTitle() -> String"""
return _core.Window_GetTitle(*args, **kwargs)
def SetLabel(*args, **kwargs):
- """SetLabel(wxString label)"""
+ """SetLabel(String label)"""
return _core.Window_SetLabel(*args, **kwargs)
def GetLabel(*args, **kwargs):
- """GetLabel() -> wxString"""
+ """GetLabel() -> String"""
return _core.Window_GetLabel(*args, **kwargs)
def SetName(*args, **kwargs):
- """SetName(wxString name)"""
+ """SetName(String name)"""
return _core.Window_SetName(*args, **kwargs)
def GetName(*args, **kwargs):
- """GetName() -> wxString"""
+ """GetName() -> String"""
return _core.Window_GetName(*args, **kwargs)
def SetId(*args, **kwargs):
return _core.Window_FindWindowById(*args, **kwargs)
def FindWindowByName(*args, **kwargs):
- """FindWindowByName(wxString name) -> Window"""
+ """FindWindowByName(String name) -> Window"""
return _core.Window_FindWindowByName(*args, **kwargs)
def GetEventHandler(*args, **kwargs):
return _core.Window_Thaw(*args, **kwargs)
def PrepareDC(*args, **kwargs):
- """PrepareDC(wxDC dc)"""
+ """PrepareDC(DC dc)"""
return _core.Window_PrepareDC(*args, **kwargs)
def GetUpdateRegion(*args, **kwargs):
- """GetUpdateRegion() -> wxRegion"""
+ """GetUpdateRegion() -> Region"""
return _core.Window_GetUpdateRegion(*args, **kwargs)
def GetUpdateClientRect(*args, **kwargs):
return _core.Window_isExposedRect(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
- """SetBackgroundColour(wxColour colour) -> bool"""
+ """SetBackgroundColour(Colour colour) -> bool"""
return _core.Window_SetBackgroundColour(*args, **kwargs)
def SetForegroundColour(*args, **kwargs):
- """SetForegroundColour(wxColour colour) -> bool"""
+ """SetForegroundColour(Colour colour) -> bool"""
return _core.Window_SetForegroundColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
- """GetBackgroundColour() -> wxColour"""
+ """GetBackgroundColour() -> Colour"""
return _core.Window_GetBackgroundColour(*args, **kwargs)
def GetForegroundColour(*args, **kwargs):
- """GetForegroundColour() -> wxColour"""
+ """GetForegroundColour() -> Colour"""
return _core.Window_GetForegroundColour(*args, **kwargs)
def SetCursor(*args, **kwargs):
- """SetCursor(wxCursor cursor) -> bool"""
+ """SetCursor(Cursor cursor) -> bool"""
return _core.Window_SetCursor(*args, **kwargs)
def GetCursor(*args, **kwargs):
- """GetCursor() -> wxCursor"""
+ """GetCursor() -> Cursor"""
return _core.Window_GetCursor(*args, **kwargs)
def SetFont(*args, **kwargs):
- """SetFont(wxFont font) -> bool"""
+ """SetFont(Font font) -> bool"""
return _core.Window_SetFont(*args, **kwargs)
def GetFont(*args, **kwargs):
- """GetFont() -> wxFont"""
+ """GetFont() -> Font"""
return _core.Window_GetFont(*args, **kwargs)
def SetCaret(*args, **kwargs):
- """SetCaret(wxCaret caret)"""
+ """SetCaret(Caret caret)"""
return _core.Window_SetCaret(*args, **kwargs)
def GetCaret(*args, **kwargs):
- """GetCaret() -> wxCaret"""
+ """GetCaret() -> Caret"""
return _core.Window_GetCaret(*args, **kwargs)
def GetCharHeight(*args, **kwargs):
def GetTextExtent(*args, **kwargs):
"""
- GetTextExtent(wxString string) -> (width, height)
+ GetTextExtent(String string) -> (width, height)
Get the width and height of the text using the current font.
"""
def GetFullTextExtent(*args, **kwargs):
"""
- GetFullTextExtent(wxString string, Font font=None) ->
+ 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.
return _core.Window_ScreenToClient(*args, **kwargs)
def HitTestXY(*args, **kwargs):
- """HitTestXY(int x, int y) -> wxHitTest"""
+ """HitTestXY(int x, int y) -> int"""
return _core.Window_HitTestXY(*args, **kwargs)
def HitTest(*args, **kwargs):
- """HitTest(Point pt) -> wxHitTest"""
+ """HitTest(Point pt) -> int"""
return _core.Window_HitTest(*args, **kwargs)
def GetBorderFlags(*args, **kwargs):
- """GetBorderFlags(long flags) -> wxBorder"""
+ """GetBorderFlags(long flags) -> int"""
return _core.Window_GetBorderFlags(*args, **kwargs)
def GetBorder(*args, **kwargs):
- """GetBorder() -> wxBorder"""
+ """GetBorder() -> int"""
return _core.Window_GetBorder(*args, **kwargs)
def UpdateWindowUI(*args, **kwargs):
return _core.Window_PageDown(*args, **kwargs)
def SetHelpText(*args, **kwargs):
- """SetHelpText(wxString text)"""
+ """SetHelpText(String text)"""
return _core.Window_SetHelpText(*args, **kwargs)
def SetHelpTextForId(*args, **kwargs):
- """SetHelpTextForId(wxString text)"""
+ """SetHelpTextForId(String text)"""
return _core.Window_SetHelpTextForId(*args, **kwargs)
def GetHelpText(*args, **kwargs):
- """GetHelpText() -> wxString"""
+ """GetHelpText() -> String"""
return _core.Window_GetHelpText(*args, **kwargs)
def SetToolTipString(*args, **kwargs):
- """SetToolTipString(wxString tip)"""
+ """SetToolTipString(String tip)"""
return _core.Window_SetToolTipString(*args, **kwargs)
def SetToolTip(*args, **kwargs):
- """SetToolTip(wxToolTip tip)"""
+ """SetToolTip(ToolTip tip)"""
return _core.Window_SetToolTip(*args, **kwargs)
def GetToolTip(*args, **kwargs):
- """GetToolTip() -> wxToolTip"""
+ """GetToolTip() -> ToolTip"""
return _core.Window_GetToolTip(*args, **kwargs)
def SetDropTarget(*args, **kwargs):
- """SetDropTarget(wxPyDropTarget dropTarget)"""
+ """SetDropTarget(PyDropTarget dropTarget)"""
val = _core.Window_SetDropTarget(*args, **kwargs)
args[1].thisown = 0
return val
def GetDropTarget(*args, **kwargs):
- """GetDropTarget() -> wxPyDropTarget"""
+ """GetDropTarget() -> PyDropTarget"""
return _core.Window_GetDropTarget(*args, **kwargs)
def DragAcceptFiles(*args, **kwargs):
return _core.FindWindowById(*args, **kwargs)
def FindWindowByName(*args, **kwargs):
- """FindWindowByName(wxString name, Window parent=None) -> Window"""
+ """FindWindowByName(String name, Window parent=None) -> Window"""
return _core.FindWindowByName(*args, **kwargs)
def FindWindowByLabel(*args, **kwargs):
- """FindWindowByLabel(wxString label, Window parent=None) -> Window"""
+ """FindWindowByLabel(String label, Window parent=None) -> Window"""
return _core.FindWindowByLabel(*args, **kwargs)
def Window_FromHWND(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxMenu instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString title=wxPyEmptyString, long style=0) -> Menu"""
+ """__init__(String title=EmptyString, long style=0) -> Menu"""
newobj = _core.new_Menu(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
self._setOORInfo(self)
def Append(*args, **kwargs):
- """
- Append(int id, wxString text, wxString help=wxPyEmptyString,
- wxItemKind kind=ITEM_NORMAL)
- """
+ """Append(int id, String text, String help=EmptyString, int kind=ITEM_NORMAL)"""
return _core.Menu_Append(*args, **kwargs)
def AppendSeparator(*args, **kwargs):
return _core.Menu_AppendSeparator(*args, **kwargs)
def AppendCheckItem(*args, **kwargs):
- """AppendCheckItem(int id, wxString text, wxString help=wxPyEmptyString)"""
+ """AppendCheckItem(int id, String text, String help=EmptyString)"""
return _core.Menu_AppendCheckItem(*args, **kwargs)
def AppendRadioItem(*args, **kwargs):
- """AppendRadioItem(int id, wxString text, wxString help=wxPyEmptyString)"""
+ """AppendRadioItem(int id, String text, String help=EmptyString)"""
return _core.Menu_AppendRadioItem(*args, **kwargs)
def AppendMenu(*args, **kwargs):
- """AppendMenu(int id, wxString text, Menu submenu, wxString help=wxPyEmptyString)"""
+ """AppendMenu(int id, String text, Menu submenu, String help=EmptyString)"""
return _core.Menu_AppendMenu(*args, **kwargs)
def AppendItem(*args, **kwargs):
def Insert(*args, **kwargs):
"""
- Insert(size_t pos, int id, wxString text, wxString help=wxPyEmptyString,
- wxItemKind kind=ITEM_NORMAL)
+ Insert(size_t pos, int id, String text, String help=EmptyString,
+ int kind=ITEM_NORMAL)
"""
return _core.Menu_Insert(*args, **kwargs)
return _core.Menu_InsertSeparator(*args, **kwargs)
def InsertCheckItem(*args, **kwargs):
- """InsertCheckItem(size_t pos, int id, wxString text, wxString help=wxPyEmptyString)"""
+ """InsertCheckItem(size_t pos, int id, String text, String help=EmptyString)"""
return _core.Menu_InsertCheckItem(*args, **kwargs)
def InsertRadioItem(*args, **kwargs):
- """InsertRadioItem(size_t pos, int id, wxString text, wxString help=wxPyEmptyString)"""
+ """InsertRadioItem(size_t pos, int id, String text, String help=EmptyString)"""
return _core.Menu_InsertRadioItem(*args, **kwargs)
def InsertMenu(*args, **kwargs):
- """InsertMenu(size_t pos, int id, wxString text, Menu submenu, wxString help=wxPyEmptyString)"""
+ """InsertMenu(size_t pos, int id, String text, Menu submenu, String help=EmptyString)"""
return _core.Menu_InsertMenu(*args, **kwargs)
def PrependItem(*args, **kwargs):
return _core.Menu_PrependItem(*args, **kwargs)
def Prepend(*args, **kwargs):
- """
- Prepend(int id, wxString text, wxString help=wxPyEmptyString,
- wxItemKind kind=ITEM_NORMAL)
- """
+ """Prepend(int id, String text, String help=EmptyString, int kind=ITEM_NORMAL)"""
return _core.Menu_Prepend(*args, **kwargs)
def PrependSeparator(*args, **kwargs):
return _core.Menu_PrependSeparator(*args, **kwargs)
def PrependCheckItem(*args, **kwargs):
- """PrependCheckItem(int id, wxString text, wxString help=wxPyEmptyString)"""
+ """PrependCheckItem(int id, String text, String help=EmptyString)"""
return _core.Menu_PrependCheckItem(*args, **kwargs)
def PrependRadioItem(*args, **kwargs):
- """PrependRadioItem(int id, wxString text, wxString help=wxPyEmptyString)"""
+ """PrependRadioItem(int id, String text, String help=EmptyString)"""
return _core.Menu_PrependRadioItem(*args, **kwargs)
def PrependMenu(*args, **kwargs):
- """PrependMenu(int id, wxString text, Menu submenu, wxString help=wxPyEmptyString)"""
+ """PrependMenu(int id, String text, Menu submenu, String help=EmptyString)"""
return _core.Menu_PrependMenu(*args, **kwargs)
def Remove(*args, **kwargs):
return _core.Menu_GetMenuItems(*args, **kwargs)
def FindItem(*args, **kwargs):
- """FindItem(wxString item) -> int"""
+ """FindItem(String item) -> int"""
return _core.Menu_FindItem(*args, **kwargs)
def FindItemById(*args, **kwargs):
return _core.Menu_IsChecked(*args, **kwargs)
def SetLabel(*args, **kwargs):
- """SetLabel(int id, wxString label)"""
+ """SetLabel(int id, String label)"""
return _core.Menu_SetLabel(*args, **kwargs)
def GetLabel(*args, **kwargs):
- """GetLabel(int id) -> wxString"""
+ """GetLabel(int id) -> String"""
return _core.Menu_GetLabel(*args, **kwargs)
def SetHelpString(*args, **kwargs):
- """SetHelpString(int id, wxString helpString)"""
+ """SetHelpString(int id, String helpString)"""
return _core.Menu_SetHelpString(*args, **kwargs)
def GetHelpString(*args, **kwargs):
- """GetHelpString(int id) -> wxString"""
+ """GetHelpString(int id) -> String"""
return _core.Menu_GetHelpString(*args, **kwargs)
def SetTitle(*args, **kwargs):
- """SetTitle(wxString title)"""
+ """SetTitle(String title)"""
return _core.Menu_SetTitle(*args, **kwargs)
def GetTitle(*args, **kwargs):
- """GetTitle() -> wxString"""
+ """GetTitle() -> String"""
return _core.Menu_GetTitle(*args, **kwargs)
def SetEventHandler(*args, **kwargs):
self._setOORInfo(self)
def Append(*args, **kwargs):
- """Append(Menu menu, wxString title) -> bool"""
+ """Append(Menu menu, String title) -> bool"""
return _core.MenuBar_Append(*args, **kwargs)
def Insert(*args, **kwargs):
- """Insert(size_t pos, Menu menu, wxString title) -> bool"""
+ """Insert(size_t pos, Menu menu, String title) -> bool"""
return _core.MenuBar_Insert(*args, **kwargs)
def GetMenuCount(*args, **kwargs):
return _core.MenuBar_GetMenu(*args, **kwargs)
def Replace(*args, **kwargs):
- """Replace(size_t pos, Menu menu, wxString title) -> Menu"""
+ """Replace(size_t pos, Menu menu, String title) -> Menu"""
return _core.MenuBar_Replace(*args, **kwargs)
def Remove(*args, **kwargs):
return _core.MenuBar_IsEnabledTop(*args, **kwargs)
def SetLabelTop(*args, **kwargs):
- """SetLabelTop(size_t pos, wxString label)"""
+ """SetLabelTop(size_t pos, String label)"""
return _core.MenuBar_SetLabelTop(*args, **kwargs)
def GetLabelTop(*args, **kwargs):
- """GetLabelTop(size_t pos) -> wxString"""
+ """GetLabelTop(size_t pos) -> String"""
return _core.MenuBar_GetLabelTop(*args, **kwargs)
def FindMenuItem(*args, **kwargs):
- """FindMenuItem(wxString menu, wxString item) -> int"""
+ """FindMenuItem(String menu, String item) -> int"""
return _core.MenuBar_FindMenuItem(*args, **kwargs)
def FindItemById(*args, **kwargs):
return _core.MenuBar_FindItemById(*args, **kwargs)
def FindMenu(*args, **kwargs):
- """FindMenu(wxString title) -> int"""
+ """FindMenu(String title) -> int"""
return _core.MenuBar_FindMenu(*args, **kwargs)
def Enable(*args, **kwargs):
return _core.MenuBar_IsEnabled(*args, **kwargs)
def SetLabel(*args, **kwargs):
- """SetLabel(int id, wxString label)"""
+ """SetLabel(int id, String label)"""
return _core.MenuBar_SetLabel(*args, **kwargs)
def GetLabel(*args, **kwargs):
- """GetLabel(int id) -> wxString"""
+ """GetLabel(int id) -> String"""
return _core.MenuBar_GetLabel(*args, **kwargs)
def SetHelpString(*args, **kwargs):
- """SetHelpString(int id, wxString helpString)"""
+ """SetHelpString(int id, String helpString)"""
return _core.MenuBar_SetHelpString(*args, **kwargs)
def GetHelpString(*args, **kwargs):
- """GetHelpString(int id) -> wxString"""
+ """GetHelpString(int id) -> String"""
return _core.MenuBar_GetHelpString(*args, **kwargs)
def GetFrame(*args, **kwargs):
return "<%s.%s; proxy of C++ wxMenuItem instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Menu parentMenu=None, int id=ID_SEPARATOR, wxString text=wxPyEmptyString,
- wxString help=wxPyEmptyString,
- wxItemKind kind=ITEM_NORMAL, Menu subMenu=None) -> MenuItem
+ __init__(Menu parentMenu=None, int id=ID_SEPARATOR, String text=EmptyString,
+ String help=EmptyString, int kind=ITEM_NORMAL,
+ Menu subMenu=None) -> MenuItem
"""
newobj = _core.new_MenuItem(*args, **kwargs)
self.this = newobj.this
return _core.MenuItem_IsSeparator(*args, **kwargs)
def SetText(*args, **kwargs):
- """SetText(wxString str)"""
+ """SetText(String str)"""
return _core.MenuItem_SetText(*args, **kwargs)
def GetLabel(*args, **kwargs):
- """GetLabel() -> wxString"""
+ """GetLabel() -> String"""
return _core.MenuItem_GetLabel(*args, **kwargs)
def GetText(*args, **kwargs):
- """GetText() -> wxString"""
+ """GetText() -> String"""
return _core.MenuItem_GetText(*args, **kwargs)
def GetLabelFromText(*args, **kwargs):
- """MenuItem.GetLabelFromText(wxString text) -> wxString"""
+ """MenuItem.GetLabelFromText(String text) -> String"""
return _core.MenuItem_GetLabelFromText(*args, **kwargs)
GetLabelFromText = staticmethod(GetLabelFromText)
def GetKind(*args, **kwargs):
- """GetKind() -> wxItemKind"""
+ """GetKind() -> int"""
return _core.MenuItem_GetKind(*args, **kwargs)
def SetCheckable(*args, **kwargs):
return _core.MenuItem_Toggle(*args, **kwargs)
def SetHelp(*args, **kwargs):
- """SetHelp(wxString str)"""
+ """SetHelp(String str)"""
return _core.MenuItem_SetHelp(*args, **kwargs)
def GetHelp(*args, **kwargs):
- """GetHelp() -> wxString"""
+ """GetHelp() -> String"""
return _core.MenuItem_GetHelp(*args, **kwargs)
def GetAccel(*args, **kwargs):
return _core.MenuItem_SetAccel(*args, **kwargs)
def SetFont(*args, **kwargs):
- """SetFont(wxFont font)"""
+ """SetFont(Font font)"""
return _core.MenuItem_SetFont(*args, **kwargs)
def GetFont(*args, **kwargs):
- """GetFont() -> wxFont"""
+ """GetFont() -> Font"""
return _core.MenuItem_GetFont(*args, **kwargs)
def SetTextColour(*args, **kwargs):
- """SetTextColour(wxColour colText)"""
+ """SetTextColour(Colour colText)"""
return _core.MenuItem_SetTextColour(*args, **kwargs)
def GetTextColour(*args, **kwargs):
- """GetTextColour() -> wxColour"""
+ """GetTextColour() -> Colour"""
return _core.MenuItem_GetTextColour(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
- """SetBackgroundColour(wxColour colBack)"""
+ """SetBackgroundColour(Colour colBack)"""
return _core.MenuItem_SetBackgroundColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
- """GetBackgroundColour() -> wxColour"""
+ """GetBackgroundColour() -> Colour"""
return _core.MenuItem_GetBackgroundColour(*args, **kwargs)
def SetBitmaps(*args, **kwargs):
- """SetBitmaps(wxBitmap bmpChecked, wxBitmap bmpUnchecked=wxNullBitmap)"""
+ """SetBitmaps(Bitmap bmpChecked, Bitmap bmpUnchecked=wxNullBitmap)"""
return _core.MenuItem_SetBitmaps(*args, **kwargs)
def SetDisabledBitmap(*args, **kwargs):
- """SetDisabledBitmap(wxBitmap bmpDisabled)"""
+ """SetDisabledBitmap(Bitmap bmpDisabled)"""
return _core.MenuItem_SetDisabledBitmap(*args, **kwargs)
def GetDisabledBitmap(*args, **kwargs):
- """GetDisabledBitmap() -> wxBitmap"""
+ """GetDisabledBitmap() -> Bitmap"""
return _core.MenuItem_GetDisabledBitmap(*args, **kwargs)
def SetMarginWidth(*args, **kwargs):
return _core.MenuItem_ResetOwnerDrawn(*args, **kwargs)
def SetBitmap(*args, **kwargs):
- """SetBitmap(wxBitmap bitmap)"""
+ """SetBitmap(Bitmap bitmap)"""
return _core.MenuItem_SetBitmap(*args, **kwargs)
def GetBitmap(*args, **kwargs):
- """GetBitmap() -> wxBitmap"""
+ """GetBitmap() -> Bitmap"""
return _core.MenuItem_GetBitmap(*args, **kwargs)
_core.MenuItem_swigregister(MenuItemPtr)
def MenuItem_GetLabelFromText(*args, **kwargs):
- """MenuItem_GetLabelFromText(wxString text) -> wxString"""
+ """MenuItem_GetLabelFromText(String text) -> String"""
return _core.MenuItem_GetLabelFromText(*args, **kwargs)
def MenuItem_GetDefaultMarginWidth(*args, **kwargs):
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
- wxString name=wxPyControlNameStr) -> Control
+ String name=ControlNameStr) -> Control
"""
newobj = _core.new_Control(*args, **kwargs)
self.this = newobj.this
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=0, Validator validator=DefaultValidator,
- wxString name=wxPyControlNameStr) -> bool
+ String name=ControlNameStr) -> bool
"""
return _core.Control_Create(*args, **kwargs)
return _core.Control_Command(*args, **kwargs)
def GetLabel(*args, **kwargs):
- """GetLabel() -> wxString"""
+ """GetLabel() -> String"""
return _core.Control_GetLabel(*args, **kwargs)
def SetLabel(*args, **kwargs):
- """SetLabel(wxString label)"""
+ """SetLabel(String label)"""
return _core.Control_SetLabel(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = Control
_core.Control_swigregister(ControlPtr)
+ControlNameStr = cvar.ControlNameStr
def PreControl(*args, **kwargs):
"""PreControl() -> Control"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxItemContainer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def Append(*args, **kwargs):
- """Append(wxString item, PyObject clientData=None) -> int"""
+ """Append(String item, PyObject clientData=None) -> int"""
return _core.ItemContainer_Append(*args, **kwargs)
def AppendItems(*args, **kwargs):
return _core.ItemContainer_AppendItems(*args, **kwargs)
def Insert(*args, **kwargs):
- """Insert(wxString item, int pos, PyObject clientData=None) -> int"""
+ """Insert(String item, int pos, PyObject clientData=None) -> int"""
return _core.ItemContainer_Insert(*args, **kwargs)
def Clear(*args, **kwargs):
return _core.ItemContainer_IsEmpty(*args, **kwargs)
def GetString(*args, **kwargs):
- """GetString(int n) -> wxString"""
+ """GetString(int n) -> String"""
return _core.ItemContainer_GetString(*args, **kwargs)
def GetStrings(*args, **kwargs):
return _core.ItemContainer_GetStrings(*args, **kwargs)
def SetString(*args, **kwargs):
- """SetString(int n, wxString s)"""
+ """SetString(int n, String s)"""
return _core.ItemContainer_SetString(*args, **kwargs)
def FindString(*args, **kwargs):
- """FindString(wxString s) -> int"""
+ """FindString(String s) -> int"""
return _core.ItemContainer_FindString(*args, **kwargs)
def Select(*args, **kwargs):
return _core.ItemContainer_GetSelection(*args, **kwargs)
def GetStringSelection(*args, **kwargs):
- """GetStringSelection() -> wxString"""
+ """GetStringSelection() -> String"""
return _core.ItemContainer_GetStringSelection(*args, **kwargs)
def GetClientData(*args, **kwargs):
return _core.FlexGridSizer_GetFlexibleDirection(*args, **kwargs)
def SetNonFlexibleGrowMode(*args, **kwargs):
- """SetNonFlexibleGrowMode(wxFlexSizerGrowMode mode)"""
+ """SetNonFlexibleGrowMode(int mode)"""
return _core.FlexGridSizer_SetNonFlexibleGrowMode(*args, **kwargs)
def GetNonFlexibleGrowMode(*args, **kwargs):
- """GetNonFlexibleGrowMode() -> wxFlexSizerGrowMode"""
+ """GetNonFlexibleGrowMode() -> int"""
return _core.FlexGridSizer_GetNonFlexibleGrowMode(*args, **kwargs)
def GetRowHeights(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxIndividualLayoutConstraint instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def Set(*args, **kwargs):
- """
- Set(wxRelationship rel, Window otherW, wxEdge otherE, int val=0,
- int marg=wxLAYOUT_DEFAULT_MARGIN)
- """
+ """Set(int rel, Window otherW, int otherE, int val=0, int marg=wxLAYOUT_DEFAULT_MARGIN)"""
return _core.IndividualLayoutConstraint_Set(*args, **kwargs)
def LeftOf(*args, **kwargs):
return _core.IndividualLayoutConstraint_Below(*args, **kwargs)
def SameAs(*args, **kwargs):
- """SameAs(Window otherW, wxEdge edge, int marg=0)"""
+ """SameAs(Window otherW, int edge, int marg=0)"""
return _core.IndividualLayoutConstraint_SameAs(*args, **kwargs)
def PercentOf(*args, **kwargs):
- """PercentOf(Window otherW, wxEdge wh, int per)"""
+ """PercentOf(Window otherW, int wh, int per)"""
return _core.IndividualLayoutConstraint_PercentOf(*args, **kwargs)
def Absolute(*args, **kwargs):
return _core.IndividualLayoutConstraint_GetOtherWindow(*args, **kwargs)
def GetMyEdge(*args, **kwargs):
- """GetMyEdge() -> wxEdge"""
+ """GetMyEdge() -> int"""
return _core.IndividualLayoutConstraint_GetMyEdge(*args, **kwargs)
def SetEdge(*args, **kwargs):
- """SetEdge(wxEdge which)"""
+ """SetEdge(int which)"""
return _core.IndividualLayoutConstraint_SetEdge(*args, **kwargs)
def SetValue(*args, **kwargs):
return _core.IndividualLayoutConstraint_SetDone(*args, **kwargs)
def GetRelationship(*args, **kwargs):
- """GetRelationship() -> wxRelationship"""
+ """GetRelationship() -> int"""
return _core.IndividualLayoutConstraint_GetRelationship(*args, **kwargs)
def SetRelationship(*args, **kwargs):
- """SetRelationship(wxRelationship r)"""
+ """SetRelationship(int r)"""
return _core.IndividualLayoutConstraint_SetRelationship(*args, **kwargs)
def ResetIfWin(*args, **kwargs):
return _core.IndividualLayoutConstraint_SatisfyConstraint(*args, **kwargs)
def GetEdge(*args, **kwargs):
- """GetEdge(wxEdge which, Window thisWin, Window other) -> int"""
+ """GetEdge(int which, Window thisWin, Window other) -> int"""
return _core.IndividualLayoutConstraint_GetEdge(*args, **kwargs)
class PyDeadObjectError(AttributeError):
pass
-
class _wxPyDeadObject(object):
"""
Instances of wx objects that are OOR capable will have their __class__
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 ):
+ def __repr__(self):
if not hasattr(self, "_name"):
self._name = "[unknown]"
return self.reprStr % self._name
- def __getattr__( self, *args ):
+ def __getattr__(self, *args):
if not hasattr(self, "_name"):
self._name = "[unknown]"
- raise PyDeadObjectError( self.attrStr % self._name )
+ 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
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()
+
#----------------------------------------------------------------------------
#----------------------------------------------------------------------------
#endif
- DECLARE_DEF_STRING(EmptyString);
-// DECLARE_DEF_STRING(PanelNameStr);
-
-
#if ! wxUSE_HOTKEY
enum wxHotkeyModifier
{
#define wxEVT_HOTKEY 9999
#endif
+ static const wxString wxPyEmptyString(wxEmptyString);
wxString wxObject_GetClassName(wxObject *self){
return self->GetClassInfo()->GetClassName();
}
wxMenuItemList& list = self->GetMenuItems();
return wxPy_ConvertList(&list);
}
-
- DECLARE_DEF_STRING(ControlNameStr);
-
+ static const wxString wxPyControlNameStr(wxControlNameStr);
int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData){
if (clientData) {
wxPyClientData* data = new wxPyClientData(clientData);
#ifdef __cplusplus
extern "C" {
#endif
+static int _wrap_EmptyString_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable EmptyString is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_EmptyString_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_Object_GetClassName(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxObject *arg1 = (wxObject *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_ControlNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable ControlNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_ControlNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_Control(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
}
static PyMethodDef SwigMethods[] = {
{ (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS },
+ { (char *)"_wxPyFixStockObjects", __wxPyFixStockObjects, METH_VARARGS },
{ (char *)"Object_GetClassName", (PyCFunction) _wrap_Object_GetClassName, METH_VARARGS | METH_KEYWORDS },
{ (char *)"Object_Destroy", (PyCFunction) _wrap_Object_Destroy, METH_VARARGS | METH_KEYWORDS },
{ (char *)"Object_swigregister", Object_swigregister, METH_VARARGS },
{ SWIG_PY_INT, (char *)"UPDATE_UI_FROMIDLE", (long) wxUPDATE_UI_FROMIDLE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_INVALID", (long) wxBITMAP_TYPE_INVALID, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_BMP", (long) wxBITMAP_TYPE_BMP, 0, 0, 0},
-{ SWIG_PY_INT, (char *)"BITMAP_TYPE_BMP_RESOURCE", (long) wxBITMAP_TYPE_BMP_RESOURCE, 0, 0, 0},
-{ SWIG_PY_INT, (char *)"BITMAP_TYPE_RESOURCE", (long) wxBITMAP_TYPE_RESOURCE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_ICO", (long) wxBITMAP_TYPE_ICO, 0, 0, 0},
-{ SWIG_PY_INT, (char *)"BITMAP_TYPE_ICO_RESOURCE", (long) wxBITMAP_TYPE_ICO_RESOURCE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_CUR", (long) wxBITMAP_TYPE_CUR, 0, 0, 0},
-{ SWIG_PY_INT, (char *)"BITMAP_TYPE_CUR_RESOURCE", (long) wxBITMAP_TYPE_CUR_RESOURCE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_XBM", (long) wxBITMAP_TYPE_XBM, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_XBM_DATA", (long) wxBITMAP_TYPE_XBM_DATA, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_XPM", (long) wxBITMAP_TYPE_XPM, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_XPM_DATA", (long) wxBITMAP_TYPE_XPM_DATA, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_TIF", (long) wxBITMAP_TYPE_TIF, 0, 0, 0},
-{ SWIG_PY_INT, (char *)"BITMAP_TYPE_TIF_RESOURCE", (long) wxBITMAP_TYPE_TIF_RESOURCE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_GIF", (long) wxBITMAP_TYPE_GIF, 0, 0, 0},
-{ SWIG_PY_INT, (char *)"BITMAP_TYPE_GIF_RESOURCE", (long) wxBITMAP_TYPE_GIF_RESOURCE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_PNG", (long) wxBITMAP_TYPE_PNG, 0, 0, 0},
-{ SWIG_PY_INT, (char *)"BITMAP_TYPE_PNG_RESOURCE", (long) wxBITMAP_TYPE_PNG_RESOURCE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_JPEG", (long) wxBITMAP_TYPE_JPEG, 0, 0, 0},
-{ SWIG_PY_INT, (char *)"BITMAP_TYPE_JPEG_RESOURCE", (long) wxBITMAP_TYPE_JPEG_RESOURCE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_PNM", (long) wxBITMAP_TYPE_PNM, 0, 0, 0},
-{ SWIG_PY_INT, (char *)"BITMAP_TYPE_PNM_RESOURCE", (long) wxBITMAP_TYPE_PNM_RESOURCE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_PCX", (long) wxBITMAP_TYPE_PCX, 0, 0, 0},
-{ SWIG_PY_INT, (char *)"BITMAP_TYPE_PCX_RESOURCE", (long) wxBITMAP_TYPE_PCX_RESOURCE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_PICT", (long) wxBITMAP_TYPE_PICT, 0, 0, 0},
-{ SWIG_PY_INT, (char *)"BITMAP_TYPE_PICT_RESOURCE", (long) wxBITMAP_TYPE_PICT_RESOURCE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_ICON", (long) wxBITMAP_TYPE_ICON, 0, 0, 0},
-{ SWIG_PY_INT, (char *)"BITMAP_TYPE_ICON_RESOURCE", (long) wxBITMAP_TYPE_ICON_RESOURCE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_ANI", (long) wxBITMAP_TYPE_ANI, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_IFF", (long) wxBITMAP_TYPE_IFF, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_MACCURSOR", (long) wxBITMAP_TYPE_MACCURSOR, 0, 0, 0},
-{ SWIG_PY_INT, (char *)"BITMAP_TYPE_MACCURSOR_RESOURCE", (long) wxBITMAP_TYPE_MACCURSOR_RESOURCE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"BITMAP_TYPE_ANY", (long) wxBITMAP_TYPE_ANY, 0, 0, 0},
{ SWIG_PY_INT, (char *)"CURSOR_NONE", (long) wxCURSOR_NONE, 0, 0, 0},
{ SWIG_PY_INT, (char *)"CURSOR_ARROW", (long) wxCURSOR_ARROW, 0, 0, 0},
#endif
PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
+ SWIG_addvarlink(SWIG_globals,(char*)"EmptyString",_wrap_EmptyString_get, _wrap_EmptyString_set);
SWIG_addvarlink(SWIG_globals,(char*)"DefaultPosition",_wrap_DefaultPosition_get, _wrap_DefaultPosition_set);
SWIG_addvarlink(SWIG_globals,(char*)"DefaultSize",_wrap_DefaultSize_get, _wrap_DefaultSize_set);
SWIG_addvarlink(SWIG_globals,(char*)"NullAcceleratorTable",_wrap_NullAcceleratorTable_get, _wrap_NullAcceleratorTable_set);
SWIG_addvarlink(SWIG_globals,(char*)"PanelNameStr",_wrap_PanelNameStr_get, _wrap_PanelNameStr_set);
SWIG_addvarlink(SWIG_globals,(char*)"DefaultValidator",_wrap_DefaultValidator_get, _wrap_DefaultValidator_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"ControlNameStr",_wrap_ControlNameStr_get, _wrap_ControlNameStr_set);
SWIG_addvarlink(SWIG_globals,(char*)"DefaultSpan",_wrap_DefaultSpan_get, _wrap_DefaultSpan_set);
// Initialize threading, some globals and such
return _gdi.Colour___ne__(*args, **kwargs)
def InitFromName(*args, **kwargs):
- """InitFromName(wxString colourName)"""
+ """InitFromName(String colourName)"""
return _gdi.Colour_InitFromName(*args, **kwargs)
def Get(*args, **kwargs):
asTuple = Get
def __str__(self): return str(self.asTuple())
- def __repr__(self): return 'wxColour' + str(self.asTuple())
+ def __repr__(self): return 'wx.Colour' + str(self.asTuple())
def __nonzero__(self): return self.Ok()
def __getinitargs__(self): return ()
def __getstate__(self): return self.asTuple()
_gdi.Colour_swigregister(ColourPtr)
def NamedColour(*args, **kwargs):
- """NamedColour(wxString colorName) -> Colour"""
+ """NamedColour(String colorName) -> Colour"""
val = _gdi.new_NamedColour(*args, **kwargs)
val.thisown = 1
return val
return "<%s.%s; proxy of C++ wxBitmap instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(wxString name, wxBitmapType type=BITMAP_TYPE_ANY) -> Bitmap
+ __init__(String name, int type=BITMAP_TYPE_ANY) -> Bitmap
Loads a bitmap from a file.
"""
def SaveFile(*args, **kwargs):
"""
- SaveFile(wxString name, wxBitmapType type, Palette palette=(wxPalette *) NULL) -> bool
+ SaveFile(String name, int type, Palette palette=(wxPalette *) NULL) -> bool
Saves a bitmap in the named file.
"""
def LoadFile(*args, **kwargs):
"""
- LoadFile(wxString name, wxBitmapType type) -> bool
+ LoadFile(String name, int type) -> bool
Loads a bitmap from a file
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxIcon instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString name, long flags, int desiredWidth=-1, int desiredHeight=-1) -> Icon"""
+ """__init__(String name, long flags, int desiredWidth=-1, int desiredHeight=-1) -> Icon"""
newobj = _gdi.new_Icon(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def LoadFile(*args, **kwargs):
- """LoadFile(wxString name, long flags) -> bool"""
+ """LoadFile(String name, long flags) -> bool"""
return _gdi.Icon_LoadFile(*args, **kwargs)
def GetHandle(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxIconLocation instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString filename=&wxPyEmptyString, int num=0) -> IconLocation"""
+ """__init__(String filename=&wxPyEmptyString, int num=0) -> IconLocation"""
newobj = _gdi.new_IconLocation(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
def __nonzero__(self): return self.Ok()
def SetFileName(*args, **kwargs):
- """SetFileName(wxString filename)"""
+ """SetFileName(String filename)"""
return _gdi.IconLocation_SetFileName(*args, **kwargs)
def GetFileName(*args, **kwargs):
- """GetFileName() -> wxString"""
+ """GetFileName() -> String"""
return _gdi.IconLocation_GetFileName(*args, **kwargs)
def SetIndex(*args, **kwargs):
return _gdi.IconBundle_AddIcon(*args, **kwargs)
def AddIconFromFile(*args, **kwargs):
- """AddIconFromFile(wxString file, long type)"""
+ """AddIconFromFile(String file, long type)"""
return _gdi.IconBundle_AddIconFromFile(*args, **kwargs)
def GetIcon(*args, **kwargs):
_gdi.IconBundle_swigregister(IconBundlePtr)
def IconBundleFromFile(*args, **kwargs):
- """IconBundleFromFile(wxString file, long type) -> IconBundle"""
+ """IconBundleFromFile(String file, long type) -> IconBundle"""
val = _gdi.new_IconBundleFromFile(*args, **kwargs)
val.thisown = 1
return val
def __repr__(self):
return "<%s.%s; proxy of C++ wxCursor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString cursorName, long flags, int hotSpotX=0, int hotSpotY=0) -> Cursor"""
+ """__init__(String cursorName, long flags, int hotSpotX=0, int hotSpotY=0) -> Cursor"""
newobj = _gdi.new_Cursor(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _gdi.Region_Offset(*args, **kwargs)
def Contains(*args, **kwargs):
- """Contains(int x, int y) -> wxRegionContain"""
+ """Contains(int x, int y) -> int"""
return _gdi.Region_Contains(*args, **kwargs)
def ContainsPoint(*args, **kwargs):
- """ContainsPoint(Point pt) -> wxRegionContain"""
+ """ContainsPoint(Point pt) -> int"""
return _gdi.Region_ContainsPoint(*args, **kwargs)
def ContainsRect(*args, **kwargs):
- """ContainsRect(Rect rect) -> wxRegionContain"""
+ """ContainsRect(Rect rect) -> int"""
return _gdi.Region_ContainsRect(*args, **kwargs)
def ContainsRectDim(*args, **kwargs):
- """ContainsRectDim(int x, int y, int w, int h) -> wxRegionContain"""
+ """ContainsRectDim(int x, int y, int w, int h) -> int"""
return _gdi.Region_ContainsRectDim(*args, **kwargs)
def GetBox(*args, **kwargs):
return _gdi.NativeFontInfo_GetPointSize(*args, **kwargs)
def GetStyle(*args, **kwargs):
- """GetStyle() -> wxFontStyle"""
+ """GetStyle() -> int"""
return _gdi.NativeFontInfo_GetStyle(*args, **kwargs)
def GetWeight(*args, **kwargs):
- """GetWeight() -> wxFontWeight"""
+ """GetWeight() -> int"""
return _gdi.NativeFontInfo_GetWeight(*args, **kwargs)
def GetUnderlined(*args, **kwargs):
return _gdi.NativeFontInfo_GetUnderlined(*args, **kwargs)
def GetFaceName(*args, **kwargs):
- """GetFaceName() -> wxString"""
+ """GetFaceName() -> String"""
return _gdi.NativeFontInfo_GetFaceName(*args, **kwargs)
def GetFamily(*args, **kwargs):
- """GetFamily() -> wxFontFamily"""
+ """GetFamily() -> int"""
return _gdi.NativeFontInfo_GetFamily(*args, **kwargs)
def GetEncoding(*args, **kwargs):
- """GetEncoding() -> wxFontEncoding"""
+ """GetEncoding() -> int"""
return _gdi.NativeFontInfo_GetEncoding(*args, **kwargs)
def SetPointSize(*args, **kwargs):
return _gdi.NativeFontInfo_SetPointSize(*args, **kwargs)
def SetStyle(*args, **kwargs):
- """SetStyle(wxFontStyle style)"""
+ """SetStyle(int style)"""
return _gdi.NativeFontInfo_SetStyle(*args, **kwargs)
def SetWeight(*args, **kwargs):
- """SetWeight(wxFontWeight weight)"""
+ """SetWeight(int weight)"""
return _gdi.NativeFontInfo_SetWeight(*args, **kwargs)
def SetUnderlined(*args, **kwargs):
return _gdi.NativeFontInfo_SetUnderlined(*args, **kwargs)
def SetFaceName(*args, **kwargs):
- """SetFaceName(wxString facename)"""
+ """SetFaceName(String facename)"""
return _gdi.NativeFontInfo_SetFaceName(*args, **kwargs)
def SetFamily(*args, **kwargs):
- """SetFamily(wxFontFamily family)"""
+ """SetFamily(int family)"""
return _gdi.NativeFontInfo_SetFamily(*args, **kwargs)
def SetEncoding(*args, **kwargs):
- """SetEncoding(wxFontEncoding encoding)"""
+ """SetEncoding(int encoding)"""
return _gdi.NativeFontInfo_SetEncoding(*args, **kwargs)
def FromString(*args, **kwargs):
- """FromString(wxString s) -> bool"""
+ """FromString(String s) -> bool"""
return _gdi.NativeFontInfo_FromString(*args, **kwargs)
def ToString(*args, **kwargs):
- """ToString() -> wxString"""
+ """ToString() -> String"""
return _gdi.NativeFontInfo_ToString(*args, **kwargs)
def __str__(*args, **kwargs):
- """__str__() -> wxString"""
+ """__str__() -> String"""
return _gdi.NativeFontInfo___str__(*args, **kwargs)
def FromUserString(*args, **kwargs):
- """FromUserString(wxString s) -> bool"""
+ """FromUserString(String s) -> bool"""
return _gdi.NativeFontInfo_FromUserString(*args, **kwargs)
def ToUserString(*args, **kwargs):
- """ToUserString() -> wxString"""
+ """ToUserString() -> String"""
return _gdi.NativeFontInfo_ToUserString(*args, **kwargs)
except: pass
def FromString(*args, **kwargs):
- """FromString(wxString s) -> bool"""
+ """FromString(String s) -> bool"""
return _gdi.NativeEncodingInfo_FromString(*args, **kwargs)
def ToString(*args, **kwargs):
- """ToString() -> wxString"""
+ """ToString() -> String"""
return _gdi.NativeEncodingInfo_ToString(*args, **kwargs)
def GetNativeFontEncoding(*args, **kwargs):
- """GetNativeFontEncoding(wxFontEncoding encoding) -> NativeEncodingInfo"""
+ """GetNativeFontEncoding(int encoding) -> NativeEncodingInfo"""
return _gdi.GetNativeFontEncoding(*args, **kwargs)
def TestFontEncoding(*args, **kwargs):
Set = staticmethod(Set)
def CharsetToEncoding(*args, **kwargs):
- """CharsetToEncoding(wxString charset, bool interactive=True) -> wxFontEncoding"""
+ """CharsetToEncoding(String charset, bool interactive=True) -> int"""
return _gdi.FontMapper_CharsetToEncoding(*args, **kwargs)
def GetSupportedEncodingsCount(*args, **kwargs):
GetSupportedEncodingsCount = staticmethod(GetSupportedEncodingsCount)
def GetEncoding(*args, **kwargs):
- """FontMapper.GetEncoding(size_t n) -> wxFontEncoding"""
+ """FontMapper.GetEncoding(size_t n) -> int"""
return _gdi.FontMapper_GetEncoding(*args, **kwargs)
GetEncoding = staticmethod(GetEncoding)
def GetEncodingName(*args, **kwargs):
- """FontMapper.GetEncodingName(wxFontEncoding encoding) -> wxString"""
+ """FontMapper.GetEncodingName(int encoding) -> String"""
return _gdi.FontMapper_GetEncodingName(*args, **kwargs)
GetEncodingName = staticmethod(GetEncodingName)
def GetEncodingDescription(*args, **kwargs):
- """FontMapper.GetEncodingDescription(wxFontEncoding encoding) -> wxString"""
+ """FontMapper.GetEncodingDescription(int encoding) -> String"""
return _gdi.FontMapper_GetEncodingDescription(*args, **kwargs)
GetEncodingDescription = staticmethod(GetEncodingDescription)
def SetConfig(*args, **kwargs):
- """SetConfig(wxConfigBase config)"""
+ """SetConfig(ConfigBase config)"""
return _gdi.FontMapper_SetConfig(*args, **kwargs)
def SetConfigPath(*args, **kwargs):
- """SetConfigPath(wxString prefix)"""
+ """SetConfigPath(String prefix)"""
return _gdi.FontMapper_SetConfigPath(*args, **kwargs)
def GetDefaultConfigPath(*args, **kwargs):
- """FontMapper.GetDefaultConfigPath() -> wxString"""
+ """FontMapper.GetDefaultConfigPath() -> String"""
return _gdi.FontMapper_GetDefaultConfigPath(*args, **kwargs)
GetDefaultConfigPath = staticmethod(GetDefaultConfigPath)
def GetAltForEncoding(*args, **kwargs):
- """
- GetAltForEncoding(wxFontEncoding encoding, wxString facename=wxPyEmptyString,
- bool interactive=True) -> PyObject
- """
+ """GetAltForEncoding(int encoding, String facename=EmptyString, bool interactive=True) -> PyObject"""
return _gdi.FontMapper_GetAltForEncoding(*args, **kwargs)
def IsEncodingAvailable(*args, **kwargs):
- """IsEncodingAvailable(wxFontEncoding encoding, wxString facename=wxPyEmptyString) -> bool"""
+ """IsEncodingAvailable(int encoding, String facename=EmptyString) -> bool"""
return _gdi.FontMapper_IsEncodingAvailable(*args, **kwargs)
def SetDialogParent(*args, **kwargs):
return _gdi.FontMapper_SetDialogParent(*args, **kwargs)
def SetDialogTitle(*args, **kwargs):
- """SetDialogTitle(wxString title)"""
+ """SetDialogTitle(String title)"""
return _gdi.FontMapper_SetDialogTitle(*args, **kwargs)
return _gdi.FontMapper_GetSupportedEncodingsCount(*args, **kwargs)
def FontMapper_GetEncoding(*args, **kwargs):
- """FontMapper_GetEncoding(size_t n) -> wxFontEncoding"""
+ """FontMapper_GetEncoding(size_t n) -> int"""
return _gdi.FontMapper_GetEncoding(*args, **kwargs)
def FontMapper_GetEncodingName(*args, **kwargs):
- """FontMapper_GetEncodingName(wxFontEncoding encoding) -> wxString"""
+ """FontMapper_GetEncodingName(int encoding) -> String"""
return _gdi.FontMapper_GetEncodingName(*args, **kwargs)
def FontMapper_GetEncodingDescription(*args, **kwargs):
- """FontMapper_GetEncodingDescription(wxFontEncoding encoding) -> wxString"""
+ """FontMapper_GetEncodingDescription(int encoding) -> String"""
return _gdi.FontMapper_GetEncodingDescription(*args, **kwargs)
def FontMapper_GetDefaultConfigPath(*args, **kwargs):
- """FontMapper_GetDefaultConfigPath() -> wxString"""
+ """FontMapper_GetDefaultConfigPath() -> String"""
return _gdi.FontMapper_GetDefaultConfigPath(*args, **kwargs)
#---------------------------------------------------------------------------
def __init__(self, *args, **kwargs):
"""
__init__(int pointSize, int family, int style, int weight, bool underline=False,
- wxString face=wxPyEmptyString,
- wxFontEncoding encoding=FONTENCODING_DEFAULT) -> Font
+ String face=EmptyString,
+ int encoding=FONTENCODING_DEFAULT) -> Font
"""
newobj = _gdi.new_Font(*args, **kwargs)
self.this = newobj.this
return _gdi.Font_GetUnderlined(*args, **kwargs)
def GetFaceName(*args, **kwargs):
- """GetFaceName() -> wxString"""
+ """GetFaceName() -> String"""
return _gdi.Font_GetFaceName(*args, **kwargs)
def GetEncoding(*args, **kwargs):
- """GetEncoding() -> wxFontEncoding"""
+ """GetEncoding() -> int"""
return _gdi.Font_GetEncoding(*args, **kwargs)
def GetNativeFontInfo(*args, **kwargs):
return _gdi.Font_IsFixedWidth(*args, **kwargs)
def GetNativeFontInfoDesc(*args, **kwargs):
- """GetNativeFontInfoDesc() -> wxString"""
+ """GetNativeFontInfoDesc() -> String"""
return _gdi.Font_GetNativeFontInfoDesc(*args, **kwargs)
def GetNativeFontInfoUserDesc(*args, **kwargs):
- """GetNativeFontInfoUserDesc() -> wxString"""
+ """GetNativeFontInfoUserDesc() -> String"""
return _gdi.Font_GetNativeFontInfoUserDesc(*args, **kwargs)
def SetPointSize(*args, **kwargs):
return _gdi.Font_SetWeight(*args, **kwargs)
def SetFaceName(*args, **kwargs):
- """SetFaceName(wxString faceName)"""
+ """SetFaceName(String faceName)"""
return _gdi.Font_SetFaceName(*args, **kwargs)
def SetUnderlined(*args, **kwargs):
return _gdi.Font_SetUnderlined(*args, **kwargs)
def SetEncoding(*args, **kwargs):
- """SetEncoding(wxFontEncoding encoding)"""
+ """SetEncoding(int encoding)"""
return _gdi.Font_SetEncoding(*args, **kwargs)
def SetNativeFontInfo(*args, **kwargs):
return _gdi.Font_SetNativeFontInfo(*args, **kwargs)
def SetNativeFontInfoFromString(*args, **kwargs):
- """SetNativeFontInfoFromString(wxString info)"""
+ """SetNativeFontInfoFromString(String info)"""
return _gdi.Font_SetNativeFontInfoFromString(*args, **kwargs)
def SetNativeFontInfoUserDesc(*args, **kwargs):
- """SetNativeFontInfoUserDesc(wxString info)"""
+ """SetNativeFontInfoUserDesc(String info)"""
return _gdi.Font_SetNativeFontInfoUserDesc(*args, **kwargs)
def GetFamilyString(*args, **kwargs):
- """GetFamilyString() -> wxString"""
+ """GetFamilyString() -> String"""
return _gdi.Font_GetFamilyString(*args, **kwargs)
def GetStyleString(*args, **kwargs):
- """GetStyleString() -> wxString"""
+ """GetStyleString() -> String"""
return _gdi.Font_GetStyleString(*args, **kwargs)
def GetWeightString(*args, **kwargs):
- """GetWeightString() -> wxString"""
+ """GetWeightString() -> String"""
return _gdi.Font_GetWeightString(*args, **kwargs)
def SetNoAntiAliasing(*args, **kwargs):
return _gdi.Font_GetNoAntiAliasing(*args, **kwargs)
def GetDefaultEncoding(*args, **kwargs):
- """Font.GetDefaultEncoding() -> wxFontEncoding"""
+ """Font.GetDefaultEncoding() -> int"""
return _gdi.Font_GetDefaultEncoding(*args, **kwargs)
GetDefaultEncoding = staticmethod(GetDefaultEncoding)
def SetDefaultEncoding(*args, **kwargs):
- """Font.SetDefaultEncoding(wxFontEncoding encoding)"""
+ """Font.SetDefaultEncoding(int encoding)"""
return _gdi.Font_SetDefaultEncoding(*args, **kwargs)
SetDefaultEncoding = staticmethod(SetDefaultEncoding)
return val
def FontFromNativeInfoString(*args, **kwargs):
- """FontFromNativeInfoString(wxString info) -> Font"""
+ """FontFromNativeInfoString(String info) -> Font"""
val = _gdi.new_FontFromNativeInfoString(*args, **kwargs)
val.thisown = 1
return val
def Font2(*args, **kwargs):
"""
- Font2(int pointSize, wxFontFamily family, int flags=FONTFLAG_DEFAULT,
- wxString face=wxPyEmptyString, wxFontEncoding encoding=FONTENCODING_DEFAULT) -> Font
+ Font2(int pointSize, int family, int flags=FONTFLAG_DEFAULT,
+ String face=EmptyString, int encoding=FONTENCODING_DEFAULT) -> Font
"""
val = _gdi.new_Font2(*args, **kwargs)
val.thisown = 1
return val
def Font_GetDefaultEncoding(*args, **kwargs):
- """Font_GetDefaultEncoding() -> wxFontEncoding"""
+ """Font_GetDefaultEncoding() -> int"""
return _gdi.Font_GetDefaultEncoding(*args, **kwargs)
def Font_SetDefaultEncoding(*args, **kwargs):
- """Font_SetDefaultEncoding(wxFontEncoding encoding)"""
+ """Font_SetDefaultEncoding(int encoding)"""
return _gdi.Font_SetDefaultEncoding(*args, **kwargs)
#---------------------------------------------------------------------------
return _gdi.FontEnumerator__setCallbackInfo(*args, **kwargs)
def EnumerateFacenames(*args, **kwargs):
- """EnumerateFacenames(wxFontEncoding encoding=FONTENCODING_SYSTEM, bool fixedWidthOnly=False) -> bool"""
+ """EnumerateFacenames(int encoding=FONTENCODING_SYSTEM, bool fixedWidthOnly=False) -> bool"""
return _gdi.FontEnumerator_EnumerateFacenames(*args, **kwargs)
def EnumerateEncodings(*args, **kwargs):
- """EnumerateEncodings(wxString facename=wxPyEmptyString) -> bool"""
+ """EnumerateEncodings(String facename=EmptyString) -> bool"""
return _gdi.FontEnumerator_EnumerateEncodings(*args, **kwargs)
def GetEncodings(*args, **kwargs):
def Init1(*args, **kwargs):
"""
- Init1(wxString szName, wxString szShort=wxPyEmptyString,
- wxString szLocale=wxPyEmptyString, bool bLoadDefault=True,
+ Init1(String szName, String szShort=EmptyString, String szLocale=EmptyString,
+ bool bLoadDefault=True,
bool bConvertEncoding=False) -> bool
"""
return _gdi.Locale_Init1(*args, **kwargs)
GetSystemLanguage = staticmethod(GetSystemLanguage)
def GetSystemEncoding(*args, **kwargs):
- """Locale.GetSystemEncoding() -> wxFontEncoding"""
+ """Locale.GetSystemEncoding() -> int"""
return _gdi.Locale_GetSystemEncoding(*args, **kwargs)
GetSystemEncoding = staticmethod(GetSystemEncoding)
def GetSystemEncodingName(*args, **kwargs):
- """Locale.GetSystemEncodingName() -> wxString"""
+ """Locale.GetSystemEncodingName() -> String"""
return _gdi.Locale_GetSystemEncodingName(*args, **kwargs)
GetSystemEncodingName = staticmethod(GetSystemEncodingName)
def __nonzero__(self): return self.IsOk()
def GetLocale(*args, **kwargs):
- """GetLocale() -> wxString"""
+ """GetLocale() -> String"""
return _gdi.Locale_GetLocale(*args, **kwargs)
def GetLanguage(*args, **kwargs):
return _gdi.Locale_GetLanguage(*args, **kwargs)
def GetSysName(*args, **kwargs):
- """GetSysName() -> wxString"""
+ """GetSysName() -> String"""
return _gdi.Locale_GetSysName(*args, **kwargs)
def GetCanonicalName(*args, **kwargs):
- """GetCanonicalName() -> wxString"""
+ """GetCanonicalName() -> String"""
return _gdi.Locale_GetCanonicalName(*args, **kwargs)
def AddCatalogLookupPathPrefix(*args, **kwargs):
- """Locale.AddCatalogLookupPathPrefix(wxString prefix)"""
+ """Locale.AddCatalogLookupPathPrefix(String prefix)"""
return _gdi.Locale_AddCatalogLookupPathPrefix(*args, **kwargs)
AddCatalogLookupPathPrefix = staticmethod(AddCatalogLookupPathPrefix)
def AddCatalog(*args, **kwargs):
- """AddCatalog(wxString szDomain) -> bool"""
+ """AddCatalog(String szDomain) -> bool"""
return _gdi.Locale_AddCatalog(*args, **kwargs)
def IsLoaded(*args, **kwargs):
- """IsLoaded(wxString szDomain) -> bool"""
+ """IsLoaded(String szDomain) -> bool"""
return _gdi.Locale_IsLoaded(*args, **kwargs)
def GetLanguageInfo(*args, **kwargs):
GetLanguageInfo = staticmethod(GetLanguageInfo)
def GetLanguageName(*args, **kwargs):
- """Locale.GetLanguageName(int lang) -> wxString"""
+ """Locale.GetLanguageName(int lang) -> String"""
return _gdi.Locale_GetLanguageName(*args, **kwargs)
GetLanguageName = staticmethod(GetLanguageName)
def FindLanguageInfo(*args, **kwargs):
- """Locale.FindLanguageInfo(wxString locale) -> LanguageInfo"""
+ """Locale.FindLanguageInfo(String locale) -> LanguageInfo"""
return _gdi.Locale_FindLanguageInfo(*args, **kwargs)
FindLanguageInfo = staticmethod(FindLanguageInfo)
AddLanguage = staticmethod(AddLanguage)
def GetString(*args, **kwargs):
- """GetString(wxString szOrigString, wxString szDomain=wxPyEmptyString) -> wxString"""
+ """GetString(String szOrigString, String szDomain=EmptyString) -> String"""
return _gdi.Locale_GetString(*args, **kwargs)
def GetName(*args, **kwargs):
- """GetName() -> wxString"""
+ """GetName() -> String"""
return _gdi.Locale_GetName(*args, **kwargs)
return _gdi.Locale_GetSystemLanguage(*args, **kwargs)
def Locale_GetSystemEncoding(*args, **kwargs):
- """Locale_GetSystemEncoding() -> wxFontEncoding"""
+ """Locale_GetSystemEncoding() -> int"""
return _gdi.Locale_GetSystemEncoding(*args, **kwargs)
def Locale_GetSystemEncodingName(*args, **kwargs):
- """Locale_GetSystemEncodingName() -> wxString"""
+ """Locale_GetSystemEncodingName() -> String"""
return _gdi.Locale_GetSystemEncodingName(*args, **kwargs)
def Locale_AddCatalogLookupPathPrefix(*args, **kwargs):
- """Locale_AddCatalogLookupPathPrefix(wxString prefix)"""
+ """Locale_AddCatalogLookupPathPrefix(String prefix)"""
return _gdi.Locale_AddCatalogLookupPathPrefix(*args, **kwargs)
def Locale_GetLanguageInfo(*args, **kwargs):
return _gdi.Locale_GetLanguageInfo(*args, **kwargs)
def Locale_GetLanguageName(*args, **kwargs):
- """Locale_GetLanguageName(int lang) -> wxString"""
+ """Locale_GetLanguageName(int lang) -> String"""
return _gdi.Locale_GetLanguageName(*args, **kwargs)
def Locale_FindLanguageInfo(*args, **kwargs):
- """Locale_FindLanguageInfo(wxString locale) -> LanguageInfo"""
+ """Locale_FindLanguageInfo(String locale) -> LanguageInfo"""
return _gdi.Locale_FindLanguageInfo(*args, **kwargs)
def Locale_AddLanguage(*args, **kwargs):
except: pass
def Init(*args, **kwargs):
- """
- Init(wxFontEncoding input_enc, wxFontEncoding output_enc,
- int method=CONVERT_STRICT) -> bool
- """
+ """Init(int input_enc, int output_enc, int method=CONVERT_STRICT) -> bool"""
return _gdi.EncodingConverter_Init(*args, **kwargs)
def Convert(*args, **kwargs):
- """Convert(wxString input) -> wxString"""
+ """Convert(String input) -> String"""
return _gdi.EncodingConverter_Convert(*args, **kwargs)
def GetPlatformEquivalents(*args, **kwargs):
- """EncodingConverter.GetPlatformEquivalents(wxFontEncoding enc, int platform=PLATFORM_CURRENT) -> wxFontEncodingArray"""
+ """EncodingConverter.GetPlatformEquivalents(int enc, int platform=PLATFORM_CURRENT) -> wxFontEncodingArray"""
return _gdi.EncodingConverter_GetPlatformEquivalents(*args, **kwargs)
GetPlatformEquivalents = staticmethod(GetPlatformEquivalents)
def GetAllEquivalents(*args, **kwargs):
- """EncodingConverter.GetAllEquivalents(wxFontEncoding enc) -> wxFontEncodingArray"""
+ """EncodingConverter.GetAllEquivalents(int enc) -> wxFontEncodingArray"""
return _gdi.EncodingConverter_GetAllEquivalents(*args, **kwargs)
GetAllEquivalents = staticmethod(GetAllEquivalents)
def CanConvert(*args, **kwargs):
- """EncodingConverter.CanConvert(wxFontEncoding encIn, wxFontEncoding encOut) -> bool"""
+ """EncodingConverter.CanConvert(int encIn, int encOut) -> bool"""
return _gdi.EncodingConverter_CanConvert(*args, **kwargs)
CanConvert = staticmethod(CanConvert)
def GetTranslation(*args):
"""
- GetTranslation(wxString sz) -> wxString
- GetTranslation(wxString sz1, wxString sz2, size_t n) -> wxString
+ GetTranslation(String sz) -> String
+ GetTranslation(String sz1, String sz2, size_t n) -> String
"""
return _gdi.GetTranslation(*args)
def EncodingConverter_GetPlatformEquivalents(*args, **kwargs):
- """EncodingConverter_GetPlatformEquivalents(wxFontEncoding enc, int platform=PLATFORM_CURRENT) -> wxFontEncodingArray"""
+ """EncodingConverter_GetPlatformEquivalents(int enc, int platform=PLATFORM_CURRENT) -> wxFontEncodingArray"""
return _gdi.EncodingConverter_GetPlatformEquivalents(*args, **kwargs)
def EncodingConverter_GetAllEquivalents(*args, **kwargs):
- """EncodingConverter_GetAllEquivalents(wxFontEncoding enc) -> wxFontEncodingArray"""
+ """EncodingConverter_GetAllEquivalents(int enc) -> wxFontEncodingArray"""
return _gdi.EncodingConverter_GetAllEquivalents(*args, **kwargs)
def EncodingConverter_CanConvert(*args, **kwargs):
- """EncodingConverter_CanConvert(wxFontEncoding encIn, wxFontEncoding encOut) -> bool"""
+ """EncodingConverter_CanConvert(int encIn, int encOut) -> bool"""
return _gdi.EncodingConverter_CanConvert(*args, **kwargs)
#----------------------------------------------------------------------------
return _gdi.DC_DrawBitmap(*args, **kwargs)
def DrawTextXY(*args, **kwargs):
- """DrawTextXY(wxString text, int x, int y)"""
+ """DrawTextXY(String text, int x, int y)"""
return _gdi.DC_DrawTextXY(*args, **kwargs)
def DrawText(*args, **kwargs):
- """DrawText(wxString text, Point pt)"""
+ """DrawText(String text, Point pt)"""
return _gdi.DC_DrawText(*args, **kwargs)
def DrawRotatedTextXY(*args, **kwargs):
- """DrawRotatedTextXY(wxString text, int x, int y, double angle)"""
+ """DrawRotatedTextXY(String text, int x, int y, double angle)"""
return _gdi.DC_DrawRotatedTextXY(*args, **kwargs)
def DrawRotatedText(*args, **kwargs):
- """DrawRotatedText(wxString text, Point pt, double angle)"""
+ """DrawRotatedText(String text, Point pt, double angle)"""
return _gdi.DC_DrawRotatedText(*args, **kwargs)
def BlitXY(*args, **kwargs):
def DrawLabel(*args, **kwargs):
"""
- DrawLabel(wxString text, Rect rect, int alignment=wxALIGN_LEFT|wxALIGN_TOP,
+ DrawLabel(String text, Rect rect, int alignment=wxALIGN_LEFT|wxALIGN_TOP,
int indexAccel=-1)
"""
return _gdi.DC_DrawLabel(*args, **kwargs)
def DrawImageLabel(*args, **kwargs):
"""
- DrawImageLabel(wxString text, Bitmap image, Rect rect, int alignment=wxALIGN_LEFT|wxALIGN_TOP,
+ DrawImageLabel(String text, Bitmap image, Rect rect, int alignment=wxALIGN_LEFT|wxALIGN_TOP,
int indexAccel=-1) -> Rect
"""
return _gdi.DC_DrawImageLabel(*args, **kwargs)
return _gdi.DC_Clear(*args, **kwargs)
def StartDoc(*args, **kwargs):
- """StartDoc(wxString message) -> bool"""
+ """StartDoc(String message) -> bool"""
return _gdi.DC_StartDoc(*args, **kwargs)
def EndDoc(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxMetaFile instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString filename=wxPyEmptyString) -> MetaFile"""
+ """__init__(String filename=EmptyString) -> MetaFile"""
newobj = _gdi.new_MetaFile(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _gdi.MetaFile_GetHeight(*args, **kwargs)
def GetFileName(*args, **kwargs):
- """GetFileName() -> wxString"""
+ """GetFileName() -> String"""
return _gdi.MetaFile_GetFileName(*args, **kwargs)
def __nonzero__(self): return self.Ok()
return "<%s.%s; proxy of C++ wxMetaFileDC instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(wxString filename=wxPyEmptyString, int width=0, int height=0,
- wxString description=wxPyEmptyString) -> MetaFileDC
+ __init__(String filename=EmptyString, int width=0, int height=0,
+ String description=EmptyString) -> MetaFileDC
"""
newobj = _gdi.new_MetaFileDC(*args, **kwargs)
self.this = newobj.this
except: pass
def Find(*args, **kwargs):
- """Find(wxString name) -> Colour"""
+ """Find(String name) -> Colour"""
return _gdi.ColourDatabase_Find(*args, **kwargs)
def FindName(*args, **kwargs):
- """FindName(Colour colour) -> wxString"""
+ """FindName(Colour colour) -> String"""
return _gdi.ColourDatabase_FindName(*args, **kwargs)
FindColour = Find
def AddColour(*args, **kwargs):
- """AddColour(wxString name, Colour colour)"""
+ """AddColour(String name, Colour colour)"""
return _gdi.ColourDatabase_AddColour(*args, **kwargs)
def Append(*args, **kwargs):
- """Append(wxString name, int red, int green, int blue)"""
+ """Append(String name, int red, int green, int blue)"""
return _gdi.ColourDatabase_Append(*args, **kwargs)
def FindOrCreateFont(*args, **kwargs):
"""
FindOrCreateFont(int point_size, int family, int style, int weight,
- bool underline=False, wxString facename=wxPyEmptyString,
- wxFontEncoding encoding=FONTENCODING_DEFAULT) -> Font
+ bool underline=False, String facename=EmptyString,
+ int encoding=FONTENCODING_DEFAULT) -> Font
"""
return _gdi.FontList_FindOrCreateFont(*args, **kwargs)
#include "wx/wxPython/wxPython.h"
#include "wx/wxPython/pyclasses.h"
- DECLARE_DEF_STRING(EmptyString);
+ static const wxString wxPyEmptyString(wxEmptyString);
PyObject *wxColour_Get(wxColour *self){
PyObject* rv = PyTuple_New(3);
int red = -1;
static PyObject *_wrap_NativeEncodingInfo_facename_set(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
- wxString arg2 ;
+ wxString *arg2 = (wxString *) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *kwnames[] = {
if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NativeEncodingInfo_facename_set",kwnames,&obj0,&obj1)) goto fail;
if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxNativeEncodingInfo,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
- {
- wxString* sptr = wxString_in_helper(obj1);
- if (sptr == NULL) SWIG_fail;
- arg2 = *sptr;
- delete sptr;
- }
- if (arg1) (arg1)->facename = arg2;
+ if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_wxString,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+ if (arg1) (arg1)->facename = *arg2;
Py_INCREF(Py_None); resultobj = Py_None;
return resultobj;
static PyObject *_wrap_NativeEncodingInfo_facename_get(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxNativeEncodingInfo *arg1 = (wxNativeEncodingInfo *) 0 ;
- wxString result;
+ wxString *result;
PyObject * obj0 = 0 ;
char *kwnames[] = {
(char *) "self", NULL
if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:NativeEncodingInfo_facename_get",kwnames,&obj0)) goto fail;
if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxNativeEncodingInfo,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
- result = ((arg1)->facename);
+ result = (wxString *)& ((arg1)->facename);
{
#if wxUSE_UNICODE
- resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
+ resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
#else
- resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
+ resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
#endif
}
return resultobj;
static PyObject *_wrap_LanguageInfo_CanonicalName_set(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
- wxString arg2 ;
+ wxString *arg2 = (wxString *) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *kwnames[] = {
if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_CanonicalName_set",kwnames,&obj0,&obj1)) goto fail;
if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxLanguageInfo,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
- {
- wxString* sptr = wxString_in_helper(obj1);
- if (sptr == NULL) SWIG_fail;
- arg2 = *sptr;
- delete sptr;
- }
- if (arg1) (arg1)->CanonicalName = arg2;
+ if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_wxString,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+ if (arg1) (arg1)->CanonicalName = *arg2;
Py_INCREF(Py_None); resultobj = Py_None;
return resultobj;
static PyObject *_wrap_LanguageInfo_CanonicalName_get(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
- wxString result;
+ wxString *result;
PyObject * obj0 = 0 ;
char *kwnames[] = {
(char *) "self", NULL
if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_CanonicalName_get",kwnames,&obj0)) goto fail;
if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxLanguageInfo,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
- result = ((arg1)->CanonicalName);
+ result = (wxString *)& ((arg1)->CanonicalName);
{
#if wxUSE_UNICODE
- resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
+ resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
#else
- resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
+ resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
#endif
}
return resultobj;
static PyObject *_wrap_LanguageInfo_Description_set(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
- wxString arg2 ;
+ wxString *arg2 = (wxString *) 0 ;
PyObject * obj0 = 0 ;
PyObject * obj1 = 0 ;
char *kwnames[] = {
if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LanguageInfo_Description_set",kwnames,&obj0,&obj1)) goto fail;
if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxLanguageInfo,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
- {
- wxString* sptr = wxString_in_helper(obj1);
- if (sptr == NULL) SWIG_fail;
- arg2 = *sptr;
- delete sptr;
- }
- if (arg1) (arg1)->Description = arg2;
+ if ((SWIG_ConvertPtr(obj1,(void **) &arg2, SWIGTYPE_p_wxString,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
+ if (arg1) (arg1)->Description = *arg2;
Py_INCREF(Py_None); resultobj = Py_None;
return resultobj;
static PyObject *_wrap_LanguageInfo_Description_get(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxLanguageInfo *arg1 = (wxLanguageInfo *) 0 ;
- wxString result;
+ wxString *result;
PyObject * obj0 = 0 ;
char *kwnames[] = {
(char *) "self", NULL
if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:LanguageInfo_Description_get",kwnames,&obj0)) goto fail;
if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxLanguageInfo,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
- result = ((arg1)->Description);
+ result = (wxString *)& ((arg1)->Description);
{
#if wxUSE_UNICODE
- resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
+ resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
#else
- resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
+ resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
#endif
}
return resultobj;
return _grid.GridCellRenderer__setOORInfo(*args, **kwargs)
def SetParameters(*args, **kwargs):
- """SetParameters(wxString params)"""
+ """SetParameters(String params)"""
return _grid.GridCellRenderer_SetParameters(*args, **kwargs)
def IncRef(*args, **kwargs):
def Draw(*args, **kwargs):
"""
- Draw(Grid grid, GridCellAttr attr, wxDC dc, Rect rect, int row,
+ Draw(Grid grid, GridCellAttr attr, DC dc, Rect rect, int row,
int col, bool isSelected)
"""
return _grid.GridCellRenderer_Draw(*args, **kwargs)
def GetBestSize(*args, **kwargs):
- """GetBestSize(Grid grid, GridCellAttr attr, wxDC dc, int row, int col) -> Size"""
+ """GetBestSize(Grid grid, GridCellAttr attr, DC dc, int row, int col) -> Size"""
return _grid.GridCellRenderer_GetBestSize(*args, **kwargs)
def Clone(*args, **kwargs):
self.__class__ = GridCellRenderer
_grid.GridCellRenderer_swigregister(GridCellRendererPtr)
cvar = _grid.cvar
+DateTimeFormatStr = cvar.DateTimeFormatStr
GridNoCellCoords = cvar.GridNoCellCoords
GridNoCellRect = cvar.GridNoCellRect
return _grid.PyGridCellRenderer__setCallbackInfo(*args, **kwargs)
def base_SetParameters(*args, **kwargs):
- """base_SetParameters(wxString params)"""
+ """base_SetParameters(String params)"""
return _grid.PyGridCellRenderer_base_SetParameters(*args, **kwargs)
def __repr__(self):
return "<%s.%s; proxy of C++ wxGridCellDateTimeRenderer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString outformat=wxPyDateTimeFormatStr, wxString informat=wxPyDateTimeFormatStr) -> GridCellDateTimeRenderer"""
+ """__init__(String outformat=DateTimeFormatStr, String informat=DateTimeFormatStr) -> GridCellDateTimeRenderer"""
newobj = _grid.new_GridCellDateTimeRenderer(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
def __repr__(self):
return "<%s.%s; proxy of C++ wxGridCellEnumRenderer instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString choices=wxPyEmptyString) -> GridCellEnumRenderer"""
+ """__init__(String choices=EmptyString) -> GridCellEnumRenderer"""
newobj = _grid.new_GridCellEnumRenderer(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _grid.GridCellEditor_SetCellAttr(*args, **kwargs)
def SetParameters(*args, **kwargs):
- """SetParameters(wxString params)"""
+ """SetParameters(String params)"""
return _grid.GridCellEditor_SetParameters(*args, **kwargs)
def IncRef(*args, **kwargs):
return _grid.PyGridCellEditor_base_Destroy(*args, **kwargs)
def base_SetParameters(*args, **kwargs):
- """base_SetParameters(wxString params)"""
+ """base_SetParameters(String params)"""
return _grid.PyGridCellEditor_base_SetParameters(*args, **kwargs)
self._setOORInfo(self)
def GetValue(*args, **kwargs):
- """GetValue() -> wxString"""
+ """GetValue() -> String"""
return _grid.GridCellTextEditor_GetValue(*args, **kwargs)
self._setOORInfo(self)
def GetValue(*args, **kwargs):
- """GetValue() -> wxString"""
+ """GetValue() -> String"""
return _grid.GridCellNumberEditor_GetValue(*args, **kwargs)
self._setOORInfo(self)
def GetValue(*args, **kwargs):
- """GetValue() -> wxString"""
+ """GetValue() -> String"""
return _grid.GridCellFloatEditor_GetValue(*args, **kwargs)
self._setOORInfo(self)
def GetValue(*args, **kwargs):
- """GetValue() -> wxString"""
+ """GetValue() -> String"""
return _grid.GridCellBoolEditor_GetValue(*args, **kwargs)
def __repr__(self):
return "<%s.%s; proxy of C++ wxGridCellChoiceEditor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(int choices=0, wxString choices_array=None, bool allowOthers=False) -> GridCellChoiceEditor"""
+ """__init__(int choices=0, String choices_array=None, bool allowOthers=False) -> GridCellChoiceEditor"""
newobj = _grid.new_GridCellChoiceEditor(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
self._setOORInfo(self)
def GetValue(*args, **kwargs):
- """GetValue() -> wxString"""
+ """GetValue() -> String"""
return _grid.GridCellChoiceEditor_GetValue(*args, **kwargs)
def __repr__(self):
return "<%s.%s; proxy of C++ wxGridCellEnumEditor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString choices=wxPyEmptyString) -> GridCellEnumEditor"""
+ """__init__(String choices=EmptyString) -> GridCellEnumEditor"""
newobj = _grid.new_GridCellEnumEditor(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
self._setOORInfo(self)
def GetValue(*args, **kwargs):
- """GetValue() -> wxString"""
+ """GetValue() -> String"""
return _grid.GridCellEnumEditor_GetValue(*args, **kwargs)
self._setOORInfo(self)
def GetValue(*args, **kwargs):
- """GetValue() -> wxString"""
+ """GetValue() -> String"""
return _grid.GridCellAutoWrapStringEditor_GetValue(*args, **kwargs)
return _grid.GridCellAttr_DecRef(*args, **kwargs)
def SetTextColour(*args, **kwargs):
- """SetTextColour(wxColour colText)"""
+ """SetTextColour(Colour colText)"""
return _grid.GridCellAttr_SetTextColour(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
- """SetBackgroundColour(wxColour colBack)"""
+ """SetBackgroundColour(Colour colBack)"""
return _grid.GridCellAttr_SetBackgroundColour(*args, **kwargs)
def SetFont(*args, **kwargs):
- """SetFont(wxFont font)"""
+ """SetFont(Font font)"""
return _grid.GridCellAttr_SetFont(*args, **kwargs)
def SetAlignment(*args, **kwargs):
return _grid.GridCellAttr_SetEditor(*args, **kwargs)
def SetKind(*args, **kwargs):
- """SetKind(wxGridCellAttr::wxAttrKind kind)"""
+ """SetKind(int kind)"""
return _grid.GridCellAttr_SetKind(*args, **kwargs)
def HasTextColour(*args, **kwargs):
return _grid.GridCellAttr_HasOverflowMode(*args, **kwargs)
def GetTextColour(*args, **kwargs):
- """GetTextColour() -> wxColour"""
+ """GetTextColour() -> Colour"""
return _grid.GridCellAttr_GetTextColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
- """GetBackgroundColour() -> wxColour"""
+ """GetBackgroundColour() -> Colour"""
return _grid.GridCellAttr_GetBackgroundColour(*args, **kwargs)
def GetFont(*args, **kwargs):
- """GetFont() -> wxFont"""
+ """GetFont() -> Font"""
return _grid.GridCellAttr_GetFont(*args, **kwargs)
def GetAlignment(*args, **kwargs):
return _grid.GridCellAttrProvider__setOORInfo(*args, **kwargs)
def GetAttr(*args, **kwargs):
- """GetAttr(int row, int col, wxGridCellAttr::wxAttrKind kind) -> GridCellAttr"""
+ """GetAttr(int row, int col, int kind) -> GridCellAttr"""
return _grid.GridCellAttrProvider_GetAttr(*args, **kwargs)
def SetAttr(*args, **kwargs):
return _grid.PyGridCellAttrProvider__setCallbackInfo(*args, **kwargs)
def base_GetAttr(*args, **kwargs):
- """base_GetAttr(int row, int col, wxGridCellAttr::wxAttrKind kind) -> GridCellAttr"""
+ """base_GetAttr(int row, int col, int kind) -> GridCellAttr"""
return _grid.PyGridCellAttrProvider_base_GetAttr(*args, **kwargs)
def base_SetAttr(*args, **kwargs):
return _grid.GridTableBase_IsEmptyCell(*args, **kwargs)
def GetValue(*args, **kwargs):
- """GetValue(int row, int col) -> wxString"""
+ """GetValue(int row, int col) -> String"""
return _grid.GridTableBase_GetValue(*args, **kwargs)
def SetValue(*args, **kwargs):
- """SetValue(int row, int col, wxString value)"""
+ """SetValue(int row, int col, String value)"""
return _grid.GridTableBase_SetValue(*args, **kwargs)
def GetTypeName(*args, **kwargs):
- """GetTypeName(int row, int col) -> wxString"""
+ """GetTypeName(int row, int col) -> String"""
return _grid.GridTableBase_GetTypeName(*args, **kwargs)
def CanGetValueAs(*args, **kwargs):
- """CanGetValueAs(int row, int col, wxString typeName) -> bool"""
+ """CanGetValueAs(int row, int col, String typeName) -> bool"""
return _grid.GridTableBase_CanGetValueAs(*args, **kwargs)
def CanSetValueAs(*args, **kwargs):
- """CanSetValueAs(int row, int col, wxString typeName) -> bool"""
+ """CanSetValueAs(int row, int col, String typeName) -> bool"""
return _grid.GridTableBase_CanSetValueAs(*args, **kwargs)
def GetValueAsLong(*args, **kwargs):
return _grid.GridTableBase_DeleteCols(*args, **kwargs)
def GetRowLabelValue(*args, **kwargs):
- """GetRowLabelValue(int row) -> wxString"""
+ """GetRowLabelValue(int row) -> String"""
return _grid.GridTableBase_GetRowLabelValue(*args, **kwargs)
def GetColLabelValue(*args, **kwargs):
- """GetColLabelValue(int col) -> wxString"""
+ """GetColLabelValue(int col) -> String"""
return _grid.GridTableBase_GetColLabelValue(*args, **kwargs)
def SetRowLabelValue(*args, **kwargs):
- """SetRowLabelValue(int row, wxString value)"""
+ """SetRowLabelValue(int row, String value)"""
return _grid.GridTableBase_SetRowLabelValue(*args, **kwargs)
def SetColLabelValue(*args, **kwargs):
- """SetColLabelValue(int col, wxString value)"""
+ """SetColLabelValue(int col, String value)"""
return _grid.GridTableBase_SetColLabelValue(*args, **kwargs)
def CanHaveAttributes(*args, **kwargs):
return _grid.GridTableBase_CanHaveAttributes(*args, **kwargs)
def GetAttr(*args, **kwargs):
- """GetAttr(int row, int col, wxGridCellAttr::wxAttrKind kind) -> GridCellAttr"""
+ """GetAttr(int row, int col, int kind) -> GridCellAttr"""
return _grid.GridTableBase_GetAttr(*args, **kwargs)
def SetAttr(*args, **kwargs):
return _grid.PyGridTableBase_Destroy(*args, **kwargs)
def base_GetTypeName(*args, **kwargs):
- """base_GetTypeName(int row, int col) -> wxString"""
+ """base_GetTypeName(int row, int col) -> String"""
return _grid.PyGridTableBase_base_GetTypeName(*args, **kwargs)
def base_CanGetValueAs(*args, **kwargs):
- """base_CanGetValueAs(int row, int col, wxString typeName) -> bool"""
+ """base_CanGetValueAs(int row, int col, String typeName) -> bool"""
return _grid.PyGridTableBase_base_CanGetValueAs(*args, **kwargs)
def base_CanSetValueAs(*args, **kwargs):
- """base_CanSetValueAs(int row, int col, wxString typeName) -> bool"""
+ """base_CanSetValueAs(int row, int col, String typeName) -> bool"""
return _grid.PyGridTableBase_base_CanSetValueAs(*args, **kwargs)
def base_Clear(*args, **kwargs):
return _grid.PyGridTableBase_base_DeleteCols(*args, **kwargs)
def base_GetRowLabelValue(*args, **kwargs):
- """base_GetRowLabelValue(int row) -> wxString"""
+ """base_GetRowLabelValue(int row) -> String"""
return _grid.PyGridTableBase_base_GetRowLabelValue(*args, **kwargs)
def base_GetColLabelValue(*args, **kwargs):
- """base_GetColLabelValue(int col) -> wxString"""
+ """base_GetColLabelValue(int col) -> String"""
return _grid.PyGridTableBase_base_GetColLabelValue(*args, **kwargs)
def base_SetRowLabelValue(*args, **kwargs):
- """base_SetRowLabelValue(int row, wxString value)"""
+ """base_SetRowLabelValue(int row, String value)"""
return _grid.PyGridTableBase_base_SetRowLabelValue(*args, **kwargs)
def base_SetColLabelValue(*args, **kwargs):
- """base_SetColLabelValue(int col, wxString value)"""
+ """base_SetColLabelValue(int col, String value)"""
return _grid.PyGridTableBase_base_SetColLabelValue(*args, **kwargs)
def base_CanHaveAttributes(*args, **kwargs):
return _grid.PyGridTableBase_base_CanHaveAttributes(*args, **kwargs)
def base_GetAttr(*args, **kwargs):
- """base_GetAttr(int row, int col, wxGridCellAttr::wxAttrKind kind) -> GridCellAttr"""
+ """base_GetAttr(int row, int col, int kind) -> GridCellAttr"""
return _grid.PyGridTableBase_base_GetAttr(*args, **kwargs)
def base_SetAttr(*args, **kwargs):
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=WANTS_CHARS,
- wxString name=PanelNameStr) -> Grid
+ String name=PanelNameStr) -> Grid
"""
newobj = _grid.new_Grid(*args, **kwargs)
self.this = newobj.this
return _grid.Grid_DeleteCols(*args, **kwargs)
def DrawCellHighlight(*args, **kwargs):
- """DrawCellHighlight(wxDC dc, GridCellAttr attr)"""
+ """DrawCellHighlight(DC dc, GridCellAttr attr)"""
return _grid.Grid_DrawCellHighlight(*args, **kwargs)
def DrawTextRectangle(*args, **kwargs):
"""
- DrawTextRectangle(wxDC dc, wxString ??, Rect ??, int horizontalAlignment=LEFT,
+ DrawTextRectangle(DC dc, String ??, Rect ??, int horizontalAlignment=LEFT,
int verticalAlignment=TOP, int textOrientation=HORIZONTAL)
"""
return _grid.Grid_DrawTextRectangle(*args, **kwargs)
return _grid.Grid_GetColLabelSize(*args, **kwargs)
def GetLabelBackgroundColour(*args, **kwargs):
- """GetLabelBackgroundColour() -> wxColour"""
+ """GetLabelBackgroundColour() -> Colour"""
return _grid.Grid_GetLabelBackgroundColour(*args, **kwargs)
def GetLabelTextColour(*args, **kwargs):
- """GetLabelTextColour() -> wxColour"""
+ """GetLabelTextColour() -> Colour"""
return _grid.Grid_GetLabelTextColour(*args, **kwargs)
def GetLabelFont(*args, **kwargs):
- """GetLabelFont() -> wxFont"""
+ """GetLabelFont() -> Font"""
return _grid.Grid_GetLabelFont(*args, **kwargs)
def GetRowLabelAlignment(*args, **kwargs):
return _grid.Grid_GetColLabelTextOrientation(*args, **kwargs)
def GetRowLabelValue(*args, **kwargs):
- """GetRowLabelValue(int row) -> wxString"""
+ """GetRowLabelValue(int row) -> String"""
return _grid.Grid_GetRowLabelValue(*args, **kwargs)
def GetColLabelValue(*args, **kwargs):
- """GetColLabelValue(int col) -> wxString"""
+ """GetColLabelValue(int col) -> String"""
return _grid.Grid_GetColLabelValue(*args, **kwargs)
def GetGridLineColour(*args, **kwargs):
- """GetGridLineColour() -> wxColour"""
+ """GetGridLineColour() -> Colour"""
return _grid.Grid_GetGridLineColour(*args, **kwargs)
def GetCellHighlightColour(*args, **kwargs):
- """GetCellHighlightColour() -> wxColour"""
+ """GetCellHighlightColour() -> Colour"""
return _grid.Grid_GetCellHighlightColour(*args, **kwargs)
def GetCellHighlightPenWidth(*args, **kwargs):
return _grid.Grid_SetColLabelSize(*args, **kwargs)
def SetLabelBackgroundColour(*args, **kwargs):
- """SetLabelBackgroundColour(wxColour ??)"""
+ """SetLabelBackgroundColour(Colour ??)"""
return _grid.Grid_SetLabelBackgroundColour(*args, **kwargs)
def SetLabelTextColour(*args, **kwargs):
- """SetLabelTextColour(wxColour ??)"""
+ """SetLabelTextColour(Colour ??)"""
return _grid.Grid_SetLabelTextColour(*args, **kwargs)
def SetLabelFont(*args, **kwargs):
- """SetLabelFont(wxFont ??)"""
+ """SetLabelFont(Font ??)"""
return _grid.Grid_SetLabelFont(*args, **kwargs)
def SetRowLabelAlignment(*args, **kwargs):
return _grid.Grid_SetColLabelTextOrientation(*args, **kwargs)
def SetRowLabelValue(*args, **kwargs):
- """SetRowLabelValue(int row, wxString ??)"""
+ """SetRowLabelValue(int row, String ??)"""
return _grid.Grid_SetRowLabelValue(*args, **kwargs)
def SetColLabelValue(*args, **kwargs):
- """SetColLabelValue(int col, wxString ??)"""
+ """SetColLabelValue(int col, String ??)"""
return _grid.Grid_SetColLabelValue(*args, **kwargs)
def SetGridLineColour(*args, **kwargs):
- """SetGridLineColour(wxColour ??)"""
+ """SetGridLineColour(Colour ??)"""
return _grid.Grid_SetGridLineColour(*args, **kwargs)
def SetCellHighlightColour(*args, **kwargs):
- """SetCellHighlightColour(wxColour ??)"""
+ """SetCellHighlightColour(Colour ??)"""
return _grid.Grid_SetCellHighlightColour(*args, **kwargs)
def SetCellHighlightPenWidth(*args, **kwargs):
return _grid.Grid_SetColFormatFloat(*args, **kwargs)
def SetColFormatCustom(*args, **kwargs):
- """SetColFormatCustom(int col, wxString typeName)"""
+ """SetColFormatCustom(int col, String typeName)"""
return _grid.Grid_SetColFormatCustom(*args, **kwargs)
def EnableGridLines(*args, **kwargs):
return _grid.Grid_GetColSize(*args, **kwargs)
def GetDefaultCellBackgroundColour(*args, **kwargs):
- """GetDefaultCellBackgroundColour() -> wxColour"""
+ """GetDefaultCellBackgroundColour() -> Colour"""
return _grid.Grid_GetDefaultCellBackgroundColour(*args, **kwargs)
def GetCellBackgroundColour(*args, **kwargs):
- """GetCellBackgroundColour(int row, int col) -> wxColour"""
+ """GetCellBackgroundColour(int row, int col) -> Colour"""
return _grid.Grid_GetCellBackgroundColour(*args, **kwargs)
def GetDefaultCellTextColour(*args, **kwargs):
- """GetDefaultCellTextColour() -> wxColour"""
+ """GetDefaultCellTextColour() -> Colour"""
return _grid.Grid_GetDefaultCellTextColour(*args, **kwargs)
def GetCellTextColour(*args, **kwargs):
- """GetCellTextColour(int row, int col) -> wxColour"""
+ """GetCellTextColour(int row, int col) -> Colour"""
return _grid.Grid_GetCellTextColour(*args, **kwargs)
def GetDefaultCellFont(*args, **kwargs):
- """GetDefaultCellFont() -> wxFont"""
+ """GetDefaultCellFont() -> Font"""
return _grid.Grid_GetDefaultCellFont(*args, **kwargs)
def GetCellFont(*args, **kwargs):
- """GetCellFont(int row, int col) -> wxFont"""
+ """GetCellFont(int row, int col) -> Font"""
return _grid.Grid_GetCellFont(*args, **kwargs)
def GetDefaultCellAlignment(*args, **kwargs):
return _grid.Grid_GetRowMinimalAcceptableHeight(*args, **kwargs)
def SetDefaultCellBackgroundColour(*args, **kwargs):
- """SetDefaultCellBackgroundColour(wxColour ??)"""
+ """SetDefaultCellBackgroundColour(Colour ??)"""
return _grid.Grid_SetDefaultCellBackgroundColour(*args, **kwargs)
def SetCellBackgroundColour(*args, **kwargs):
- """SetCellBackgroundColour(int row, int col, wxColour ??)"""
+ """SetCellBackgroundColour(int row, int col, Colour ??)"""
return _grid.Grid_SetCellBackgroundColour(*args, **kwargs)
def SetDefaultCellTextColour(*args, **kwargs):
- """SetDefaultCellTextColour(wxColour ??)"""
+ """SetDefaultCellTextColour(Colour ??)"""
return _grid.Grid_SetDefaultCellTextColour(*args, **kwargs)
def SetCellTextColour(*args, **kwargs):
- """SetCellTextColour(int row, int col, wxColour ??)"""
+ """SetCellTextColour(int row, int col, Colour ??)"""
return _grid.Grid_SetCellTextColour(*args, **kwargs)
def SetDefaultCellFont(*args, **kwargs):
- """SetDefaultCellFont(wxFont ??)"""
+ """SetDefaultCellFont(Font ??)"""
return _grid.Grid_SetDefaultCellFont(*args, **kwargs)
def SetCellFont(*args, **kwargs):
- """SetCellFont(int row, int col, wxFont ??)"""
+ """SetCellFont(int row, int col, Font ??)"""
return _grid.Grid_SetCellFont(*args, **kwargs)
def SetDefaultCellAlignment(*args, **kwargs):
return _grid.Grid_GetCellEditor(*args, **kwargs)
def GetCellValue(*args, **kwargs):
- """GetCellValue(int row, int col) -> wxString"""
+ """GetCellValue(int row, int col) -> String"""
return _grid.Grid_GetCellValue(*args, **kwargs)
def SetCellValue(*args, **kwargs):
- """SetCellValue(int row, int col, wxString s)"""
+ """SetCellValue(int row, int col, String s)"""
return _grid.Grid_SetCellValue(*args, **kwargs)
def IsReadOnly(*args, **kwargs):
return _grid.Grid_BlockToDeviceRect(*args, **kwargs)
def GetSelectionBackground(*args, **kwargs):
- """GetSelectionBackground() -> wxColour"""
+ """GetSelectionBackground() -> Colour"""
return _grid.Grid_GetSelectionBackground(*args, **kwargs)
def GetSelectionForeground(*args, **kwargs):
- """GetSelectionForeground() -> wxColour"""
+ """GetSelectionForeground() -> Colour"""
return _grid.Grid_GetSelectionForeground(*args, **kwargs)
def SetSelectionBackground(*args, **kwargs):
- """SetSelectionBackground(wxColour c)"""
+ """SetSelectionBackground(Colour c)"""
return _grid.Grid_SetSelectionBackground(*args, **kwargs)
def SetSelectionForeground(*args, **kwargs):
- """SetSelectionForeground(wxColour c)"""
+ """SetSelectionForeground(Colour c)"""
return _grid.Grid_SetSelectionForeground(*args, **kwargs)
def RegisterDataType(*args, **kwargs):
- """RegisterDataType(wxString typeName, GridCellRenderer renderer, GridCellEditor editor)"""
+ """RegisterDataType(String typeName, GridCellRenderer renderer, GridCellEditor editor)"""
return _grid.Grid_RegisterDataType(*args, **kwargs)
def GetDefaultEditorForCell(*args, **kwargs):
return _grid.Grid_GetDefaultRendererForCell(*args, **kwargs)
def GetDefaultEditorForType(*args, **kwargs):
- """GetDefaultEditorForType(wxString typeName) -> GridCellEditor"""
+ """GetDefaultEditorForType(String typeName) -> GridCellEditor"""
return _grid.Grid_GetDefaultEditorForType(*args, **kwargs)
def GetDefaultRendererForType(*args, **kwargs):
- """GetDefaultRendererForType(wxString typeName) -> GridCellRenderer"""
+ """GetDefaultRendererForType(String typeName) -> GridCellRenderer"""
return _grid.Grid_GetDefaultRendererForType(*args, **kwargs)
def SetMargins(*args, **kwargs):
#include <wx/grid.h>
#include <wx/generic/gridctrl.h>
- DECLARE_DEF_STRING(PanelNameStr);
- DECLARE_DEF_STRING2(DateTimeFormatStr, wxT("%c"));
- static const wxString wxPyEmptyString(wxT(""));
+ static const wxString wxPyEmptyString(wxEmptyString);
+ static const wxString wxPyPanelNameStr(wxPanelNameStr);
+ static const wxString wxPyDateTimeFormatStr(wxT(wxT("%c")));
#define wxPyMake_TEMPLATE(TYPE) \
#ifdef __cplusplus
extern "C" {
#endif
+static int _wrap_DateTimeFormatStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable DateTimeFormatStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_DateTimeFormatStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyDateTimeFormatStr)->c_str(), (&wxPyDateTimeFormatStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyDateTimeFormatStr)->c_str(), (&wxPyDateTimeFormatStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static int _wrap_GridNoCellCoords_set(PyObject *_val) {
PyErr_SetString(PyExc_TypeError,"Variable GridNoCellCoords is read-only.");
return 1;
SWIG_InstallConstants(d,swig_const_table);
PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
+ SWIG_addvarlink(SWIG_globals,(char*)"DateTimeFormatStr",_wrap_DateTimeFormatStr_get, _wrap_DateTimeFormatStr_set);
SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellCoords",_wrap_GridNoCellCoords_get, _wrap_GridNoCellCoords_set);
SWIG_addvarlink(SWIG_globals,(char*)"GridNoCellRect",_wrap_GridNoCellRect_get, _wrap_GridNoCellRect_set);
PyDict_SetItemString(d, "wxEVT_GRID_CELL_LEFT_CLICK", PyInt_FromLong(wxEVT_GRID_CELL_LEFT_CLICK));
def __repr__(self):
return "<%s.%s; proxy of C++ wxHtmlLinkInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString href, wxString target=wxPyEmptyString) -> HtmlLinkInfo"""
+ """__init__(String href, String target=EmptyString) -> HtmlLinkInfo"""
newobj = _html.new_HtmlLinkInfo(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetHref(*args, **kwargs):
- """GetHref() -> wxString"""
+ """GetHref() -> String"""
return _html.HtmlLinkInfo_GetHref(*args, **kwargs)
def GetTarget(*args, **kwargs):
- """GetTarget() -> wxString"""
+ """GetTarget() -> String"""
return _html.HtmlLinkInfo_GetTarget(*args, **kwargs)
def GetEvent(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = HtmlLinkInfo
_html.HtmlLinkInfo_swigregister(HtmlLinkInfoPtr)
+cvar = _html.cvar
+HtmlWindowNameStr = cvar.HtmlWindowNameStr
+HtmlPrintoutTitleStr = cvar.HtmlPrintoutTitleStr
+HtmlPrintingTitleStr = cvar.HtmlPrintingTitleStr
class HtmlTag(core.Object):
def __init__(self): raise RuntimeError, "No constructor defined"
def __repr__(self):
return "<%s.%s; proxy of C++ wxHtmlTag instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def GetName(*args, **kwargs):
- """GetName() -> wxString"""
+ """GetName() -> String"""
return _html.HtmlTag_GetName(*args, **kwargs)
def HasParam(*args, **kwargs):
- """HasParam(wxString par) -> bool"""
+ """HasParam(String par) -> bool"""
return _html.HtmlTag_HasParam(*args, **kwargs)
def GetParam(*args, **kwargs):
- """GetParam(wxString par, int with_commas=False) -> wxString"""
+ """GetParam(String par, int with_commas=False) -> String"""
return _html.HtmlTag_GetParam(*args, **kwargs)
def GetAllParams(*args, **kwargs):
- """GetAllParams() -> wxString"""
+ """GetAllParams() -> String"""
return _html.HtmlTag_GetAllParams(*args, **kwargs)
def HasEnding(*args, **kwargs):
return _html.HtmlParser_GetFS(*args, **kwargs)
def Parse(*args, **kwargs):
- """Parse(wxString source) -> Object"""
+ """Parse(String source) -> Object"""
return _html.HtmlParser_Parse(*args, **kwargs)
def InitParser(*args, **kwargs):
- """InitParser(wxString source)"""
+ """InitParser(String source)"""
return _html.HtmlParser_InitParser(*args, **kwargs)
def DoneParser(*args, **kwargs):
return _html.HtmlParser_StopParsing(*args, **kwargs)
def AddTagHandler(*args, **kwargs):
- """AddTagHandler(wxHtmlTagHandler handler)"""
+ """AddTagHandler(HtmlTagHandler handler)"""
return _html.HtmlParser_AddTagHandler(*args, **kwargs)
def GetSource(*args, **kwargs):
- """GetSource() -> wxString"""
+ """GetSource() -> String"""
return _html.HtmlParser_GetSource(*args, **kwargs)
def PushTagHandler(*args, **kwargs):
- """PushTagHandler(wxHtmlTagHandler handler, wxString tags)"""
+ """PushTagHandler(HtmlTagHandler handler, String tags)"""
return _html.HtmlParser_PushTagHandler(*args, **kwargs)
def PopTagHandler(*args, **kwargs):
self.thisown = 1
del newobj.thisown
def SetDC(*args, **kwargs):
- """SetDC(wxDC dc)"""
+ """SetDC(DC dc)"""
return _html.HtmlWinParser_SetDC(*args, **kwargs)
def GetDC(*args, **kwargs):
- """GetDC() -> wxDC"""
+ """GetDC() -> DC"""
return _html.HtmlWinParser_GetDC(*args, **kwargs)
def GetCharHeight(*args, **kwargs):
return _html.HtmlWinParser_GetWindow(*args, **kwargs)
def SetFonts(*args, **kwargs):
- """SetFonts(wxString normal_face, wxString fixed_face, PyObject sizes=None)"""
+ """SetFonts(String normal_face, String fixed_face, PyObject sizes=None)"""
return _html.HtmlWinParser_SetFonts(*args, **kwargs)
def GetContainer(*args, **kwargs):
return _html.HtmlWinParser_SetAlign(*args, **kwargs)
def GetLinkColor(*args, **kwargs):
- """GetLinkColor() -> wxColour"""
+ """GetLinkColor() -> Colour"""
return _html.HtmlWinParser_GetLinkColor(*args, **kwargs)
def SetLinkColor(*args, **kwargs):
- """SetLinkColor(wxColour clr)"""
+ """SetLinkColor(Colour clr)"""
return _html.HtmlWinParser_SetLinkColor(*args, **kwargs)
def GetActualColor(*args, **kwargs):
- """GetActualColor() -> wxColour"""
+ """GetActualColor() -> Colour"""
return _html.HtmlWinParser_GetActualColor(*args, **kwargs)
def SetActualColor(*args, **kwargs):
- """SetActualColor(wxColour clr)"""
+ """SetActualColor(Colour clr)"""
return _html.HtmlWinParser_SetActualColor(*args, **kwargs)
def SetLink(*args, **kwargs):
- """SetLink(wxString link)"""
+ """SetLink(String link)"""
return _html.HtmlWinParser_SetLink(*args, **kwargs)
def CreateCurrentFont(*args, **kwargs):
- """CreateCurrentFont() -> wxFont"""
+ """CreateCurrentFont() -> Font"""
return _html.HtmlWinParser_CreateCurrentFont(*args, **kwargs)
def GetLink(*args, **kwargs):
except: pass
def SetSelectionState(*args, **kwargs):
- """SetSelectionState(wxHtmlSelectionState s)"""
+ """SetSelectionState(int s)"""
return _html.HtmlRenderingState_SetSelectionState(*args, **kwargs)
def GetSelectionState(*args, **kwargs):
- """GetSelectionState() -> wxHtmlSelectionState"""
+ """GetSelectionState() -> int"""
return _html.HtmlRenderingState_GetSelectionState(*args, **kwargs)
def SetFgColour(*args, **kwargs):
- """SetFgColour(wxColour c)"""
+ """SetFgColour(Colour c)"""
return _html.HtmlRenderingState_SetFgColour(*args, **kwargs)
def GetFgColour(*args, **kwargs):
- """GetFgColour() -> wxColour"""
+ """GetFgColour() -> Colour"""
return _html.HtmlRenderingState_GetFgColour(*args, **kwargs)
def SetBgColour(*args, **kwargs):
- """SetBgColour(wxColour c)"""
+ """SetBgColour(Colour c)"""
return _html.HtmlRenderingState_SetBgColour(*args, **kwargs)
def GetBgColour(*args, **kwargs):
- """GetBgColour() -> wxColour"""
+ """GetBgColour() -> Colour"""
return _html.HtmlRenderingState_GetBgColour(*args, **kwargs)
def __repr__(self):
return "<%s.%s; proxy of C++ wxHtmlRenderingStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def GetSelectedTextColour(*args, **kwargs):
- """GetSelectedTextColour(wxColour clr) -> wxColour"""
+ """GetSelectedTextColour(Colour clr) -> Colour"""
return _html.HtmlRenderingStyle_GetSelectedTextColour(*args, **kwargs)
def GetSelectedTextBgColour(*args, **kwargs):
- """GetSelectedTextBgColour(wxColour clr) -> wxColour"""
+ """GetSelectedTextBgColour(Colour clr) -> Colour"""
return _html.HtmlRenderingStyle_GetSelectedTextBgColour(*args, **kwargs)
def __repr__(self):
return "<%s.%s; proxy of C++ wxDefaultHtmlRenderingStyle instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def GetSelectedTextColour(*args, **kwargs):
- """GetSelectedTextColour(wxColour clr) -> wxColour"""
+ """GetSelectedTextColour(Colour clr) -> Colour"""
return _html.DefaultHtmlRenderingStyle_GetSelectedTextColour(*args, **kwargs)
def GetSelectedTextBgColour(*args, **kwargs):
- """GetSelectedTextBgColour(wxColour clr) -> wxColour"""
+ """GetSelectedTextBgColour(Colour clr) -> Colour"""
return _html.DefaultHtmlRenderingStyle_GetSelectedTextBgColour(*args, **kwargs)
return _html.HtmlCell_GetFirstChild(*args, **kwargs)
def GetCursor(*args, **kwargs):
- """GetCursor() -> wxCursor"""
+ """GetCursor() -> Cursor"""
return _html.HtmlCell_GetCursor(*args, **kwargs)
def IsFormattingCell(*args, **kwargs):
return _html.HtmlCell_Layout(*args, **kwargs)
def Draw(*args, **kwargs):
- """Draw(wxDC dc, int x, int y, int view_y1, int view_y2, HtmlRenderingInfo info)"""
+ """Draw(DC dc, int x, int y, int view_y1, int view_y2, HtmlRenderingInfo info)"""
return _html.HtmlCell_Draw(*args, **kwargs)
def DrawInvisible(*args, **kwargs):
- """DrawInvisible(wxDC dc, int x, int y, HtmlRenderingInfo info)"""
+ """DrawInvisible(DC dc, int x, int y, HtmlRenderingInfo info)"""
return _html.HtmlCell_DrawInvisible(*args, **kwargs)
def Find(*args, **kwargs):
return _html.HtmlCell_IsBefore(*args, **kwargs)
def ConvertToText(*args, **kwargs):
- """ConvertToText(HtmlSelection sel) -> wxString"""
+ """ConvertToText(HtmlSelection sel) -> String"""
return _html.HtmlCell_ConvertToText(*args, **kwargs)
def __repr__(self):
return "<%s.%s; proxy of C++ wxHtmlWordCell instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString word, wxDC dc) -> HtmlWordCell"""
+ """__init__(String word, DC dc) -> HtmlWordCell"""
newobj = _html.new_HtmlWordCell(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _html.HtmlContainerCell_SetMinHeight(*args, **kwargs)
def SetBackgroundColour(*args, **kwargs):
- """SetBackgroundColour(wxColour clr)"""
+ """SetBackgroundColour(Colour clr)"""
return _html.HtmlContainerCell_SetBackgroundColour(*args, **kwargs)
def GetBackgroundColour(*args, **kwargs):
- """GetBackgroundColour() -> wxColour"""
+ """GetBackgroundColour() -> Colour"""
return _html.HtmlContainerCell_GetBackgroundColour(*args, **kwargs)
def SetBorder(*args, **kwargs):
- """SetBorder(wxColour clr1, wxColour clr2)"""
+ """SetBorder(Colour clr1, Colour clr2)"""
return _html.HtmlContainerCell_SetBorder(*args, **kwargs)
def GetFirstChild(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxHtmlColourCell instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxColour clr, int flags=HTML_CLR_FOREGROUND) -> HtmlColourCell"""
+ """__init__(Colour clr, int flags=HTML_CLR_FOREGROUND) -> HtmlColourCell"""
newobj = _html.new_HtmlColourCell(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
def __repr__(self):
return "<%s.%s; proxy of C++ wxHtmlFontCell instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxFont font) -> HtmlFontCell"""
+ """__init__(Font font) -> HtmlFontCell"""
newobj = _html.new_HtmlFontCell(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
"""
__init__(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, int style=HW_DEFAULT_STYLE,
- wxString name=wxPyHtmlWindowNameStr) -> HtmlWindow
+ String name=HtmlWindowNameStr) -> HtmlWindow
"""
newobj = _html.new_HtmlWindow(*args, **kwargs)
self.this = newobj.this
"""
Create(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, int style=HW_SCROLLBAR_AUTO,
- wxString name=wxPyHtmlWindowNameStr) -> bool
+ String name=HtmlWindowNameStr) -> bool
"""
return _html.HtmlWindow_Create(*args, **kwargs)
return _html.HtmlWindow__setCallbackInfo(*args, **kwargs)
def SetPage(*args, **kwargs):
- """SetPage(wxString source) -> bool"""
+ """SetPage(String source) -> bool"""
return _html.HtmlWindow_SetPage(*args, **kwargs)
def LoadPage(*args, **kwargs):
- """LoadPage(wxString location) -> bool"""
+ """LoadPage(String location) -> bool"""
return _html.HtmlWindow_LoadPage(*args, **kwargs)
def LoadFile(*args, **kwargs):
- """LoadFile(wxString filename) -> bool"""
+ """LoadFile(String filename) -> bool"""
return _html.HtmlWindow_LoadFile(*args, **kwargs)
def AppendToPage(*args, **kwargs):
- """AppendToPage(wxString source) -> bool"""
+ """AppendToPage(String source) -> bool"""
return _html.HtmlWindow_AppendToPage(*args, **kwargs)
def GetOpenedPage(*args, **kwargs):
- """GetOpenedPage() -> wxString"""
+ """GetOpenedPage() -> String"""
return _html.HtmlWindow_GetOpenedPage(*args, **kwargs)
def GetOpenedAnchor(*args, **kwargs):
- """GetOpenedAnchor() -> wxString"""
+ """GetOpenedAnchor() -> String"""
return _html.HtmlWindow_GetOpenedAnchor(*args, **kwargs)
def GetOpenedPageTitle(*args, **kwargs):
- """GetOpenedPageTitle() -> wxString"""
+ """GetOpenedPageTitle() -> String"""
return _html.HtmlWindow_GetOpenedPageTitle(*args, **kwargs)
def SetRelatedFrame(*args, **kwargs):
- """SetRelatedFrame(Frame frame, wxString format)"""
+ """SetRelatedFrame(Frame frame, String format)"""
return _html.HtmlWindow_SetRelatedFrame(*args, **kwargs)
def GetRelatedFrame(*args, **kwargs):
return _html.HtmlWindow_SetRelatedStatusBar(*args, **kwargs)
def SetFonts(*args, **kwargs):
- """SetFonts(wxString normal_face, wxString fixed_face, PyObject sizes=None)"""
+ """SetFonts(String normal_face, String fixed_face, PyObject sizes=None)"""
return _html.HtmlWindow_SetFonts(*args, **kwargs)
def SetTitle(*args, **kwargs):
- """SetTitle(wxString title)"""
+ """SetTitle(String title)"""
return _html.HtmlWindow_SetTitle(*args, **kwargs)
def SetBorders(*args, **kwargs):
return _html.HtmlWindow_SetBorders(*args, **kwargs)
def ReadCustomization(*args, **kwargs):
- """ReadCustomization(wxConfigBase cfg, wxString path=wxPyEmptyString)"""
+ """ReadCustomization(ConfigBase cfg, String path=EmptyString)"""
return _html.HtmlWindow_ReadCustomization(*args, **kwargs)
def WriteCustomization(*args, **kwargs):
- """WriteCustomization(wxConfigBase cfg, wxString path=wxPyEmptyString)"""
+ """WriteCustomization(ConfigBase cfg, String path=EmptyString)"""
return _html.HtmlWindow_WriteCustomization(*args, **kwargs)
def HistoryBack(*args, **kwargs):
return _html.HtmlWindow_GetParser(*args, **kwargs)
def ScrollToAnchor(*args, **kwargs):
- """ScrollToAnchor(wxString anchor) -> bool"""
+ """ScrollToAnchor(String anchor) -> bool"""
return _html.HtmlWindow_ScrollToAnchor(*args, **kwargs)
def HasAnchor(*args, **kwargs):
- """HasAnchor(wxString anchor) -> bool"""
+ """HasAnchor(String anchor) -> bool"""
return _html.HtmlWindow_HasAnchor(*args, **kwargs)
def AddFilter(*args, **kwargs):
return _html.HtmlWindow_base_OnLinkClicked(*args, **kwargs)
def base_OnSetTitle(*args, **kwargs):
- """base_OnSetTitle(wxString title)"""
+ """base_OnSetTitle(String title)"""
return _html.HtmlWindow_base_OnSetTitle(*args, **kwargs)
def base_OnCellMouseHover(*args, **kwargs):
except: pass
def SetDC(*args, **kwargs):
- """SetDC(wxDC dc, int maxwidth)"""
+ """SetDC(DC dc, int maxwidth)"""
return _html.HtmlDCRenderer_SetDC(*args, **kwargs)
def SetSize(*args, **kwargs):
return _html.HtmlDCRenderer_SetSize(*args, **kwargs)
def SetHtmlText(*args, **kwargs):
- """SetHtmlText(wxString html, wxString basepath=wxPyEmptyString, bool isdir=True)"""
+ """SetHtmlText(String html, String basepath=EmptyString, bool isdir=True)"""
return _html.HtmlDCRenderer_SetHtmlText(*args, **kwargs)
def SetFonts(*args, **kwargs):
- """SetFonts(wxString normal_face, wxString fixed_face, PyObject sizes=None)"""
+ """SetFonts(String normal_face, String fixed_face, PyObject sizes=None)"""
return _html.HtmlDCRenderer_SetFonts(*args, **kwargs)
def Render(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxHtmlPrintout instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString title=wxPyHtmlPrintoutTitleStr) -> HtmlPrintout"""
+ """__init__(String title=HtmlPrintoutTitleStr) -> HtmlPrintout"""
newobj = _html.new_HtmlPrintout(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def SetHtmlText(*args, **kwargs):
- """SetHtmlText(wxString html, wxString basepath=wxPyEmptyString, bool isdir=True)"""
+ """SetHtmlText(String html, String basepath=EmptyString, bool isdir=True)"""
return _html.HtmlPrintout_SetHtmlText(*args, **kwargs)
def SetHtmlFile(*args, **kwargs):
- """SetHtmlFile(wxString htmlfile)"""
+ """SetHtmlFile(String htmlfile)"""
return _html.HtmlPrintout_SetHtmlFile(*args, **kwargs)
def SetHeader(*args, **kwargs):
- """SetHeader(wxString header, int pg=PAGE_ALL)"""
+ """SetHeader(String header, int pg=PAGE_ALL)"""
return _html.HtmlPrintout_SetHeader(*args, **kwargs)
def SetFooter(*args, **kwargs):
- """SetFooter(wxString footer, int pg=PAGE_ALL)"""
+ """SetFooter(String footer, int pg=PAGE_ALL)"""
return _html.HtmlPrintout_SetFooter(*args, **kwargs)
def SetFonts(*args, **kwargs):
- """SetFonts(wxString normal_face, wxString fixed_face, PyObject sizes=None)"""
+ """SetFonts(String normal_face, String fixed_face, PyObject sizes=None)"""
return _html.HtmlPrintout_SetFonts(*args, **kwargs)
def SetMargins(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxHtmlEasyPrinting instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString name=wxPyHtmlPrintingTitleStr, Window parentWindow=None) -> HtmlEasyPrinting"""
+ """__init__(String name=HtmlPrintingTitleStr, Window parentWindow=None) -> HtmlEasyPrinting"""
newobj = _html.new_HtmlEasyPrinting(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def PreviewFile(*args, **kwargs):
- """PreviewFile(wxString htmlfile)"""
+ """PreviewFile(String htmlfile)"""
return _html.HtmlEasyPrinting_PreviewFile(*args, **kwargs)
def PreviewText(*args, **kwargs):
- """PreviewText(wxString htmltext, wxString basepath=wxPyEmptyString)"""
+ """PreviewText(String htmltext, String basepath=EmptyString)"""
return _html.HtmlEasyPrinting_PreviewText(*args, **kwargs)
def PrintFile(*args, **kwargs):
- """PrintFile(wxString htmlfile)"""
+ """PrintFile(String htmlfile)"""
return _html.HtmlEasyPrinting_PrintFile(*args, **kwargs)
def PrintText(*args, **kwargs):
- """PrintText(wxString htmltext, wxString basepath=wxPyEmptyString)"""
+ """PrintText(String htmltext, String basepath=EmptyString)"""
return _html.HtmlEasyPrinting_PrintText(*args, **kwargs)
def PrinterSetup(*args, **kwargs):
return _html.HtmlEasyPrinting_PageSetup(*args, **kwargs)
def SetHeader(*args, **kwargs):
- """SetHeader(wxString header, int pg=PAGE_ALL)"""
+ """SetHeader(String header, int pg=PAGE_ALL)"""
return _html.HtmlEasyPrinting_SetHeader(*args, **kwargs)
def SetFooter(*args, **kwargs):
- """SetFooter(wxString footer, int pg=PAGE_ALL)"""
+ """SetFooter(String footer, int pg=PAGE_ALL)"""
return _html.HtmlEasyPrinting_SetFooter(*args, **kwargs)
def SetFonts(*args, **kwargs):
- """SetFonts(wxString normal_face, wxString fixed_face, PyObject sizes=None)"""
+ """SetFonts(String normal_face, String fixed_face, PyObject sizes=None)"""
return _html.HtmlEasyPrinting_SetFonts(*args, **kwargs)
def GetPrintData(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxHtmlBookRecord instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """
- __init__(wxString bookfile, wxString basepath, wxString title,
- wxString start) -> HtmlBookRecord
- """
+ """__init__(String bookfile, String basepath, String title, String start) -> HtmlBookRecord"""
newobj = _html.new_HtmlBookRecord(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetBookFile(*args, **kwargs):
- """GetBookFile() -> wxString"""
+ """GetBookFile() -> String"""
return _html.HtmlBookRecord_GetBookFile(*args, **kwargs)
def GetTitle(*args, **kwargs):
- """GetTitle() -> wxString"""
+ """GetTitle() -> String"""
return _html.HtmlBookRecord_GetTitle(*args, **kwargs)
def GetStart(*args, **kwargs):
- """GetStart() -> wxString"""
+ """GetStart() -> String"""
return _html.HtmlBookRecord_GetStart(*args, **kwargs)
def GetBasePath(*args, **kwargs):
- """GetBasePath() -> wxString"""
+ """GetBasePath() -> String"""
return _html.HtmlBookRecord_GetBasePath(*args, **kwargs)
def SetContentsRange(*args, **kwargs):
return _html.HtmlBookRecord_GetContentsEnd(*args, **kwargs)
def SetTitle(*args, **kwargs):
- """SetTitle(wxString title)"""
+ """SetTitle(String title)"""
return _html.HtmlBookRecord_SetTitle(*args, **kwargs)
def SetBasePath(*args, **kwargs):
- """SetBasePath(wxString path)"""
+ """SetBasePath(String path)"""
return _html.HtmlBookRecord_SetBasePath(*args, **kwargs)
def SetStart(*args, **kwargs):
- """SetStart(wxString start)"""
+ """SetStart(String start)"""
return _html.HtmlBookRecord_SetStart(*args, **kwargs)
def GetFullPath(*args, **kwargs):
- """GetFullPath(wxString page) -> wxString"""
+ """GetFullPath(String page) -> String"""
return _html.HtmlBookRecord_GetFullPath(*args, **kwargs)
return _html.HtmlContentsItem_GetID(*args, **kwargs)
def GetName(*args, **kwargs):
- """GetName() -> wxString"""
+ """GetName() -> String"""
return _html.HtmlContentsItem_GetName(*args, **kwargs)
def GetPage(*args, **kwargs):
- """GetPage() -> wxString"""
+ """GetPage() -> String"""
return _html.HtmlContentsItem_GetPage(*args, **kwargs)
def GetBook(*args, **kwargs):
return _html.HtmlSearchStatus_GetMaxIndex(*args, **kwargs)
def GetName(*args, **kwargs):
- """GetName() -> wxString"""
+ """GetName() -> String"""
return _html.HtmlSearchStatus_GetName(*args, **kwargs)
def GetContentsItem(*args, **kwargs):
except: pass
def SetTempDir(*args, **kwargs):
- """SetTempDir(wxString path)"""
+ """SetTempDir(String path)"""
return _html.HtmlHelpData_SetTempDir(*args, **kwargs)
def AddBook(*args, **kwargs):
- """AddBook(wxString book) -> bool"""
+ """AddBook(String book) -> bool"""
return _html.HtmlHelpData_AddBook(*args, **kwargs)
def FindPageByName(*args, **kwargs):
- """FindPageByName(wxString page) -> wxString"""
+ """FindPageByName(String page) -> String"""
return _html.HtmlHelpData_FindPageByName(*args, **kwargs)
def FindPageById(*args, **kwargs):
- """FindPageById(int id) -> wxString"""
+ """FindPageById(int id) -> String"""
return _html.HtmlHelpData_FindPageById(*args, **kwargs)
def GetBookRecArray(*args, **kwargs):
return "<%s.%s; proxy of C++ wxHtmlHelpFrame instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int ??, wxString title=wxPyEmptyString,
- int style=HF_DEFAULTSTYLE, HtmlHelpData data=None) -> HtmlHelpFrame
+ __init__(Window parent, int ??, String title=EmptyString, int style=HF_DEFAULTSTYLE,
+ HtmlHelpData data=None) -> HtmlHelpFrame
"""
newobj = _html.new_HtmlHelpFrame(*args, **kwargs)
self.this = newobj.this
return _html.HtmlHelpFrame_GetData(*args, **kwargs)
def SetTitleFormat(*args, **kwargs):
- """SetTitleFormat(wxString format)"""
+ """SetTitleFormat(String format)"""
return _html.HtmlHelpFrame_SetTitleFormat(*args, **kwargs)
def Display(*args, **kwargs):
- """Display(wxString x)"""
+ """Display(String x)"""
return _html.HtmlHelpFrame_Display(*args, **kwargs)
def DisplayID(*args, **kwargs):
return _html.HtmlHelpFrame_DisplayIndex(*args, **kwargs)
def KeywordSearch(*args, **kwargs):
- """KeywordSearch(wxString keyword) -> bool"""
+ """KeywordSearch(String keyword) -> bool"""
return _html.HtmlHelpFrame_KeywordSearch(*args, **kwargs)
def UseConfig(*args, **kwargs):
- """UseConfig(wxConfigBase config, wxString rootpath=wxPyEmptyString)"""
+ """UseConfig(ConfigBase config, String rootpath=EmptyString)"""
return _html.HtmlHelpFrame_UseConfig(*args, **kwargs)
def ReadCustomization(*args, **kwargs):
- """ReadCustomization(wxConfigBase cfg, wxString path=wxPyEmptyString)"""
+ """ReadCustomization(ConfigBase cfg, String path=EmptyString)"""
return _html.HtmlHelpFrame_ReadCustomization(*args, **kwargs)
def WriteCustomization(*args, **kwargs):
- """WriteCustomization(wxConfigBase cfg, wxString path=wxPyEmptyString)"""
+ """WriteCustomization(ConfigBase cfg, String path=EmptyString)"""
return _html.HtmlHelpFrame_WriteCustomization(*args, **kwargs)
except: pass
def SetTitleFormat(*args, **kwargs):
- """SetTitleFormat(wxString format)"""
+ """SetTitleFormat(String format)"""
return _html.HtmlHelpController_SetTitleFormat(*args, **kwargs)
def SetTempDir(*args, **kwargs):
- """SetTempDir(wxString path)"""
+ """SetTempDir(String path)"""
return _html.HtmlHelpController_SetTempDir(*args, **kwargs)
def AddBook(*args, **kwargs):
- """AddBook(wxString book, int show_wait_msg=False) -> bool"""
+ """AddBook(String book, int show_wait_msg=False) -> bool"""
return _html.HtmlHelpController_AddBook(*args, **kwargs)
def Display(*args, **kwargs):
- """Display(wxString x)"""
+ """Display(String x)"""
return _html.HtmlHelpController_Display(*args, **kwargs)
def DisplayID(*args, **kwargs):
return _html.HtmlHelpController_DisplayIndex(*args, **kwargs)
def KeywordSearch(*args, **kwargs):
- """KeywordSearch(wxString keyword) -> bool"""
+ """KeywordSearch(String keyword) -> bool"""
return _html.HtmlHelpController_KeywordSearch(*args, **kwargs)
def UseConfig(*args, **kwargs):
- """UseConfig(wxConfigBase config, wxString rootpath=wxPyEmptyString)"""
+ """UseConfig(ConfigBase config, String rootpath=EmptyString)"""
return _html.HtmlHelpController_UseConfig(*args, **kwargs)
def ReadCustomization(*args, **kwargs):
- """ReadCustomization(wxConfigBase cfg, wxString path=wxPyEmptyString)"""
+ """ReadCustomization(ConfigBase cfg, String path=EmptyString)"""
return _html.HtmlHelpController_ReadCustomization(*args, **kwargs)
def WriteCustomization(*args, **kwargs):
- """WriteCustomization(wxConfigBase cfg, wxString path=wxPyEmptyString)"""
+ """WriteCustomization(ConfigBase cfg, String path=EmptyString)"""
return _html.HtmlHelpController_WriteCustomization(*args, **kwargs)
def GetFrame(*args, **kwargs):
#include <wx/html/helpctrl.h>
- DECLARE_DEF_STRING(EmptyString);
- static const wxChar* wxHtmlWindowNameStr = wxT("htmlWindow");
- DECLARE_DEF_STRING(HtmlWindowNameStr);
- static const wxChar* wxHtmlPrintoutTitleStr = wxT("Printout");
- DECLARE_DEF_STRING(HtmlPrintoutTitleStr);
- static const wxChar* wxHtmlPrintingTitleStr = wxT("Printing");
- DECLARE_DEF_STRING(HtmlPrintingTitleStr);
-
-
+ static const wxString wxPyEmptyString(wxEmptyString);
+ static const wxString wxPyHtmlWindowNameStr(wxT("htmlWindow"));
+ static const wxString wxPyHtmlPrintoutTitleStr(wxT("Printout"));
+ static const wxString wxPyHtmlPrintingTitleStr(wxT("Printing"));
void wxHtmlWinParser_SetFonts(wxHtmlWinParser *self,wxString normal_face,wxString fixed_face,PyObject *sizes){
int* temp = NULL;
if (sizes) temp = int_LIST_helper(sizes);
#ifdef __cplusplus
extern "C" {
#endif
+static int _wrap_HtmlWindowNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable HtmlWindowNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_HtmlWindowNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyHtmlWindowNameStr)->c_str(), (&wxPyHtmlWindowNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyHtmlWindowNameStr)->c_str(), (&wxPyHtmlWindowNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_HtmlPrintoutTitleStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable HtmlPrintoutTitleStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_HtmlPrintoutTitleStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyHtmlPrintoutTitleStr)->c_str(), (&wxPyHtmlPrintoutTitleStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyHtmlPrintoutTitleStr)->c_str(), (&wxPyHtmlPrintoutTitleStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_HtmlPrintingTitleStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable HtmlPrintingTitleStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_HtmlPrintingTitleStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyHtmlPrintingTitleStr)->c_str(), (&wxPyHtmlPrintingTitleStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyHtmlPrintingTitleStr)->c_str(), (&wxPyHtmlPrintingTitleStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_HtmlLinkInfo(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxString *arg1 = 0 ;
}
SWIG_InstallConstants(d,swig_const_table);
+ PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
+ SWIG_addvarlink(SWIG_globals,(char*)"HtmlWindowNameStr",_wrap_HtmlWindowNameStr_get, _wrap_HtmlWindowNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"HtmlPrintoutTitleStr",_wrap_HtmlPrintoutTitleStr_get, _wrap_HtmlPrintoutTitleStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"HtmlPrintingTitleStr",_wrap_HtmlPrintingTitleStr_get, _wrap_HtmlPrintingTitleStr_set);
wxPyPtrTypeMap_Add("wxHtmlTagHandler", "wxPyHtmlTagHandler");
wxPyPtrTypeMap_Add("wxHtmlWinTagHandler", "wxPyHtmlWinTagHandler");
def __repr__(self):
return "<%s.%s; proxy of C++ wxSystemSettings instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def GetColour(*args, **kwargs):
- """SystemSettings.GetColour(wxSystemColour index) -> wxColour"""
+ """SystemSettings.GetColour(int index) -> Colour"""
return _misc.SystemSettings_GetColour(*args, **kwargs)
GetColour = staticmethod(GetColour)
def GetFont(*args, **kwargs):
- """SystemSettings.GetFont(wxSystemFont index) -> wxFont"""
+ """SystemSettings.GetFont(int index) -> Font"""
return _misc.SystemSettings_GetFont(*args, **kwargs)
GetFont = staticmethod(GetFont)
def GetMetric(*args, **kwargs):
- """SystemSettings.GetMetric(wxSystemMetric index) -> int"""
+ """SystemSettings.GetMetric(int index) -> int"""
return _misc.SystemSettings_GetMetric(*args, **kwargs)
GetMetric = staticmethod(GetMetric)
def HasFeature(*args, **kwargs):
- """SystemSettings.HasFeature(wxSystemFeature index) -> bool"""
+ """SystemSettings.HasFeature(int index) -> bool"""
return _misc.SystemSettings_HasFeature(*args, **kwargs)
HasFeature = staticmethod(HasFeature)
def GetScreenType(*args, **kwargs):
- """SystemSettings.GetScreenType() -> wxSystemScreenType"""
+ """SystemSettings.GetScreenType() -> int"""
return _misc.SystemSettings_GetScreenType(*args, **kwargs)
GetScreenType = staticmethod(GetScreenType)
def SetScreenType(*args, **kwargs):
- """SystemSettings.SetScreenType(wxSystemScreenType screen)"""
+ """SystemSettings.SetScreenType(int screen)"""
return _misc.SystemSettings_SetScreenType(*args, **kwargs)
SetScreenType = staticmethod(SetScreenType)
_misc.SystemSettings_swigregister(SystemSettingsPtr)
def SystemSettings_GetColour(*args, **kwargs):
- """SystemSettings_GetColour(wxSystemColour index) -> wxColour"""
+ """SystemSettings_GetColour(int index) -> Colour"""
return _misc.SystemSettings_GetColour(*args, **kwargs)
def SystemSettings_GetFont(*args, **kwargs):
- """SystemSettings_GetFont(wxSystemFont index) -> wxFont"""
+ """SystemSettings_GetFont(int index) -> Font"""
return _misc.SystemSettings_GetFont(*args, **kwargs)
def SystemSettings_GetMetric(*args, **kwargs):
- """SystemSettings_GetMetric(wxSystemMetric index) -> int"""
+ """SystemSettings_GetMetric(int index) -> int"""
return _misc.SystemSettings_GetMetric(*args, **kwargs)
def SystemSettings_HasFeature(*args, **kwargs):
- """SystemSettings_HasFeature(wxSystemFeature index) -> bool"""
+ """SystemSettings_HasFeature(int index) -> bool"""
return _misc.SystemSettings_HasFeature(*args, **kwargs)
def SystemSettings_GetScreenType(*args, **kwargs):
- """SystemSettings_GetScreenType() -> wxSystemScreenType"""
+ """SystemSettings_GetScreenType() -> int"""
return _misc.SystemSettings_GetScreenType(*args, **kwargs)
def SystemSettings_SetScreenType(*args, **kwargs):
- """SystemSettings_SetScreenType(wxSystemScreenType screen)"""
+ """SystemSettings_SetScreenType(int screen)"""
return _misc.SystemSettings_SetScreenType(*args, **kwargs)
# backwards compatibility aliasses
self.thisown = 1
del newobj.thisown
def SetOption(*args, **kwargs):
- """SystemOptions.SetOption(wxString name, wxString value)"""
+ """SystemOptions.SetOption(String name, String value)"""
return _misc.SystemOptions_SetOption(*args, **kwargs)
SetOption = staticmethod(SetOption)
def SetOptionInt(*args, **kwargs):
- """SystemOptions.SetOptionInt(wxString name, int value)"""
+ """SystemOptions.SetOptionInt(String name, int value)"""
return _misc.SystemOptions_SetOptionInt(*args, **kwargs)
SetOptionInt = staticmethod(SetOptionInt)
def GetOption(*args, **kwargs):
- """SystemOptions.GetOption(wxString name) -> wxString"""
+ """SystemOptions.GetOption(String name) -> String"""
return _misc.SystemOptions_GetOption(*args, **kwargs)
GetOption = staticmethod(GetOption)
def GetOptionInt(*args, **kwargs):
- """SystemOptions.GetOptionInt(wxString name) -> int"""
+ """SystemOptions.GetOptionInt(String name) -> int"""
return _misc.SystemOptions_GetOptionInt(*args, **kwargs)
GetOptionInt = staticmethod(GetOptionInt)
def HasOption(*args, **kwargs):
- """SystemOptions.HasOption(wxString name) -> bool"""
+ """SystemOptions.HasOption(String name) -> bool"""
return _misc.SystemOptions_HasOption(*args, **kwargs)
HasOption = staticmethod(HasOption)
_misc.SystemOptions_swigregister(SystemOptionsPtr)
def SystemOptions_SetOption(*args, **kwargs):
- """SystemOptions_SetOption(wxString name, wxString value)"""
+ """SystemOptions_SetOption(String name, String value)"""
return _misc.SystemOptions_SetOption(*args, **kwargs)
def SystemOptions_SetOptionInt(*args, **kwargs):
- """SystemOptions_SetOptionInt(wxString name, int value)"""
+ """SystemOptions_SetOptionInt(String name, int value)"""
return _misc.SystemOptions_SetOptionInt(*args, **kwargs)
def SystemOptions_GetOption(*args, **kwargs):
- """SystemOptions_GetOption(wxString name) -> wxString"""
+ """SystemOptions_GetOption(String name) -> String"""
return _misc.SystemOptions_GetOption(*args, **kwargs)
def SystemOptions_GetOptionInt(*args, **kwargs):
- """SystemOptions_GetOptionInt(wxString name) -> int"""
+ """SystemOptions_GetOptionInt(String name) -> int"""
return _misc.SystemOptions_GetOptionInt(*args, **kwargs)
def SystemOptions_HasOption(*args, **kwargs):
- """SystemOptions_HasOption(wxString name) -> bool"""
+ """SystemOptions_HasOption(String name) -> bool"""
return _misc.SystemOptions_HasOption(*args, **kwargs)
#---------------------------------------------------------------------------
return _misc.IsBusy(*args, **kwargs)
def Now(*args, **kwargs):
- """Now() -> wxString"""
+ """Now() -> String"""
return _misc.Now(*args, **kwargs)
def Shell(*args, **kwargs):
- """Shell(wxString command=wxPyEmptyString) -> bool"""
+ """Shell(String command=EmptyString) -> bool"""
return _misc.Shell(*args, **kwargs)
def StartTimer(*args, **kwargs):
return _misc.GetOsVersion(*args, **kwargs)
def GetOsDescription(*args, **kwargs):
- """GetOsDescription() -> wxString"""
+ """GetOsDescription() -> String"""
return _misc.GetOsDescription(*args, **kwargs)
def GetFreeMemory(*args, **kwargs):
SHUTDOWN_REBOOT = _misc.SHUTDOWN_REBOOT
def Shutdown(*args, **kwargs):
- """Shutdown(wxShutdownFlags wFlags) -> bool"""
+ """Shutdown(int wFlags) -> bool"""
return _misc.Shutdown(*args, **kwargs)
def Sleep(*args, **kwargs):
return _misc.EnableTopLevelWindows(*args, **kwargs)
def StripMenuCodes(*args, **kwargs):
- """StripMenuCodes(wxString in) -> wxString"""
+ """StripMenuCodes(String in) -> String"""
return _misc.StripMenuCodes(*args, **kwargs)
def GetEmailAddress(*args, **kwargs):
- """GetEmailAddress() -> wxString"""
+ """GetEmailAddress() -> String"""
return _misc.GetEmailAddress(*args, **kwargs)
def GetHostName(*args, **kwargs):
- """GetHostName() -> wxString"""
+ """GetHostName() -> String"""
return _misc.GetHostName(*args, **kwargs)
def GetFullHostName(*args, **kwargs):
- """GetFullHostName() -> wxString"""
+ """GetFullHostName() -> String"""
return _misc.GetFullHostName(*args, **kwargs)
def GetUserId(*args, **kwargs):
- """GetUserId() -> wxString"""
+ """GetUserId() -> String"""
return _misc.GetUserId(*args, **kwargs)
def GetUserName(*args, **kwargs):
- """GetUserName() -> wxString"""
+ """GetUserName() -> String"""
return _misc.GetUserName(*args, **kwargs)
def GetHomeDir(*args, **kwargs):
- """GetHomeDir() -> wxString"""
+ """GetHomeDir() -> String"""
return _misc.GetHomeDir(*args, **kwargs)
def GetUserHome(*args, **kwargs):
- """GetUserHome(wxString user=wxPyEmptyString) -> wxString"""
+ """GetUserHome(String user=EmptyString) -> String"""
return _misc.GetUserHome(*args, **kwargs)
def GetProcessId(*args, **kwargs):
def FileSelector(*args, **kwargs):
"""
- FileSelector(wxString message=wxPyFileSelectorPromptStr, wxString default_path=wxPyEmptyString,
- wxString default_filename=wxPyEmptyString,
- wxString default_extension=wxPyEmptyString,
- wxString wildcard=wxPyFileSelectorDefaultWildcardStr,
- int flags=0,
- Window parent=None, int x=-1, int y=-1) -> wxString
+ 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
"""
return _misc.FileSelector(*args, **kwargs)
def LoadFileSelector(*args, **kwargs):
"""
- LoadFileSelector(wxString what, wxString extension, wxString default_name=wxPyEmptyString,
- Window parent=None) -> wxString
+ LoadFileSelector(String what, String extension, String default_name=EmptyString,
+ Window parent=None) -> String
"""
return _misc.LoadFileSelector(*args, **kwargs)
def SaveFileSelector(*args, **kwargs):
"""
- SaveFileSelector(wxString what, wxString extension, wxString default_name=wxPyEmptyString,
- Window parent=None) -> wxString
+ SaveFileSelector(String what, String extension, String default_name=EmptyString,
+ Window parent=None) -> String
"""
return _misc.SaveFileSelector(*args, **kwargs)
def DirSelector(*args, **kwargs):
"""
- DirSelector(wxString message=wxPyDirSelectorPromptStr, wxString defaultPath=wxPyEmptyString,
+ DirSelector(String message=DirSelectorPromptStr, String defaultPath=EmptyString,
long style=DD_DEFAULT_STYLE,
- Point pos=DefaultPosition, Window parent=None) -> wxString
+ Point pos=DefaultPosition, Window parent=None) -> String
"""
return _misc.DirSelector(*args, **kwargs)
def GetTextFromUser(*args, **kwargs):
"""
- GetTextFromUser(wxString message, wxString caption=wxPyEmptyString,
- wxString default_value=wxPyEmptyString, Window parent=None,
- int x=-1, int y=-1, bool centre=True) -> wxString
+ GetTextFromUser(String message, String caption=EmptyString, String default_value=EmptyString,
+ Window parent=None,
+ int x=-1, int y=-1, bool centre=True) -> String
"""
return _misc.GetTextFromUser(*args, **kwargs)
def GetPasswordFromUser(*args, **kwargs):
"""
- GetPasswordFromUser(wxString message, wxString caption=wxPyEmptyString,
- wxString default_value=wxPyEmptyString, Window parent=None) -> wxString
+ GetPasswordFromUser(String message, String caption=EmptyString, String default_value=EmptyString,
+ Window parent=None) -> String
"""
return _misc.GetPasswordFromUser(*args, **kwargs)
def GetSingleChoice(*args, **kwargs):
"""
- GetSingleChoice(wxString message, wxString caption, int choices, wxString choices_array,
+ 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) -> wxString
+ int y=-1, bool centre=True, int width=150, int height=200) -> String
"""
return _misc.GetSingleChoice(*args, **kwargs)
def GetSingleChoiceIndex(*args, **kwargs):
"""
- GetSingleChoiceIndex(wxString message, wxString caption, int choices, wxString choices_array,
+ 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
+ int y=-1, bool centre=True, int width=150, int height=200) -> int
"""
return _misc.GetSingleChoiceIndex(*args, **kwargs)
def MessageBox(*args, **kwargs):
"""
- MessageBox(wxString message, wxString caption=wxPyEmptyString,
- int style=wxOK|wxCENTRE, Window parent=None,
- int x=-1, int y=-1) -> int
+ MessageBox(String message, String caption=EmptyString, int style=wxOK|wxCENTRE,
+ Window parent=None, int x=-1,
+ int y=-1) -> int
"""
return _misc.MessageBox(*args, **kwargs)
def GetNumberFromUser(*args, **kwargs):
"""
- GetNumberFromUser(wxString message, wxString prompt, wxString caption,
- long value, long min=0, long max=100, Window parent=None,
+ GetNumberFromUser(String message, String prompt, String caption, long value,
+ long min=0, long max=100, Window parent=None,
Point pos=DefaultPosition) -> long
"""
return _misc.GetNumberFromUser(*args, **kwargs)
return _misc.GetClientDisplayRect(*args, **kwargs)
def SetCursor(*args, **kwargs):
- """SetCursor(wxCursor cursor)"""
+ """SetCursor(Cursor cursor)"""
return _misc.SetCursor(*args, **kwargs)
def BeginBusyCursor(*args, **kwargs):
- """BeginBusyCursor(wxCursor cursor=wxHOURGLASS_CURSOR)"""
+ """BeginBusyCursor(Cursor cursor=wxHOURGLASS_CURSOR)"""
return _misc.BeginBusyCursor(*args, **kwargs)
def GetActiveWindow(*args, **kwargs):
"""GetTopLevelParent(Window win) -> Window"""
return _misc.GetTopLevelParent(*args, **kwargs)
+def GetKeyState(*args, **kwargs):
+ """GetKeyState(int key) -> bool"""
+ return _misc.GetKeyState(*args, **kwargs)
+
def WakeUpMainThread(*args, **kwargs):
"""WakeUpMainThread()"""
return _misc.WakeUpMainThread(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MutexGuiLocker
_misc.MutexGuiLocker_swigregister(MutexGuiLockerPtr)
+cvar = _misc.cvar
+FileSelectorPromptStr = cvar.FileSelectorPromptStr
+FileSelectorDefaultWildcardStr = cvar.FileSelectorDefaultWildcardStr
+DirSelectorPromptStr = cvar.DirSelectorPromptStr
def Thread_IsMain(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxToolTip instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString tip) -> ToolTip"""
+ """__init__(String tip) -> ToolTip"""
newobj = _misc.new_ToolTip(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def SetTip(*args, **kwargs):
- """SetTip(wxString tip)"""
+ """SetTip(String tip)"""
return _misc.ToolTip_SetTip(*args, **kwargs)
def GetTip(*args, **kwargs):
- """GetTip() -> wxString"""
+ """GetTip() -> String"""
return _misc.ToolTip_GetTip(*args, **kwargs)
def GetWindow(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxBusyCursor instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxCursor cursor=wxHOURGLASS_CURSOR) -> BusyCursor"""
+ """__init__(Cursor cursor=wxHOURGLASS_CURSOR) -> BusyCursor"""
newobj = _misc.new_BusyCursor(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
def __repr__(self):
return "<%s.%s; proxy of C++ wxBusyInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString message) -> BusyInfo"""
+ """__init__(String message) -> BusyInfo"""
newobj = _misc.new_BusyInfo(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def AddFileToHistory(*args, **kwargs):
- """AddFileToHistory(wxString file)"""
+ """AddFileToHistory(String file)"""
return _misc.FileHistory_AddFileToHistory(*args, **kwargs)
def RemoveFileFromHistory(*args, **kwargs):
return _misc.FileHistory_AddFilesToThisMenu(*args, **kwargs)
def GetHistoryFile(*args, **kwargs):
- """GetHistoryFile(int i) -> wxString"""
+ """GetHistoryFile(int i) -> String"""
return _misc.FileHistory_GetHistoryFile(*args, **kwargs)
def GetCount(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxSingleInstanceChecker instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString name, wxString path=wxPyEmptyString) -> SingleInstanceChecker"""
+ """__init__(String name, String path=EmptyString) -> SingleInstanceChecker"""
newobj = _misc.new_SingleInstanceChecker(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def Create(*args, **kwargs):
- """Create(wxString name, wxString path=wxPyEmptyString) -> bool"""
+ """Create(String name, String path=EmptyString) -> bool"""
return _misc.SingleInstanceChecker_Create(*args, **kwargs)
def IsAnotherRunning(*args, **kwargs):
def DrawWindowOnDC(*args, **kwargs):
- """DrawWindowOnDC(Window window, wxDC dc, int method)"""
+ """DrawWindowOnDC(Window window, DC dc, int method)"""
return _misc.DrawWindowOnDC(*args, **kwargs)
#---------------------------------------------------------------------------
except: pass
def GetTip(*args, **kwargs):
- """GetTip() -> wxString"""
+ """GetTip() -> String"""
return _misc.TipProvider_GetTip(*args, **kwargs)
def GetCurrentTip(*args, **kwargs):
return _misc.TipProvider_GetCurrentTip(*args, **kwargs)
def PreprocessTip(*args, **kwargs):
- """PreprocessTip(wxString tip) -> wxString"""
+ """PreprocessTip(String tip) -> String"""
return _misc.TipProvider_PreprocessTip(*args, **kwargs)
return _misc.ShowTip(*args, **kwargs)
def CreateFileTipProvider(*args, **kwargs):
- """CreateFileTipProvider(wxString filename, size_t currentTip) -> TipProvider"""
+ """CreateFileTipProvider(String filename, size_t currentTip) -> TipProvider"""
return _misc.CreateFileTipProvider(*args, **kwargs)
#---------------------------------------------------------------------------
SetTraceMask = staticmethod(SetTraceMask)
def AddTraceMask(*args, **kwargs):
- """Log.AddTraceMask(wxString str)"""
+ """Log.AddTraceMask(String str)"""
return _misc.Log_AddTraceMask(*args, **kwargs)
AddTraceMask = staticmethod(AddTraceMask)
def RemoveTraceMask(*args, **kwargs):
- """Log.RemoveTraceMask(wxString str)"""
+ """Log.RemoveTraceMask(String str)"""
return _misc.Log_RemoveTraceMask(*args, **kwargs)
RemoveTraceMask = staticmethod(RemoveTraceMask)
GetTimestamp = staticmethod(GetTimestamp)
def TimeStamp(*args, **kwargs):
- """Log.TimeStamp() -> wxString"""
+ """Log.TimeStamp() -> String"""
return _misc.Log_TimeStamp(*args, **kwargs)
TimeStamp = staticmethod(TimeStamp)
return _misc.Log_SetTraceMask(*args, **kwargs)
def Log_AddTraceMask(*args, **kwargs):
- """Log_AddTraceMask(wxString str)"""
+ """Log_AddTraceMask(String str)"""
return _misc.Log_AddTraceMask(*args, **kwargs)
def Log_RemoveTraceMask(*args, **kwargs):
- """Log_RemoveTraceMask(wxString str)"""
+ """Log_RemoveTraceMask(String str)"""
return _misc.Log_RemoveTraceMask(*args, **kwargs)
def Log_ClearTraceMasks(*args, **kwargs):
return _misc.Log_GetTimestamp(*args, **kwargs)
def Log_TimeStamp(*args, **kwargs):
- """Log_TimeStamp() -> wxString"""
+ """Log_TimeStamp() -> String"""
return _misc.Log_TimeStamp(*args, **kwargs)
class LogStderr(Log):
def __repr__(self):
return "<%s.%s; proxy of C++ wxLogWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """
- __init__(wxFrame pParent, wxString szTitle, bool bShow=True,
- bool bPassToOld=True) -> LogWindow
- """
+ """__init__(wxFrame pParent, String szTitle, bool bShow=True, bool bPassToOld=True) -> LogWindow"""
newobj = _misc.new_LogWindow(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _misc.SysErrorCode(*args, **kwargs)
def SysErrorMsg(*args, **kwargs):
- """SysErrorMsg(unsigned long nErrCode=0) -> wxString"""
+ """SysErrorMsg(unsigned long nErrCode=0) -> String"""
return _misc.SysErrorMsg(*args, **kwargs)
def LogFatalError(*args, **kwargs):
- """LogFatalError(wxString msg)"""
+ """LogFatalError(String msg)"""
return _misc.LogFatalError(*args, **kwargs)
def LogError(*args, **kwargs):
- """LogError(wxString msg)"""
+ """LogError(String msg)"""
return _misc.LogError(*args, **kwargs)
def LogWarning(*args, **kwargs):
- """LogWarning(wxString msg)"""
+ """LogWarning(String msg)"""
return _misc.LogWarning(*args, **kwargs)
def LogMessage(*args, **kwargs):
- """LogMessage(wxString msg)"""
+ """LogMessage(String msg)"""
return _misc.LogMessage(*args, **kwargs)
def LogInfo(*args, **kwargs):
- """LogInfo(wxString msg)"""
+ """LogInfo(String msg)"""
return _misc.LogInfo(*args, **kwargs)
def LogDebug(*args, **kwargs):
- """LogDebug(wxString msg)"""
+ """LogDebug(String msg)"""
return _misc.LogDebug(*args, **kwargs)
def LogVerbose(*args, **kwargs):
- """LogVerbose(wxString msg)"""
+ """LogVerbose(String msg)"""
return _misc.LogVerbose(*args, **kwargs)
def LogStatus(*args, **kwargs):
- """LogStatus(wxString msg)"""
+ """LogStatus(String msg)"""
return _misc.LogStatus(*args, **kwargs)
def LogStatusFrame(*args, **kwargs):
- """LogStatusFrame(wxFrame pFrame, wxString msg)"""
+ """LogStatusFrame(wxFrame pFrame, String msg)"""
return _misc.LogStatusFrame(*args, **kwargs)
def LogSysError(*args, **kwargs):
- """LogSysError(wxString msg)"""
+ """LogSysError(String msg)"""
return _misc.LogSysError(*args, **kwargs)
def LogGeneric(*args, **kwargs):
- """LogGeneric(unsigned long level, wxString msg)"""
+ """LogGeneric(unsigned long level, String msg)"""
return _misc.LogGeneric(*args, **kwargs)
def SafeShowMessage(*args, **kwargs):
- """SafeShowMessage(wxString title, wxString text)"""
+ """SafeShowMessage(String title, String text)"""
return _misc.SafeShowMessage(*args, **kwargs)
class LogNull(object):
def __repr__(self):
def LogTrace(*args):
"""
- LogTrace(unsigned long mask, wxString msg)
- LogTrace(wxString mask, wxString msg)
+ LogTrace(unsigned long mask, String msg)
+ LogTrace(String mask, String msg)
"""
return _misc.LogTrace(*args)
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyProcess instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def Kill(*args, **kwargs):
- """Process.Kill(int pid, wxSignal sig=SIGTERM) -> wxKillError"""
+ """Process.Kill(int pid, int sig=SIGTERM) -> int"""
return _misc.Process_Kill(*args, **kwargs)
Kill = staticmethod(Kill)
Exists = staticmethod(Exists)
def Open(*args, **kwargs):
- """Process.Open(wxString cmd, int flags=EXEC_ASYNC) -> Process"""
+ """Process.Open(String cmd, int flags=EXEC_ASYNC) -> Process"""
return _misc.Process_Open(*args, **kwargs)
Open = staticmethod(Open)
return _misc.Process_Detach(*args, **kwargs)
def GetInputStream(*args, **kwargs):
- """GetInputStream() -> wxInputStream"""
+ """GetInputStream() -> InputStream"""
return _misc.Process_GetInputStream(*args, **kwargs)
def GetErrorStream(*args, **kwargs):
- """GetErrorStream() -> wxInputStream"""
+ """GetErrorStream() -> InputStream"""
return _misc.Process_GetErrorStream(*args, **kwargs)
def GetOutputStream(*args, **kwargs):
_misc.Process_swigregister(ProcessPtr)
def Process_Kill(*args, **kwargs):
- """Process_Kill(int pid, wxSignal sig=SIGTERM) -> wxKillError"""
+ """Process_Kill(int pid, int sig=SIGTERM) -> int"""
return _misc.Process_Kill(*args, **kwargs)
def Process_Exists(*args, **kwargs):
return _misc.Process_Exists(*args, **kwargs)
def Process_Open(*args, **kwargs):
- """Process_Open(wxString cmd, int flags=EXEC_ASYNC) -> Process"""
+ """Process_Open(String cmd, int flags=EXEC_ASYNC) -> Process"""
return _misc.Process_Open(*args, **kwargs)
class ProcessEvent(core.Event):
EXEC_MAKE_GROUP_LEADER = _misc.EXEC_MAKE_GROUP_LEADER
def Execute(*args, **kwargs):
- """Execute(wxString command, int flags=EXEC_ASYNC, Process process=None) -> long"""
+ """Execute(String command, int flags=EXEC_ASYNC, Process process=None) -> long"""
return _misc.Execute(*args, **kwargs)
#---------------------------------------------------------------------------
return _misc.Joystick_GetProductId(*args, **kwargs)
def GetProductName(*args, **kwargs):
- """GetProductName() -> wxString"""
+ """GetProductName() -> String"""
return _misc.Joystick_GetProductName(*args, **kwargs)
def GetXMin(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxWave instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString fileName, bool isResource=False) -> Wave"""
+ """__init__(String fileName, bool isResource=False) -> Wave"""
newobj = _misc.new_Wave(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
_misc.Wave_swigregister(WavePtr)
def WaveData(*args, **kwargs):
- """WaveData(wxString data) -> Wave"""
+ """WaveData(String data) -> Wave"""
val = _misc.new_WaveData(*args, **kwargs)
val.thisown = 1
return val
def __repr__(self):
return "<%s.%s; proxy of C++ wxFileTypeInfo instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """
- __init__(wxString mimeType, wxString openCmd, wxString printCmd,
- wxString desc) -> FileTypeInfo
- """
+ """__init__(String mimeType, String openCmd, String printCmd, String desc) -> FileTypeInfo"""
newobj = _misc.new_FileTypeInfo(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _misc.FileTypeInfo_IsValid(*args, **kwargs)
def SetIcon(*args, **kwargs):
- """SetIcon(wxString iconFile, int iconIndex=0)"""
+ """SetIcon(String iconFile, int iconIndex=0)"""
return _misc.FileTypeInfo_SetIcon(*args, **kwargs)
def SetShortDesc(*args, **kwargs):
- """SetShortDesc(wxString shortDesc)"""
+ """SetShortDesc(String shortDesc)"""
return _misc.FileTypeInfo_SetShortDesc(*args, **kwargs)
def GetMimeType(*args, **kwargs):
- """GetMimeType() -> wxString"""
+ """GetMimeType() -> String"""
return _misc.FileTypeInfo_GetMimeType(*args, **kwargs)
def GetOpenCommand(*args, **kwargs):
- """GetOpenCommand() -> wxString"""
+ """GetOpenCommand() -> String"""
return _misc.FileTypeInfo_GetOpenCommand(*args, **kwargs)
def GetPrintCommand(*args, **kwargs):
- """GetPrintCommand() -> wxString"""
+ """GetPrintCommand() -> String"""
return _misc.FileTypeInfo_GetPrintCommand(*args, **kwargs)
def GetShortDesc(*args, **kwargs):
- """GetShortDesc() -> wxString"""
+ """GetShortDesc() -> String"""
return _misc.FileTypeInfo_GetShortDesc(*args, **kwargs)
def GetDescription(*args, **kwargs):
- """GetDescription() -> wxString"""
+ """GetDescription() -> String"""
return _misc.FileTypeInfo_GetDescription(*args, **kwargs)
def GetExtensions(*args, **kwargs):
return _misc.FileTypeInfo_GetExtensionsCount(*args, **kwargs)
def GetIconFile(*args, **kwargs):
- """GetIconFile() -> wxString"""
+ """GetIconFile() -> String"""
return _misc.FileTypeInfo_GetIconFile(*args, **kwargs)
def GetIconIndex(*args, **kwargs):
return _misc.FileType_GetExtensions(*args, **kwargs)
def GetIcon(*args, **kwargs):
- """GetIcon() -> wxIcon"""
+ """GetIcon() -> Icon"""
return _misc.FileType_GetIcon(*args, **kwargs)
def GetIconInfo(*args, **kwargs):
return _misc.FileType_GetDescription(*args, **kwargs)
def GetOpenCommand(*args, **kwargs):
- """GetOpenCommand(wxString filename, wxString mimetype=wxPyEmptyString) -> PyObject"""
+ """GetOpenCommand(String filename, String mimetype=EmptyString) -> PyObject"""
return _misc.FileType_GetOpenCommand(*args, **kwargs)
def GetPrintCommand(*args, **kwargs):
- """GetPrintCommand(wxString filename, wxString mimetype=wxPyEmptyString) -> PyObject"""
+ """GetPrintCommand(String filename, String mimetype=EmptyString) -> PyObject"""
return _misc.FileType_GetPrintCommand(*args, **kwargs)
def GetAllCommands(*args, **kwargs):
- """GetAllCommands(wxString filename, wxString mimetype=wxPyEmptyString) -> PyObject"""
+ """GetAllCommands(String filename, String mimetype=EmptyString) -> PyObject"""
return _misc.FileType_GetAllCommands(*args, **kwargs)
def SetCommand(*args, **kwargs):
- """SetCommand(wxString cmd, wxString verb, bool overwriteprompt=True) -> bool"""
+ """SetCommand(String cmd, String verb, bool overwriteprompt=True) -> bool"""
return _misc.FileType_SetCommand(*args, **kwargs)
def SetDefaultIcon(*args, **kwargs):
- """SetDefaultIcon(wxString cmd=wxPyEmptyString, int index=0) -> bool"""
+ """SetDefaultIcon(String cmd=EmptyString, int index=0) -> bool"""
return _misc.FileType_SetDefaultIcon(*args, **kwargs)
def Unassociate(*args, **kwargs):
return _misc.FileType_Unassociate(*args, **kwargs)
def ExpandCommand(*args, **kwargs):
- """FileType.ExpandCommand(wxString command, wxString filename, wxString mimetype=wxPyEmptyString) -> wxString"""
+ """FileType.ExpandCommand(String command, String filename, String mimetype=EmptyString) -> String"""
return _misc.FileType_ExpandCommand(*args, **kwargs)
ExpandCommand = staticmethod(ExpandCommand)
_misc.FileType_swigregister(FileTypePtr)
def FileType_ExpandCommand(*args, **kwargs):
- """FileType_ExpandCommand(wxString command, wxString filename, wxString mimetype=wxPyEmptyString) -> wxString"""
+ """FileType_ExpandCommand(String command, String filename, String mimetype=EmptyString) -> String"""
return _misc.FileType_ExpandCommand(*args, **kwargs)
class MimeTypesManager(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxMimeTypesManager instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def IsOfType(*args, **kwargs):
- """MimeTypesManager.IsOfType(wxString mimeType, wxString wildcard) -> bool"""
+ """MimeTypesManager.IsOfType(String mimeType, String wildcard) -> bool"""
return _misc.MimeTypesManager_IsOfType(*args, **kwargs)
IsOfType = staticmethod(IsOfType)
self.thisown = 1
del newobj.thisown
def Initialize(*args, **kwargs):
- """Initialize(int mailcapStyle=MAILCAP_ALL, wxString extraDir=wxPyEmptyString)"""
+ """Initialize(int mailcapStyle=MAILCAP_ALL, String extraDir=EmptyString)"""
return _misc.MimeTypesManager_Initialize(*args, **kwargs)
def ClearData(*args, **kwargs):
return _misc.MimeTypesManager_ClearData(*args, **kwargs)
def GetFileTypeFromExtension(*args, **kwargs):
- """GetFileTypeFromExtension(wxString ext) -> FileType"""
+ """GetFileTypeFromExtension(String ext) -> FileType"""
return _misc.MimeTypesManager_GetFileTypeFromExtension(*args, **kwargs)
def GetFileTypeFromMimeType(*args, **kwargs):
- """GetFileTypeFromMimeType(wxString mimeType) -> FileType"""
+ """GetFileTypeFromMimeType(String mimeType) -> FileType"""
return _misc.MimeTypesManager_GetFileTypeFromMimeType(*args, **kwargs)
def ReadMailcap(*args, **kwargs):
- """ReadMailcap(wxString filename, bool fallback=False) -> bool"""
+ """ReadMailcap(String filename, bool fallback=False) -> bool"""
return _misc.MimeTypesManager_ReadMailcap(*args, **kwargs)
def ReadMimeTypes(*args, **kwargs):
- """ReadMimeTypes(wxString filename) -> bool"""
+ """ReadMimeTypes(String filename) -> bool"""
return _misc.MimeTypesManager_ReadMimeTypes(*args, **kwargs)
def EnumAllFileTypes(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = MimeTypesManager
_misc.MimeTypesManager_swigregister(MimeTypesManagerPtr)
-cvar = _misc.cvar
TheMimeTypesManager = cvar.TheMimeTypesManager
def MimeTypesManager_IsOfType(*args, **kwargs):
- """MimeTypesManager_IsOfType(wxString mimeType, wxString wildcard) -> bool"""
+ """MimeTypesManager_IsOfType(String mimeType, String wildcard) -> bool"""
return _misc.MimeTypesManager_IsOfType(*args, **kwargs)
#---------------------------------------------------------------------------
RemoveProvider = staticmethod(RemoveProvider)
def GetBitmap(*args, **kwargs):
"""
- ArtProvider.GetBitmap(wxString id, wxString client=ART_OTHER, Size size=DefaultSize) -> wxBitmap
+ 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.
GetBitmap = staticmethod(GetBitmap)
def GetIcon(*args, **kwargs):
"""
- ArtProvider.GetIcon(wxString id, wxString client=ART_OTHER, Size size=DefaultSize) -> wxIcon
+ 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.
def ArtProvider_GetBitmap(*args, **kwargs):
"""
- ArtProvider_GetBitmap(wxString id, wxString client=ART_OTHER, Size size=DefaultSize) -> wxBitmap
+ 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.
def ArtProvider_GetIcon(*args, **kwargs):
"""
- ArtProvider_GetIcon(wxString id, wxString client=ART_OTHER, Size size=DefaultSize) -> wxIcon
+ 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.
DontCreateOnDemand = staticmethod(DontCreateOnDemand)
def SetPath(*args, **kwargs):
- """SetPath(wxString strPath)"""
+ """SetPath(String strPath)"""
return _misc.ConfigBase_SetPath(*args, **kwargs)
def GetPath(*args, **kwargs):
- """GetPath() -> wxString"""
+ """GetPath() -> String"""
return _misc.ConfigBase_GetPath(*args, **kwargs)
def GetFirstGroup(*args, **kwargs):
return _misc.ConfigBase_GetNumberOfGroups(*args, **kwargs)
def HasGroup(*args, **kwargs):
- """HasGroup(wxString strName) -> bool"""
+ """HasGroup(String strName) -> bool"""
return _misc.ConfigBase_HasGroup(*args, **kwargs)
def HasEntry(*args, **kwargs):
- """HasEntry(wxString strName) -> bool"""
+ """HasEntry(String strName) -> bool"""
return _misc.ConfigBase_HasEntry(*args, **kwargs)
def Exists(*args, **kwargs):
- """Exists(wxString strName) -> bool"""
+ """Exists(String strName) -> bool"""
return _misc.ConfigBase_Exists(*args, **kwargs)
def GetEntryType(*args, **kwargs):
- """GetEntryType(wxString name) -> wxConfigBase::EntryType"""
+ """GetEntryType(String name) -> int"""
return _misc.ConfigBase_GetEntryType(*args, **kwargs)
def Read(*args, **kwargs):
- """Read(wxString key, wxString defaultVal=wxPyEmptyString) -> wxString"""
+ """Read(String key, String defaultVal=EmptyString) -> String"""
return _misc.ConfigBase_Read(*args, **kwargs)
def ReadInt(*args, **kwargs):
- """ReadInt(wxString key, long defaultVal=0) -> long"""
+ """ReadInt(String key, long defaultVal=0) -> long"""
return _misc.ConfigBase_ReadInt(*args, **kwargs)
def ReadFloat(*args, **kwargs):
- """ReadFloat(wxString key, double defaultVal=0.0) -> double"""
+ """ReadFloat(String key, double defaultVal=0.0) -> double"""
return _misc.ConfigBase_ReadFloat(*args, **kwargs)
def ReadBool(*args, **kwargs):
- """ReadBool(wxString key, bool defaultVal=False) -> bool"""
+ """ReadBool(String key, bool defaultVal=False) -> bool"""
return _misc.ConfigBase_ReadBool(*args, **kwargs)
def Write(*args, **kwargs):
- """Write(wxString key, wxString value) -> bool"""
+ """Write(String key, String value) -> bool"""
return _misc.ConfigBase_Write(*args, **kwargs)
def WriteInt(*args, **kwargs):
- """WriteInt(wxString key, long value) -> bool"""
+ """WriteInt(String key, long value) -> bool"""
return _misc.ConfigBase_WriteInt(*args, **kwargs)
def WriteFloat(*args, **kwargs):
- """WriteFloat(wxString key, double value) -> bool"""
+ """WriteFloat(String key, double value) -> bool"""
return _misc.ConfigBase_WriteFloat(*args, **kwargs)
def WriteBool(*args, **kwargs):
- """WriteBool(wxString key, bool value) -> bool"""
+ """WriteBool(String key, bool value) -> bool"""
return _misc.ConfigBase_WriteBool(*args, **kwargs)
def Flush(*args, **kwargs):
return _misc.ConfigBase_Flush(*args, **kwargs)
def RenameEntry(*args, **kwargs):
- """RenameEntry(wxString oldName, wxString newName) -> bool"""
+ """RenameEntry(String oldName, String newName) -> bool"""
return _misc.ConfigBase_RenameEntry(*args, **kwargs)
def RenameGroup(*args, **kwargs):
- """RenameGroup(wxString oldName, wxString newName) -> bool"""
+ """RenameGroup(String oldName, String newName) -> bool"""
return _misc.ConfigBase_RenameGroup(*args, **kwargs)
def DeleteEntry(*args, **kwargs):
- """DeleteEntry(wxString key, bool bDeleteGroupIfEmpty=True) -> bool"""
+ """DeleteEntry(String key, bool bDeleteGroupIfEmpty=True) -> bool"""
return _misc.ConfigBase_DeleteEntry(*args, **kwargs)
def DeleteGroup(*args, **kwargs):
- """DeleteGroup(wxString key) -> bool"""
+ """DeleteGroup(String key) -> bool"""
return _misc.ConfigBase_DeleteGroup(*args, **kwargs)
def DeleteAll(*args, **kwargs):
return _misc.ConfigBase_IsRecordingDefaults(*args, **kwargs)
def ExpandEnvVars(*args, **kwargs):
- """ExpandEnvVars(wxString str) -> wxString"""
+ """ExpandEnvVars(String str) -> String"""
return _misc.ConfigBase_ExpandEnvVars(*args, **kwargs)
def GetAppName(*args, **kwargs):
- """GetAppName() -> wxString"""
+ """GetAppName() -> String"""
return _misc.ConfigBase_GetAppName(*args, **kwargs)
def GetVendorName(*args, **kwargs):
- """GetVendorName() -> wxString"""
+ """GetVendorName() -> String"""
return _misc.ConfigBase_GetVendorName(*args, **kwargs)
def SetAppName(*args, **kwargs):
- """SetAppName(wxString appName)"""
+ """SetAppName(String appName)"""
return _misc.ConfigBase_SetAppName(*args, **kwargs)
def SetVendorName(*args, **kwargs):
- """SetVendorName(wxString vendorName)"""
+ """SetVendorName(String vendorName)"""
return _misc.ConfigBase_SetVendorName(*args, **kwargs)
def SetStyle(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxConfigPathChanger instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(ConfigBase pContainer, wxString strEntry) -> ConfigPathChanger"""
+ """__init__(ConfigBase pContainer, String strEntry) -> ConfigPathChanger"""
newobj = _misc.new_ConfigPathChanger(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
except: pass
def Name(*args, **kwargs):
- """Name() -> wxString"""
+ """Name() -> String"""
return _misc.ConfigPathChanger_Name(*args, **kwargs)
return "<%s.%s; proxy of C++ wxConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(wxString appName=wxPyEmptyString, wxString vendorName=wxPyEmptyString,
- wxString localFilename=wxPyEmptyString,
- wxString globalFilename=wxPyEmptyString,
+ __init__(String appName=EmptyString, String vendorName=EmptyString,
+ String localFilename=EmptyString, String globalFilename=EmptyString,
long style=0) -> Config
"""
newobj = _misc.new_Config(*args, **kwargs)
return "<%s.%s; proxy of C++ wxFileConfig instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(wxString appName=wxPyEmptyString, wxString vendorName=wxPyEmptyString,
- wxString localFilename=wxPyEmptyString,
- wxString globalFilename=wxPyEmptyString,
+ __init__(String appName=EmptyString, String vendorName=EmptyString,
+ String localFilename=EmptyString, String globalFilename=EmptyString,
long style=0) -> FileConfig
"""
newobj = _misc.new_FileConfig(*args, **kwargs)
def ExpandEnvVars(*args, **kwargs):
- """ExpandEnvVars(wxString sz) -> wxString"""
+ """ExpandEnvVars(String sz) -> String"""
return _misc.ExpandEnvVars(*args, **kwargs)
#---------------------------------------------------------------------------
Monday_First = _misc.DateTime_Monday_First
Sunday_First = _misc.DateTime_Sunday_First
def SetCountry(*args, **kwargs):
- """DateTime.SetCountry(wxDateTime::Country country)"""
+ """DateTime.SetCountry(int country)"""
return _misc.DateTime_SetCountry(*args, **kwargs)
SetCountry = staticmethod(SetCountry)
def GetCountry(*args, **kwargs):
- """DateTime.GetCountry() -> wxDateTime::Country"""
+ """DateTime.GetCountry() -> int"""
return _misc.DateTime_GetCountry(*args, **kwargs)
GetCountry = staticmethod(GetCountry)
def IsWestEuropeanCountry(*args, **kwargs):
- """DateTime.IsWestEuropeanCountry(wxDateTime::Country country=Country_Default) -> bool"""
+ """DateTime.IsWestEuropeanCountry(int country=Country_Default) -> bool"""
return _misc.DateTime_IsWestEuropeanCountry(*args, **kwargs)
IsWestEuropeanCountry = staticmethod(IsWestEuropeanCountry)
def GetCurrentYear(*args, **kwargs):
- """DateTime.GetCurrentYear(wxDateTime::Calendar cal=Gregorian) -> int"""
+ """DateTime.GetCurrentYear(int cal=Gregorian) -> int"""
return _misc.DateTime_GetCurrentYear(*args, **kwargs)
GetCurrentYear = staticmethod(GetCurrentYear)
ConvertYearToBC = staticmethod(ConvertYearToBC)
def GetCurrentMonth(*args, **kwargs):
- """DateTime.GetCurrentMonth(wxDateTime::Calendar cal=Gregorian) -> wxDateTime::Month"""
+ """DateTime.GetCurrentMonth(int cal=Gregorian) -> int"""
return _misc.DateTime_GetCurrentMonth(*args, **kwargs)
GetCurrentMonth = staticmethod(GetCurrentMonth)
def IsLeapYear(*args, **kwargs):
- """DateTime.IsLeapYear(int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> bool"""
+ """DateTime.IsLeapYear(int year=Inv_Year, int cal=Gregorian) -> bool"""
return _misc.DateTime_IsLeapYear(*args, **kwargs)
IsLeapYear = staticmethod(IsLeapYear)
GetCentury = staticmethod(GetCentury)
def GetNumberOfDaysinYear(*args, **kwargs):
- """DateTime.GetNumberOfDaysinYear(int year, wxDateTime::Calendar cal=Gregorian) -> int"""
+ """DateTime.GetNumberOfDaysinYear(int year, int cal=Gregorian) -> int"""
return _misc.DateTime_GetNumberOfDaysinYear(*args, **kwargs)
GetNumberOfDaysinYear = staticmethod(GetNumberOfDaysinYear)
def GetNumberOfDaysInMonth(*args, **kwargs):
- """DateTime.GetNumberOfDaysInMonth(wxDateTime::Month month, int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> int"""
+ """DateTime.GetNumberOfDaysInMonth(int month, int year=Inv_Year, int cal=Gregorian) -> int"""
return _misc.DateTime_GetNumberOfDaysInMonth(*args, **kwargs)
GetNumberOfDaysInMonth = staticmethod(GetNumberOfDaysInMonth)
def GetMonthName(*args, **kwargs):
- """DateTime.GetMonthName(wxDateTime::Month month, wxDateTime::NameFlags flags=Name_Full) -> wxString"""
+ """DateTime.GetMonthName(int month, int flags=Name_Full) -> String"""
return _misc.DateTime_GetMonthName(*args, **kwargs)
GetMonthName = staticmethod(GetMonthName)
def GetWeekDayName(*args, **kwargs):
- """DateTime.GetWeekDayName(wxDateTime::WeekDay weekday, wxDateTime::NameFlags flags=Name_Full) -> wxString"""
+ """DateTime.GetWeekDayName(int weekday, int flags=Name_Full) -> String"""
return _misc.DateTime_GetWeekDayName(*args, **kwargs)
GetWeekDayName = staticmethod(GetWeekDayName)
GetAmPmStrings = staticmethod(GetAmPmStrings)
def IsDSTApplicable(*args, **kwargs):
- """DateTime.IsDSTApplicable(int year=Inv_Year, wxDateTime::Country country=Country_Default) -> bool"""
+ """DateTime.IsDSTApplicable(int year=Inv_Year, int country=Country_Default) -> bool"""
return _misc.DateTime_IsDSTApplicable(*args, **kwargs)
IsDSTApplicable = staticmethod(IsDSTApplicable)
def GetBeginDST(*args, **kwargs):
- """DateTime.GetBeginDST(int year=Inv_Year, wxDateTime::Country country=Country_Default) -> DateTime"""
+ """DateTime.GetBeginDST(int year=Inv_Year, int country=Country_Default) -> DateTime"""
return _misc.DateTime_GetBeginDST(*args, **kwargs)
GetBeginDST = staticmethod(GetBeginDST)
def GetEndDST(*args, **kwargs):
- """DateTime.GetEndDST(int year=Inv_Year, wxDateTime::Country country=Country_Default) -> DateTime"""
+ """DateTime.GetEndDST(int year=Inv_Year, int country=Country_Default) -> DateTime"""
return _misc.DateTime_GetEndDST(*args, **kwargs)
GetEndDST = staticmethod(GetEndDST)
def Set(*args, **kwargs):
"""
- Set(int day, wxDateTime::Month month=Inv_Month, int year=Inv_Year,
- int hour=0, 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
"""
return _misc.DateTime_Set(*args, **kwargs)
return _misc.DateTime_SetYear(*args, **kwargs)
def SetMonth(*args, **kwargs):
- """SetMonth(wxDateTime::Month month) -> DateTime"""
+ """SetMonth(int month) -> DateTime"""
return _misc.DateTime_SetMonth(*args, **kwargs)
def SetDay(*args, **kwargs):
return _misc.DateTime_SetMillisecond(*args, **kwargs)
def SetToWeekDayInSameWeek(*args, **kwargs):
- """SetToWeekDayInSameWeek(wxDateTime::WeekDay weekday, wxDateTime::WeekFlags flags=Monday_First) -> DateTime"""
+ """SetToWeekDayInSameWeek(int weekday, int flags=Monday_First) -> DateTime"""
return _misc.DateTime_SetToWeekDayInSameWeek(*args, **kwargs)
def GetWeekDayInSameWeek(*args, **kwargs):
- """GetWeekDayInSameWeek(wxDateTime::WeekDay weekday, wxDateTime::WeekFlags flags=Monday_First) -> DateTime"""
+ """GetWeekDayInSameWeek(int weekday, int flags=Monday_First) -> DateTime"""
return _misc.DateTime_GetWeekDayInSameWeek(*args, **kwargs)
def SetToNextWeekDay(*args, **kwargs):
- """SetToNextWeekDay(wxDateTime::WeekDay weekday) -> DateTime"""
+ """SetToNextWeekDay(int weekday) -> DateTime"""
return _misc.DateTime_SetToNextWeekDay(*args, **kwargs)
def GetNextWeekDay(*args, **kwargs):
- """GetNextWeekDay(wxDateTime::WeekDay weekday) -> DateTime"""
+ """GetNextWeekDay(int weekday) -> DateTime"""
return _misc.DateTime_GetNextWeekDay(*args, **kwargs)
def SetToPrevWeekDay(*args, **kwargs):
- """SetToPrevWeekDay(wxDateTime::WeekDay weekday) -> DateTime"""
+ """SetToPrevWeekDay(int weekday) -> DateTime"""
return _misc.DateTime_SetToPrevWeekDay(*args, **kwargs)
def GetPrevWeekDay(*args, **kwargs):
- """GetPrevWeekDay(wxDateTime::WeekDay weekday) -> DateTime"""
+ """GetPrevWeekDay(int weekday) -> DateTime"""
return _misc.DateTime_GetPrevWeekDay(*args, **kwargs)
def SetToWeekDay(*args, **kwargs):
- """
- SetToWeekDay(wxDateTime::WeekDay weekday, int n=1, wxDateTime::Month month=Inv_Month,
- int year=Inv_Year) -> bool
- """
+ """SetToWeekDay(int weekday, int n=1, int month=Inv_Month, int year=Inv_Year) -> bool"""
return _misc.DateTime_SetToWeekDay(*args, **kwargs)
def SetToLastWeekDay(*args, **kwargs):
- """
- SetToLastWeekDay(wxDateTime::WeekDay weekday, wxDateTime::Month month=Inv_Month,
- int year=Inv_Year) -> bool
- """
+ """SetToLastWeekDay(int weekday, int month=Inv_Month, int year=Inv_Year) -> bool"""
return _misc.DateTime_SetToLastWeekDay(*args, **kwargs)
def GetLastWeekDay(*args, **kwargs):
- """
- GetLastWeekDay(wxDateTime::WeekDay weekday, wxDateTime::Month month=Inv_Month,
- int year=Inv_Year) -> DateTime
- """
+ """GetLastWeekDay(int weekday, int month=Inv_Month, int year=Inv_Year) -> DateTime"""
return _misc.DateTime_GetLastWeekDay(*args, **kwargs)
def SetToTheWeek(*args, **kwargs):
- """SetToTheWeek(int numWeek, wxDateTime::WeekDay weekday=Mon, wxDateTime::WeekFlags flags=Monday_First) -> bool"""
+ """SetToTheWeek(int numWeek, int weekday=Mon, int flags=Monday_First) -> bool"""
return _misc.DateTime_SetToTheWeek(*args, **kwargs)
def GetWeek(*args, **kwargs):
- """GetWeek(int numWeek, wxDateTime::WeekDay weekday=Mon, wxDateTime::WeekFlags flags=Monday_First) -> DateTime"""
+ """GetWeek(int numWeek, int weekday=Mon, int flags=Monday_First) -> DateTime"""
return _misc.DateTime_GetWeek(*args, **kwargs)
def SetToLastMonthDay(*args, **kwargs):
- """SetToLastMonthDay(wxDateTime::Month month=Inv_Month, int year=Inv_Year) -> DateTime"""
+ """SetToLastMonthDay(int month=Inv_Month, int year=Inv_Year) -> DateTime"""
return _misc.DateTime_SetToLastMonthDay(*args, **kwargs)
def GetLastMonthDay(*args, **kwargs):
- """GetLastMonthDay(wxDateTime::Month month=Inv_Month, int year=Inv_Year) -> DateTime"""
+ """GetLastMonthDay(int month=Inv_Month, int year=Inv_Year) -> DateTime"""
return _misc.DateTime_GetLastMonthDay(*args, **kwargs)
def SetToYearDay(*args, **kwargs):
return _misc.DateTime_MakeGMT(*args, **kwargs)
def IsDST(*args, **kwargs):
- """IsDST(wxDateTime::Country country=Country_Default) -> int"""
+ """IsDST(int country=Country_Default) -> int"""
return _misc.DateTime_IsDST(*args, **kwargs)
def IsValid(*args, **kwargs):
return _misc.DateTime_GetYear(*args, **kwargs)
def GetMonth(*args, **kwargs):
- """GetMonth(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime::Month"""
+ """GetMonth(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetMonth(*args, **kwargs)
def GetDay(*args, **kwargs):
return _misc.DateTime_GetDay(*args, **kwargs)
def GetWeekDay(*args, **kwargs):
- """GetWeekDay(wxDateTime::TimeZone tz=LOCAL_TZ) -> wxDateTime::WeekDay"""
+ """GetWeekDay(wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetWeekDay(*args, **kwargs)
def GetHour(*args, **kwargs):
return _misc.DateTime_GetDayOfYear(*args, **kwargs)
def GetWeekOfYear(*args, **kwargs):
- """GetWeekOfYear(wxDateTime::WeekFlags flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
+ """GetWeekOfYear(int flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetWeekOfYear(*args, **kwargs)
def GetWeekOfMonth(*args, **kwargs):
- """GetWeekOfMonth(wxDateTime::WeekFlags flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
+ """GetWeekOfMonth(int flags=Monday_First, wxDateTime::TimeZone tz=LOCAL_TZ) -> int"""
return _misc.DateTime_GetWeekOfMonth(*args, **kwargs)
def IsWorkDay(*args, **kwargs):
- """IsWorkDay(wxDateTime::Country country=Country_Default) -> bool"""
+ """IsWorkDay(int country=Country_Default) -> bool"""
return _misc.DateTime_IsWorkDay(*args, **kwargs)
def IsEqualTo(*args, **kwargs):
return _misc.DateTime___ne__(*args)
def ParseRfc822Date(*args, **kwargs):
- """ParseRfc822Date(wxString date) -> int"""
+ """ParseRfc822Date(String date) -> int"""
return _misc.DateTime_ParseRfc822Date(*args, **kwargs)
def ParseFormat(*args, **kwargs):
- """ParseFormat(wxString date, wxString format=wxPyDateFormatStr, DateTime dateDef=wxDefaultDateTime) -> int"""
+ """ParseFormat(String date, String format=DateFormatStr, DateTime dateDef=wxDefaultDateTime) -> int"""
return _misc.DateTime_ParseFormat(*args, **kwargs)
def ParseDateTime(*args, **kwargs):
- """ParseDateTime(wxString datetime) -> int"""
+ """ParseDateTime(String datetime) -> int"""
return _misc.DateTime_ParseDateTime(*args, **kwargs)
def ParseDate(*args, **kwargs):
- """ParseDate(wxString date) -> int"""
+ """ParseDate(String date) -> int"""
return _misc.DateTime_ParseDate(*args, **kwargs)
def ParseTime(*args, **kwargs):
- """ParseTime(wxString time) -> int"""
+ """ParseTime(String time) -> int"""
return _misc.DateTime_ParseTime(*args, **kwargs)
def Format(*args, **kwargs):
- """Format(wxString format=wxPyDateFormatStr, wxDateTime::TimeZone tz=LOCAL_TZ) -> wxString"""
+ """Format(String format=DateFormatStr, wxDateTime::TimeZone tz=LOCAL_TZ) -> String"""
return _misc.DateTime_Format(*args, **kwargs)
def FormatDate(*args, **kwargs):
- """FormatDate() -> wxString"""
+ """FormatDate() -> String"""
return _misc.DateTime_FormatDate(*args, **kwargs)
def FormatTime(*args, **kwargs):
- """FormatTime() -> wxString"""
+ """FormatTime() -> String"""
return _misc.DateTime_FormatTime(*args, **kwargs)
def FormatISODate(*args, **kwargs):
- """FormatISODate() -> wxString"""
+ """FormatISODate() -> String"""
return _misc.DateTime_FormatISODate(*args, **kwargs)
def FormatISOTime(*args, **kwargs):
- """FormatISOTime() -> wxString"""
+ """FormatISOTime() -> String"""
return _misc.DateTime_FormatISOTime(*args, **kwargs)
def __repr__(self):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = DateTime
_misc.DateTime_swigregister(DateTimePtr)
+DateFormatStr = cvar.DateFormatStr
+TimeSpanFormatStr = cvar.TimeSpanFormatStr
def DateTime_SetCountry(*args, **kwargs):
- """DateTime_SetCountry(wxDateTime::Country country)"""
+ """DateTime_SetCountry(int country)"""
return _misc.DateTime_SetCountry(*args, **kwargs)
def DateTime_GetCountry(*args, **kwargs):
- """DateTime_GetCountry() -> wxDateTime::Country"""
+ """DateTime_GetCountry() -> int"""
return _misc.DateTime_GetCountry(*args, **kwargs)
def DateTime_IsWestEuropeanCountry(*args, **kwargs):
- """DateTime_IsWestEuropeanCountry(wxDateTime::Country country=Country_Default) -> bool"""
+ """DateTime_IsWestEuropeanCountry(int country=Country_Default) -> bool"""
return _misc.DateTime_IsWestEuropeanCountry(*args, **kwargs)
def DateTime_GetCurrentYear(*args, **kwargs):
- """DateTime_GetCurrentYear(wxDateTime::Calendar cal=Gregorian) -> int"""
+ """DateTime_GetCurrentYear(int cal=Gregorian) -> int"""
return _misc.DateTime_GetCurrentYear(*args, **kwargs)
def DateTime_ConvertYearToBC(*args, **kwargs):
return _misc.DateTime_ConvertYearToBC(*args, **kwargs)
def DateTime_GetCurrentMonth(*args, **kwargs):
- """DateTime_GetCurrentMonth(wxDateTime::Calendar cal=Gregorian) -> wxDateTime::Month"""
+ """DateTime_GetCurrentMonth(int cal=Gregorian) -> int"""
return _misc.DateTime_GetCurrentMonth(*args, **kwargs)
def DateTime_IsLeapYear(*args, **kwargs):
- """DateTime_IsLeapYear(int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> bool"""
+ """DateTime_IsLeapYear(int year=Inv_Year, int cal=Gregorian) -> bool"""
return _misc.DateTime_IsLeapYear(*args, **kwargs)
def DateTime_GetCentury(*args, **kwargs):
return _misc.DateTime_GetCentury(*args, **kwargs)
def DateTime_GetNumberOfDaysinYear(*args, **kwargs):
- """DateTime_GetNumberOfDaysinYear(int year, wxDateTime::Calendar cal=Gregorian) -> int"""
+ """DateTime_GetNumberOfDaysinYear(int year, int cal=Gregorian) -> int"""
return _misc.DateTime_GetNumberOfDaysinYear(*args, **kwargs)
def DateTime_GetNumberOfDaysInMonth(*args, **kwargs):
- """DateTime_GetNumberOfDaysInMonth(wxDateTime::Month month, int year=Inv_Year, wxDateTime::Calendar cal=Gregorian) -> int"""
+ """DateTime_GetNumberOfDaysInMonth(int month, int year=Inv_Year, int cal=Gregorian) -> int"""
return _misc.DateTime_GetNumberOfDaysInMonth(*args, **kwargs)
def DateTime_GetMonthName(*args, **kwargs):
- """DateTime_GetMonthName(wxDateTime::Month month, wxDateTime::NameFlags flags=Name_Full) -> wxString"""
+ """DateTime_GetMonthName(int month, int flags=Name_Full) -> String"""
return _misc.DateTime_GetMonthName(*args, **kwargs)
def DateTime_GetWeekDayName(*args, **kwargs):
- """DateTime_GetWeekDayName(wxDateTime::WeekDay weekday, wxDateTime::NameFlags flags=Name_Full) -> wxString"""
+ """DateTime_GetWeekDayName(int weekday, int flags=Name_Full) -> String"""
return _misc.DateTime_GetWeekDayName(*args, **kwargs)
def DateTime_GetAmPmStrings(*args, **kwargs):
return _misc.DateTime_GetAmPmStrings(*args, **kwargs)
def DateTime_IsDSTApplicable(*args, **kwargs):
- """DateTime_IsDSTApplicable(int year=Inv_Year, wxDateTime::Country country=Country_Default) -> bool"""
+ """DateTime_IsDSTApplicable(int year=Inv_Year, int country=Country_Default) -> bool"""
return _misc.DateTime_IsDSTApplicable(*args, **kwargs)
def DateTime_GetBeginDST(*args, **kwargs):
- """DateTime_GetBeginDST(int year=Inv_Year, wxDateTime::Country country=Country_Default) -> DateTime"""
+ """DateTime_GetBeginDST(int year=Inv_Year, int country=Country_Default) -> DateTime"""
return _misc.DateTime_GetBeginDST(*args, **kwargs)
def DateTime_GetEndDST(*args, **kwargs):
- """DateTime_GetEndDST(int year=Inv_Year, wxDateTime::Country country=Country_Default) -> DateTime"""
+ """DateTime_GetEndDST(int year=Inv_Year, int country=Country_Default) -> DateTime"""
return _misc.DateTime_GetEndDST(*args, **kwargs)
def DateTime_Now(*args, **kwargs):
def DateTimeFromDMY(*args, **kwargs):
"""
- DateTimeFromDMY(int day, wxDateTime::Month month=Inv_Month, int year=Inv_Year,
- int hour=0, 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
"""
val = _misc.new_DateTimeFromDMY(*args, **kwargs)
val.thisown = 1
return _misc.TimeSpan_GetMilliseconds(*args, **kwargs)
def Format(*args, **kwargs):
- """Format(wxString format=wxPyTimeSpanFormatStr) -> wxString"""
+ """Format(String format=TimeSpanFormatStr) -> String"""
return _misc.TimeSpan_Format(*args, **kwargs)
def __repr__(self):
def __repr__(self):
return "<%s.%s; proxy of C++ wxDataFormat instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxDataFormatId type) -> DataFormat"""
+ """__init__(int type) -> DataFormat"""
newobj = _misc.new_DataFormat(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
def __eq__(*args):
"""
- __eq__(wxDataFormatId format) -> bool
+ __eq__(int format) -> bool
__eq__(DataFormat format) -> bool
"""
return _misc.DataFormat___eq__(*args)
def __ne__(*args):
"""
- __ne__(wxDataFormatId format) -> bool
+ __ne__(int format) -> bool
__ne__(DataFormat format) -> bool
"""
return _misc.DataFormat___ne__(*args)
def SetType(*args, **kwargs):
- """SetType(wxDataFormatId format)"""
+ """SetType(int format)"""
return _misc.DataFormat_SetType(*args, **kwargs)
def GetType(*args, **kwargs):
- """GetType() -> wxDataFormatId"""
+ """GetType() -> int"""
return _misc.DataFormat_GetType(*args, **kwargs)
def GetId(*args, **kwargs):
- """GetId() -> wxString"""
+ """GetId() -> String"""
return _misc.DataFormat_GetId(*args, **kwargs)
def SetId(*args, **kwargs):
- """SetId(wxString format)"""
+ """SetId(String format)"""
return _misc.DataFormat_SetId(*args, **kwargs)
_misc.DataFormat_swigregister(DataFormatPtr)
def CustomDataFormat(*args, **kwargs):
- """CustomDataFormat(wxString format) -> DataFormat"""
+ """CustomDataFormat(String format) -> DataFormat"""
val = _misc.new_CustomDataFormat(*args, **kwargs)
val.thisown = 1
return val
except: pass
def GetPreferredFormat(*args, **kwargs):
- """GetPreferredFormat(wxDataObject::Direction dir=Get) -> DataFormat"""
+ """GetPreferredFormat(int dir=Get) -> DataFormat"""
return _misc.DataObject_GetPreferredFormat(*args, **kwargs)
def GetFormatCount(*args, **kwargs):
- """GetFormatCount(wxDataObject::Direction dir=Get) -> size_t"""
+ """GetFormatCount(int dir=Get) -> size_t"""
return _misc.DataObject_GetFormatCount(*args, **kwargs)
def IsSupported(*args, **kwargs):
- """IsSupported(DataFormat format, wxDataObject::Direction dir=Get) -> bool"""
+ """IsSupported(DataFormat format, int dir=Get) -> bool"""
return _misc.DataObject_IsSupported(*args, **kwargs)
def GetDataSize(*args, **kwargs):
return _misc.DataObject_GetDataSize(*args, **kwargs)
def GetAllFormats(*args, **kwargs):
- """GetAllFormats(DataFormat formats, wxDataObject::Direction dir=Get)"""
+ """GetAllFormats(DataFormat formats, int dir=Get)"""
return _misc.DataObject_GetAllFormats(*args, **kwargs)
def GetDataHere(*args, **kwargs):
def __repr__(self):
return "<%s.%s; proxy of C++ wxTextDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString text=wxPyEmptyString) -> TextDataObject"""
+ """__init__(String text=EmptyString) -> TextDataObject"""
newobj = _misc.new_TextDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _misc.TextDataObject_GetTextLength(*args, **kwargs)
def GetText(*args, **kwargs):
- """GetText() -> wxString"""
+ """GetText() -> String"""
return _misc.TextDataObject_GetText(*args, **kwargs)
def SetText(*args, **kwargs):
- """SetText(wxString text)"""
+ """SetText(String text)"""
return _misc.TextDataObject_SetText(*args, **kwargs)
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyTextDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString text=wxPyEmptyString) -> PyTextDataObject"""
+ """__init__(String text=EmptyString) -> PyTextDataObject"""
newobj = _misc.new_PyTextDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
def __repr__(self):
return "<%s.%s; proxy of C++ wxBitmapDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxBitmap bitmap=wxNullBitmap) -> BitmapDataObject"""
+ """__init__(Bitmap bitmap=wxNullBitmap) -> BitmapDataObject"""
newobj = _misc.new_BitmapDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def GetBitmap(*args, **kwargs):
- """GetBitmap() -> wxBitmap"""
+ """GetBitmap() -> Bitmap"""
return _misc.BitmapDataObject_GetBitmap(*args, **kwargs)
def SetBitmap(*args, **kwargs):
- """SetBitmap(wxBitmap bitmap)"""
+ """SetBitmap(Bitmap bitmap)"""
return _misc.BitmapDataObject_SetBitmap(*args, **kwargs)
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyBitmapDataObject instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxBitmap bitmap=wxNullBitmap) -> PyBitmapDataObject"""
+ """__init__(Bitmap bitmap=wxNullBitmap) -> PyBitmapDataObject"""
newobj = _misc.new_PyBitmapDataObject(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _misc.FileDataObject_GetFilenames(*args, **kwargs)
def AddFile(*args, **kwargs):
- """AddFile(wxString filename)"""
+ """AddFile(String filename)"""
return _misc.FileDataObject_AddFile(*args, **kwargs)
self.thisown = 1
del newobj.thisown
def GetURL(*args, **kwargs):
- """GetURL() -> wxString"""
+ """GetURL() -> String"""
return _misc.URLDataObject_GetURL(*args, **kwargs)
def SetURL(*args, **kwargs):
- """SetURL(wxString url)"""
+ """SetURL(String url)"""
return _misc.URLDataObject_SetURL(*args, **kwargs)
DragCancel = _misc.DragCancel
def IsDragResultOk(*args, **kwargs):
- """IsDragResultOk(wxDragResult res) -> bool"""
+ """IsDragResultOk(int res) -> bool"""
return _misc.IsDragResultOk(*args, **kwargs)
class DropSource(object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyDropSource instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window win=None, wxCursor copy=wxNullCursor, wxCursor move=wxNullCursor,
- wxCursor none=wxNullCursor) -> DropSource
+ __init__(Window win=None, Cursor copy=wxNullCursor, Cursor move=wxNullCursor,
+ Cursor none=wxNullCursor) -> DropSource
"""
newobj = _misc.new_DropSource(*args, **kwargs)
self.this = newobj.this
return _misc.DropSource_GetDataObject(*args, **kwargs)
def SetCursor(*args, **kwargs):
- """SetCursor(wxDragResult res, wxCursor cursor)"""
+ """SetCursor(int res, Cursor cursor)"""
return _misc.DropSource_SetCursor(*args, **kwargs)
def DoDragDrop(*args, **kwargs):
- """DoDragDrop(int flags=Drag_CopyOnly) -> wxDragResult"""
+ """DoDragDrop(int flags=Drag_CopyOnly) -> int"""
return _misc.DropSource_DoDragDrop(*args, **kwargs)
def base_GiveFeedback(*args, **kwargs):
- """base_GiveFeedback(wxDragResult effect) -> bool"""
+ """base_GiveFeedback(int effect) -> bool"""
return _misc.DropSource_base_GiveFeedback(*args, **kwargs)
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyDropTarget instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(DataObject dataObject=None) -> DropTarget"""
- newobj = _misc.new_DropTarget(*args, **kwargs)
+ """PyDropTarget(DataObject dataObject=None) -> DropTarget"""
+ newobj = _misc.new_PyDropTarget(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
return val
def base_OnEnter(*args, **kwargs):
- """base_OnEnter(int x, int y, wxDragResult def) -> wxDragResult"""
+ """base_OnEnter(int x, int y, int def) -> int"""
return _misc.DropTarget_base_OnEnter(*args, **kwargs)
def base_OnDragOver(*args, **kwargs):
- """base_OnDragOver(int x, int y, wxDragResult def) -> wxDragResult"""
+ """base_OnDragOver(int x, int y, int def) -> int"""
return _misc.DropTarget_base_OnDragOver(*args, **kwargs)
def base_OnLeave(*args, **kwargs):
return _misc.TextDropTarget__setCallbackInfo(*args, **kwargs)
def base_OnEnter(*args, **kwargs):
- """base_OnEnter(int x, int y, wxDragResult def) -> wxDragResult"""
+ """base_OnEnter(int x, int y, int def) -> int"""
return _misc.TextDropTarget_base_OnEnter(*args, **kwargs)
def base_OnDragOver(*args, **kwargs):
- """base_OnDragOver(int x, int y, wxDragResult def) -> wxDragResult"""
+ """base_OnDragOver(int x, int y, int def) -> int"""
return _misc.TextDropTarget_base_OnDragOver(*args, **kwargs)
def base_OnLeave(*args, **kwargs):
return _misc.TextDropTarget_base_OnDrop(*args, **kwargs)
def base_OnData(*args, **kwargs):
- """base_OnData(int x, int y, wxDragResult def) -> wxDragResult"""
+ """base_OnData(int x, int y, int def) -> int"""
return _misc.TextDropTarget_base_OnData(*args, **kwargs)
return _misc.FileDropTarget__setCallbackInfo(*args, **kwargs)
def base_OnEnter(*args, **kwargs):
- """base_OnEnter(int x, int y, wxDragResult def) -> wxDragResult"""
+ """base_OnEnter(int x, int y, int def) -> int"""
return _misc.FileDropTarget_base_OnEnter(*args, **kwargs)
def base_OnDragOver(*args, **kwargs):
- """base_OnDragOver(int x, int y, wxDragResult def) -> wxDragResult"""
+ """base_OnDragOver(int x, int y, int def) -> int"""
return _misc.FileDropTarget_base_OnDragOver(*args, **kwargs)
def base_OnLeave(*args, **kwargs):
return _misc.FileDropTarget_base_OnDrop(*args, **kwargs)
def base_OnData(*args, **kwargs):
- """base_OnData(int x, int y, wxDragResult def) -> wxDragResult"""
+ """base_OnData(int x, int y, int def) -> int"""
return _misc.FileDropTarget_base_OnData(*args, **kwargs)
#include "wx/wxPython/pyclasses.h"
#include "wx/wxPython/pyistream.h"
- DECLARE_DEF_STRING(EmptyString);
-
-
+ static const wxString wxPyEmptyString(wxEmptyString);
- DECLARE_DEF_STRING(FileSelectorPromptStr);
- DECLARE_DEF_STRING(FileSelectorDefaultWildcardStr);
- DECLARE_DEF_STRING(DirSelectorPromptStr);
-
+ static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
+ static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
+ static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
static PyObject* t_output_helper(PyObject* target, PyObject* o) {
PyObject* o2;
#include <wx/datetime.h>
- DECLARE_DEF_STRING2(DateFormatStr, wxT("%c"));
- DECLARE_DEF_STRING2(TimeSpanFormatStr, wxT("%H:%M:%S"));
-
+ static const wxString wxPyDateFormatStr(wxT(wxT("%c")));
+ static const wxString wxPyTimeSpanFormatStr(wxT(wxT("%H:%M:%S")));
#define LOCAL_TZ wxDateTime::Local
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_FileSelectorPromptStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_FileSelectorPromptStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_FileSelectorDefaultWildcardStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_DirSelectorPromptStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_DirSelectorPromptStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_NewId(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
long result;
}
+static PyObject *_wrap_GetKeyState(PyObject *self, PyObject *args, PyObject *kwargs) {
+ PyObject *resultobj;
+ int arg1 ;
+ bool result;
+ char *kwnames[] = {
+ (char *) "key", NULL
+ };
+
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"i:GetKeyState",kwnames,&arg1)) goto fail;
+ {
+ PyThreadState* __tstate = wxPyBeginAllowThreads();
+ result = (bool)wxGetKeyState((wxKeyCode )arg1);
+
+ wxPyEndAllowThreads(__tstate);
+ if (PyErr_Occurred()) SWIG_fail;
+ }
+ resultobj = PyInt_FromLong((long)result);
+ return resultobj;
+ fail:
+ return NULL;
+}
+
+
static PyObject *_wrap_WakeUpMainThread(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
char *kwnames[] = {
}
+static int _wrap_DateFormatStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable DateFormatStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_DateFormatStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyDateFormatStr)->c_str(), (&wxPyDateFormatStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_TimeSpanFormatStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable TimeSpanFormatStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_TimeSpanFormatStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyTimeSpanFormatStr)->c_str(), (&wxPyTimeSpanFormatStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_DateTime_SetCountry(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
int arg1 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
-static PyObject *_wrap_new_DropTarget(PyObject *self, PyObject *args, PyObject *kwargs) {
+static PyObject *_wrap_new_PyDropTarget(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxDataObject *arg1 = (wxDataObject *) NULL ;
wxPyDropTarget *result;
(char *) "dataObject", NULL
};
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_DropTarget",kwnames,&obj0)) goto fail;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PyDropTarget",kwnames,&obj0)) goto fail;
if (obj0) {
if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxDataObject,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
}
{ (char *)"GenericFindWindowAtPoint", (PyCFunction) _wrap_GenericFindWindowAtPoint, METH_VARARGS | METH_KEYWORDS },
{ (char *)"FindWindowAtPoint", (PyCFunction) _wrap_FindWindowAtPoint, METH_VARARGS | METH_KEYWORDS },
{ (char *)"GetTopLevelParent", (PyCFunction) _wrap_GetTopLevelParent, METH_VARARGS | METH_KEYWORDS },
+ { (char *)"GetKeyState", (PyCFunction) _wrap_GetKeyState, METH_VARARGS | METH_KEYWORDS },
{ (char *)"WakeUpMainThread", (PyCFunction) _wrap_WakeUpMainThread, METH_VARARGS | METH_KEYWORDS },
{ (char *)"MutexGuiEnter", (PyCFunction) _wrap_MutexGuiEnter, METH_VARARGS | METH_KEYWORDS },
{ (char *)"MutexGuiLeave", (PyCFunction) _wrap_MutexGuiLeave, METH_VARARGS | METH_KEYWORDS },
{ (char *)"DropSource_DoDragDrop", (PyCFunction) _wrap_DropSource_DoDragDrop, METH_VARARGS | METH_KEYWORDS },
{ (char *)"DropSource_base_GiveFeedback", (PyCFunction) _wrap_DropSource_base_GiveFeedback, METH_VARARGS | METH_KEYWORDS },
{ (char *)"DropSource_swigregister", DropSource_swigregister, METH_VARARGS },
- { (char *)"new_DropTarget", (PyCFunction) _wrap_new_DropTarget, METH_VARARGS | METH_KEYWORDS },
+ { (char *)"new_PyDropTarget", (PyCFunction) _wrap_new_PyDropTarget, METH_VARARGS | METH_KEYWORDS },
{ (char *)"DropTarget__setCallbackInfo", (PyCFunction) _wrap_DropTarget__setCallbackInfo, METH_VARARGS | METH_KEYWORDS },
{ (char *)"delete_DropTarget", (PyCFunction) _wrap_delete_DropTarget, METH_VARARGS | METH_KEYWORDS },
{ (char *)"DropTarget_GetDataObject", (PyCFunction) _wrap_DropTarget_GetDataObject, METH_VARARGS | METH_KEYWORDS },
}
SWIG_InstallConstants(d,swig_const_table);
+ PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
+ SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
PyDict_SetItemString(d, "wxEVT_TIMER", PyInt_FromLong(wxEVT_TIMER));
PyDict_SetItemString(d, "wxEVT_END_PROCESS", PyInt_FromLong(wxEVT_END_PROCESS));
PyDict_SetItemString(d, "wxEVT_JOY_BUTTON_UP", PyInt_FromLong(wxEVT_JOY_BUTTON_UP));
PyDict_SetItemString(d, "wxEVT_JOY_MOVE", PyInt_FromLong(wxEVT_JOY_MOVE));
PyDict_SetItemString(d, "wxEVT_JOY_ZMOVE", PyInt_FromLong(wxEVT_JOY_ZMOVE));
- PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
SWIG_addvarlink(SWIG_globals,(char*)"TheMimeTypesManager",_wrap_TheMimeTypesManager_get, _wrap_TheMimeTypesManager_set);
SWIG_addvarlink(SWIG_globals,(char*)"ART_TOOLBAR",_wrap_ART_TOOLBAR_get, _wrap_ART_TOOLBAR_set);
SWIG_addvarlink(SWIG_globals,(char*)"ART_MENU",_wrap_ART_MENU_get, _wrap_ART_MENU_set);
wxPyPtrTypeMap_Add("wxArtProvider", "wxPyArtProvider");
+ SWIG_addvarlink(SWIG_globals,(char*)"DateFormatStr",_wrap_DateFormatStr_get, _wrap_DateFormatStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"TimeSpanFormatStr",_wrap_TimeSpanFormatStr_get, _wrap_TimeSpanFormatStr_set);
SWIG_addvarlink(SWIG_globals,(char*)"FormatInvalid",_wrap_FormatInvalid_get, _wrap_FormatInvalid_set);
wxPyPtrTypeMap_Add("wxDropSource", "wxPyDropSource");
"""
__init__(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=wxTAB_TRAVERSAL|wxNO_BORDER,
- wxString name=PanelNameStr) -> Panel
+ String name=PanelNameStr) -> Panel
"""
newobj = _windows.new_Panel(*args, **kwargs)
self.this = newobj.this
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxTAB_TRAVERSAL|wxNO_BORDER,
- wxString name=PanelNameStr) -> bool
+ String name=PanelNameStr) -> bool
"""
return _windows.Panel_Create(*args, **kwargs)
"""
__init__(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=wxHSCROLL|wxVSCROLL,
- wxString name=PanelNameStr) -> ScrolledWindow
+ String name=PanelNameStr) -> ScrolledWindow
"""
newobj = _windows.new_ScrolledWindow(*args, **kwargs)
self.this = newobj.this
"""
Create(Window parent, int id=-1, Point pos=DefaultPosition,
Size size=DefaultSize, long style=wxHSCROLL|wxVSCROLL,
- wxString name=PanelNameStr) -> bool
+ String name=PanelNameStr) -> bool
"""
return _windows.ScrolledWindow_Create(*args, **kwargs)
return _windows.TopLevelWindow_IsIconized(*args, **kwargs)
def GetIcon(*args, **kwargs):
- """GetIcon() -> wxIcon"""
+ """GetIcon() -> Icon"""
return _windows.TopLevelWindow_GetIcon(*args, **kwargs)
def SetIcon(*args, **kwargs):
- """SetIcon(wxIcon icon)"""
+ """SetIcon(Icon icon)"""
return _windows.TopLevelWindow_SetIcon(*args, **kwargs)
def SetIcons(*args, **kwargs):
return _windows.TopLevelWindow_IsFullScreen(*args, **kwargs)
def SetTitle(*args, **kwargs):
- """SetTitle(wxString title)"""
+ """SetTitle(String title)"""
return _windows.TopLevelWindow_SetTitle(*args, **kwargs)
def GetTitle(*args, **kwargs):
- """GetTitle() -> wxString"""
+ """GetTitle() -> String"""
return _windows.TopLevelWindow_GetTitle(*args, **kwargs)
def SetShape(*args, **kwargs):
- """SetShape(wxRegion region) -> bool"""
+ """SetShape(Region region) -> bool"""
return _windows.TopLevelWindow_SetShape(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = TopLevelWindow
_windows.TopLevelWindow_swigregister(TopLevelWindowPtr)
+cvar = _windows.cvar
+FrameNameStr = cvar.FrameNameStr
+DialogNameStr = cvar.DialogNameStr
+StatusLineNameStr = cvar.StatusLineNameStr
+ToolBarNameStr = cvar.ToolBarNameStr
#---------------------------------------------------------------------------
return "<%s.%s; proxy of C++ wxFrame instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString title, Point pos=DefaultPosition,
+ __init__(Window parent, int id, String title, Point pos=DefaultPosition,
Size size=DefaultSize, long style=DEFAULT_FRAME_STYLE,
- wxString name=wxPyFrameNameStr) -> Frame
+ String name=FrameNameStr) -> Frame
"""
newobj = _windows.new_Frame(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxString title, Point pos=DefaultPosition,
+ Create(Window parent, int id, String title, Point pos=DefaultPosition,
Size size=DefaultSize, long style=DEFAULT_FRAME_STYLE,
- wxString name=wxPyFrameNameStr) -> bool
+ String name=FrameNameStr) -> bool
"""
return _windows.Frame_Create(*args, **kwargs)
def CreateStatusBar(*args, **kwargs):
"""
CreateStatusBar(int number=1, long style=ST_SIZEGRIP, int winid=0,
- wxString name=wxPyStatusLineNameStr) -> StatusBar
+ String name=StatusLineNameStr) -> StatusBar
"""
return _windows.Frame_CreateStatusBar(*args, **kwargs)
return _windows.Frame_SetStatusBar(*args, **kwargs)
def SetStatusText(*args, **kwargs):
- """SetStatusText(wxString text, int number=0)"""
+ """SetStatusText(String text, int number=0)"""
return _windows.Frame_SetStatusText(*args, **kwargs)
def SetStatusWidths(*args, **kwargs):
return _windows.Frame_SetStatusWidths(*args, **kwargs)
def PushStatusText(*args, **kwargs):
- """PushStatusText(wxString text, int number=0)"""
+ """PushStatusText(String text, int number=0)"""
return _windows.Frame_PushStatusText(*args, **kwargs)
def PopStatusText(*args, **kwargs):
return _windows.Frame_GetStatusBarPane(*args, **kwargs)
def CreateToolBar(*args, **kwargs):
- """CreateToolBar(long style=-1, int winid=-1, wxString name=wxPyToolBarNameStr) -> wxToolBar"""
+ """CreateToolBar(long style=-1, int winid=-1, String name=ToolBarNameStr) -> wxToolBar"""
return _windows.Frame_CreateToolBar(*args, **kwargs)
def GetToolBar(*args, **kwargs):
return _windows.Frame_SetToolBar(*args, **kwargs)
def DoGiveHelp(*args, **kwargs):
- """DoGiveHelp(wxString text, bool show)"""
+ """DoGiveHelp(String text, bool show)"""
return _windows.Frame_DoGiveHelp(*args, **kwargs)
def DoMenuUpdates(*args, **kwargs):
return "<%s.%s; proxy of C++ wxDialog instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString title, Point pos=DefaultPosition,
+ __init__(Window parent, int id, String title, Point pos=DefaultPosition,
Size size=DefaultSize, long style=DEFAULT_DIALOG_STYLE,
- wxString name=wxPyDialogNameStr) -> Dialog
+ String name=DialogNameStr) -> Dialog
"""
newobj = _windows.new_Dialog(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxString title, Point pos=DefaultPosition,
+ Create(Window parent, int id, String title, Point pos=DefaultPosition,
Size size=DefaultSize, long style=DEFAULT_DIALOG_STYLE,
- wxString name=wxPyDialogNameStr) -> bool
+ String name=DialogNameStr) -> bool
"""
return _windows.Dialog_Create(*args, **kwargs)
return _windows.Dialog_GetReturnCode(*args, **kwargs)
def CreateTextSizer(*args, **kwargs):
- """CreateTextSizer(wxString message) -> Sizer"""
+ """CreateTextSizer(String message) -> Sizer"""
return _windows.Dialog_CreateTextSizer(*args, **kwargs)
def CreateButtonSizer(*args, **kwargs):
return "<%s.%s; proxy of C++ wxMiniFrame instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString title, Point pos=DefaultPosition,
+ __init__(Window parent, int id, String title, Point pos=DefaultPosition,
Size size=DefaultSize, long style=DEFAULT_FRAME_STYLE,
- wxString name=wxPyFrameNameStr) -> MiniFrame
+ String name=FrameNameStr) -> MiniFrame
"""
newobj = _windows.new_MiniFrame(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxString title, Point pos=DefaultPosition,
+ Create(Window parent, int id, String title, Point pos=DefaultPosition,
Size size=DefaultSize, long style=DEFAULT_FRAME_STYLE,
- wxString name=wxPyFrameNameStr) -> bool
+ String name=FrameNameStr) -> bool
"""
return _windows.MiniFrame_Create(*args, **kwargs)
return "<%s.%s; proxy of C++ wxSplashScreenWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(wxBitmap bitmap, Window parent, int id, Point pos=DefaultPosition,
+ __init__(Bitmap bitmap, Window parent, int id, Point pos=DefaultPosition,
Size size=DefaultSize, long style=NO_BORDER) -> SplashScreenWindow
"""
newobj = _windows.new_SplashScreenWindow(*args, **kwargs)
self._setOORInfo(self)
def SetBitmap(*args, **kwargs):
- """SetBitmap(wxBitmap bitmap)"""
+ """SetBitmap(Bitmap bitmap)"""
return _windows.SplashScreenWindow_SetBitmap(*args, **kwargs)
def GetBitmap(*args, **kwargs):
- """GetBitmap() -> wxBitmap"""
+ """GetBitmap() -> Bitmap"""
return _windows.SplashScreenWindow_GetBitmap(*args, **kwargs)
return "<%s.%s; proxy of C++ wxSplashScreen instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(wxBitmap bitmap, long splashStyle, int milliseconds,
+ __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
"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxStatusBar instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(Window parent, int id=-1, long style=ST_SIZEGRIP, wxString name=wxPyStatusLineNameStr) -> StatusBar"""
+ """__init__(Window parent, int id=-1, long style=ST_SIZEGRIP, String name=StatusLineNameStr) -> StatusBar"""
newobj = _windows.new_StatusBar(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
self._setOORInfo(self)
def Create(*args, **kwargs):
- """Create(Window parent, int id, long style=ST_SIZEGRIP, wxString name=wxPyStatusLineNameStr) -> bool"""
+ """Create(Window parent, int id, long style=ST_SIZEGRIP, String name=StatusLineNameStr) -> bool"""
return _windows.StatusBar_Create(*args, **kwargs)
def SetFieldsCount(*args, **kwargs):
return _windows.StatusBar_GetFieldsCount(*args, **kwargs)
def SetStatusText(*args, **kwargs):
- """SetStatusText(wxString text, int number=0)"""
+ """SetStatusText(String text, int number=0)"""
return _windows.StatusBar_SetStatusText(*args, **kwargs)
def GetStatusText(*args, **kwargs):
- """GetStatusText(int number=0) -> wxString"""
+ """GetStatusText(int number=0) -> String"""
return _windows.StatusBar_GetStatusText(*args, **kwargs)
def PushStatusText(*args, **kwargs):
- """PushStatusText(wxString text, int number=0)"""
+ """PushStatusText(String text, int number=0)"""
return _windows.StatusBar_PushStatusText(*args, **kwargs)
def PopStatusText(*args, **kwargs):
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id, Point point=DefaultPosition,
- Size size=DefaultSize, long style=SP_3D, wxString name=wxPySplitterNameStr) -> SplitterWindow
+ Size size=DefaultSize, long style=SP_3D, String name=SplitterNameStr) -> SplitterWindow
"""
newobj = _windows.new_SplitterWindow(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
Create(Window parent, int id, Point point=DefaultPosition,
- Size size=DefaultSize, long style=SP_3D, wxString name=wxPySplitterNameStr) -> bool
+ Size size=DefaultSize, long style=SP_3D, String name=SplitterNameStr) -> bool
"""
return _windows.SplitterWindow_Create(*args, **kwargs)
return _windows.SplitterWindow_SetSplitMode(*args, **kwargs)
def GetSplitMode(*args, **kwargs):
- """GetSplitMode() -> wxSplitMode"""
+ """GetSplitMode() -> int"""
return _windows.SplitterWindow_GetSplitMode(*args, **kwargs)
def Initialize(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = SplitterWindow
_windows.SplitterWindow_swigregister(SplitterWindowPtr)
+SplitterNameStr = cvar.SplitterNameStr
def PreSplitterWindow(*args, **kwargs):
"""PreSplitterWindow() -> SplitterWindow"""
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxCLIP_CHILDREN|wxSW_3D,
- wxString name=wxPySashNameStr) -> SashWindow
+ String name=SashNameStr) -> SashWindow
"""
newobj = _windows.new_SashWindow(*args, **kwargs)
self.this = newobj.this
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxCLIP_CHILDREN|wxSW_3D,
- wxString name=wxPySashNameStr) -> bool
+ String name=SashNameStr) -> bool
"""
return _windows.SashWindow_Create(*args, **kwargs)
def SetSashVisible(*args, **kwargs):
- """SetSashVisible(wxSashEdgePosition edge, bool sash)"""
+ """SetSashVisible(int edge, bool sash)"""
return _windows.SashWindow_SetSashVisible(*args, **kwargs)
def GetSashVisible(*args, **kwargs):
- """GetSashVisible(wxSashEdgePosition edge) -> bool"""
+ """GetSashVisible(int edge) -> bool"""
return _windows.SashWindow_GetSashVisible(*args, **kwargs)
def SetSashBorder(*args, **kwargs):
- """SetSashBorder(wxSashEdgePosition edge, bool border)"""
+ """SetSashBorder(int edge, bool border)"""
return _windows.SashWindow_SetSashBorder(*args, **kwargs)
def HasBorder(*args, **kwargs):
- """HasBorder(wxSashEdgePosition edge) -> bool"""
+ """HasBorder(int edge) -> bool"""
return _windows.SashWindow_HasBorder(*args, **kwargs)
def GetEdgeMargin(*args, **kwargs):
- """GetEdgeMargin(wxSashEdgePosition edge) -> int"""
+ """GetEdgeMargin(int edge) -> int"""
return _windows.SashWindow_GetEdgeMargin(*args, **kwargs)
def SetDefaultBorderSize(*args, **kwargs):
return _windows.SashWindow_GetMaximumSizeY(*args, **kwargs)
def SashHitTest(*args, **kwargs):
- """SashHitTest(int x, int y, int tolerance=2) -> wxSashEdgePosition"""
+ """SashHitTest(int x, int y, int tolerance=2) -> int"""
return _windows.SashWindow_SashHitTest(*args, **kwargs)
def SizeWindows(*args, **kwargs):
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = SashWindow
_windows.SashWindow_swigregister(SashWindowPtr)
+SashNameStr = cvar.SashNameStr
+SashLayoutNameStr = cvar.SashLayoutNameStr
def PreSashWindow(*args, **kwargs):
"""PreSashWindow() -> SashWindow"""
def __repr__(self):
return "<%s.%s; proxy of C++ wxSashEvent instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(int id=0, wxSashEdgePosition edge=SASH_NONE) -> SashEvent"""
+ """__init__(int id=0, int edge=SASH_NONE) -> SashEvent"""
newobj = _windows.new_SashEvent(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
del newobj.thisown
def SetEdge(*args, **kwargs):
- """SetEdge(wxSashEdgePosition edge)"""
+ """SetEdge(int edge)"""
return _windows.SashEvent_SetEdge(*args, **kwargs)
def GetEdge(*args, **kwargs):
- """GetEdge() -> wxSashEdgePosition"""
+ """GetEdge() -> int"""
return _windows.SashEvent_GetEdge(*args, **kwargs)
def SetDragRect(*args, **kwargs):
return _windows.SashEvent_GetDragRect(*args, **kwargs)
def SetDragStatus(*args, **kwargs):
- """SetDragStatus(wxSashDragStatus status)"""
+ """SetDragStatus(int status)"""
return _windows.SashEvent_SetDragStatus(*args, **kwargs)
def GetDragStatus(*args, **kwargs):
- """GetDragStatus() -> wxSashDragStatus"""
+ """GetDragStatus() -> int"""
return _windows.SashEvent_GetDragStatus(*args, **kwargs)
return _windows.QueryLayoutInfoEvent_GetSize(*args, **kwargs)
def SetOrientation(*args, **kwargs):
- """SetOrientation(wxLayoutOrientation orient)"""
+ """SetOrientation(int orient)"""
return _windows.QueryLayoutInfoEvent_SetOrientation(*args, **kwargs)
def GetOrientation(*args, **kwargs):
- """GetOrientation() -> wxLayoutOrientation"""
+ """GetOrientation() -> int"""
return _windows.QueryLayoutInfoEvent_GetOrientation(*args, **kwargs)
def SetAlignment(*args, **kwargs):
- """SetAlignment(wxLayoutAlignment align)"""
+ """SetAlignment(int align)"""
return _windows.QueryLayoutInfoEvent_SetAlignment(*args, **kwargs)
def GetAlignment(*args, **kwargs):
- """GetAlignment() -> wxLayoutAlignment"""
+ """GetAlignment() -> int"""
return _windows.QueryLayoutInfoEvent_GetAlignment(*args, **kwargs)
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxCLIP_CHILDREN|wxSW_3D,
- wxString name=wxPySashLayoutNameStr) -> SashLayoutWindow
+ String name=SashLayoutNameStr) -> SashLayoutWindow
"""
newobj = _windows.new_SashLayoutWindow(*args, **kwargs)
self.this = newobj.this
"""
Create(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
long style=wxCLIP_CHILDREN|wxSW_3D,
- wxString name=wxPySashLayoutNameStr) -> bool
+ String name=SashLayoutNameStr) -> bool
"""
return _windows.SashLayoutWindow_Create(*args, **kwargs)
def GetAlignment(*args, **kwargs):
- """GetAlignment() -> wxLayoutAlignment"""
+ """GetAlignment() -> int"""
return _windows.SashLayoutWindow_GetAlignment(*args, **kwargs)
def GetOrientation(*args, **kwargs):
- """GetOrientation() -> wxLayoutOrientation"""
+ """GetOrientation() -> int"""
return _windows.SashLayoutWindow_GetOrientation(*args, **kwargs)
def SetAlignment(*args, **kwargs):
- """SetAlignment(wxLayoutAlignment alignment)"""
+ """SetAlignment(int alignment)"""
return _windows.SashLayoutWindow_SetAlignment(*args, **kwargs)
def SetDefaultSize(*args, **kwargs):
return _windows.SashLayoutWindow_SetDefaultSize(*args, **kwargs)
def SetOrientation(*args, **kwargs):
- """SetOrientation(wxLayoutOrientation orientation)"""
+ """SetOrientation(int orientation)"""
return _windows.SashLayoutWindow_SetOrientation(*args, **kwargs)
def __repr__(self):
return "<%s.%s; proxy of C++ wxTipWindow instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(Window parent, wxString text, int maxLength=100, Rect rectBound=None) -> TipWindow"""
+ """__init__(Window parent, String text, int maxLength=100, Rect rectBound=None) -> TipWindow"""
newobj = _windows.new_TipWindow(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id=ID_ANY, Point pos=DefaultPosition,
- Size size=DefaultSize, long style=0, wxString name=PanelNameStr) -> VScrolledWindow
+ Size size=DefaultSize, long style=0, String name=PanelNameStr) -> VScrolledWindow
"""
newobj = _windows.new_VScrolledWindow(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
Create(Window parent, int id=ID_ANY, Point pos=DefaultPosition,
- Size size=DefaultSize, long style=0, wxString name=PanelNameStr) -> bool
+ Size size=DefaultSize, long style=0, String name=PanelNameStr) -> bool
"""
return _windows.VScrolledWindow_Create(*args, **kwargs)
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id=ID_ANY, Point pos=DefaultPosition,
- Size size=DefaultSize, long style=0, wxString name=wxPyVListBoxNameStr) -> VListBox
+ Size size=DefaultSize, long style=0, String name=VListBoxNameStr) -> VListBox
"""
newobj = _windows.new_VListBox(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
Create(Window parent, int id=ID_ANY, Point pos=DefaultPosition,
- Size size=DefaultSize, long style=0, wxString name=wxPyVListBoxNameStr) -> bool
+ Size size=DefaultSize, long style=0, String name=VListBoxNameStr) -> bool
"""
return _windows.VListBox_Create(*args, **kwargs)
return _windows.VListBox_GetMargins(*args, **kwargs)
def GetSelectionBackground(*args, **kwargs):
- """GetSelectionBackground() -> wxColour"""
+ """GetSelectionBackground() -> Colour"""
return _windows.VListBox_GetSelectionBackground(*args, **kwargs)
def SetItemCount(*args, **kwargs):
return _windows.VListBox_SetMarginsXY(*args, **kwargs)
def SetSelectionBackground(*args, **kwargs):
- """SetSelectionBackground(wxColour col)"""
+ """SetSelectionBackground(Colour col)"""
return _windows.VListBox_SetSelectionBackground(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = VListBox
_windows.VListBox_swigregister(VListBoxPtr)
+VListBoxNameStr = cvar.VListBoxNameStr
def PreVListBox(*args, **kwargs):
"""PreVListBox() -> VListBox"""
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id=ID_ANY, Point pos=DefaultPosition,
- Size size=DefaultSize, long style=0, wxString name=wxPyVListBoxNameStr) -> HtmlListBox
+ Size size=DefaultSize, long style=0, String name=VListBoxNameStr) -> HtmlListBox
"""
newobj = _windows.new_HtmlListBox(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
Create(Window parent, int id=ID_ANY, Point pos=DefaultPosition,
- Size size=DefaultSize, long style=0, wxString name=wxPyVListBoxNameStr) -> bool
+ Size size=DefaultSize, long style=0, String name=VListBoxNameStr) -> bool
"""
return _windows.HtmlListBox_Create(*args, **kwargs)
return _windows.TaskBarIcon_IsIconInstalled(*args, **kwargs)
def SetIcon(*args, **kwargs):
- """SetIcon(wxIcon icon, wxString tooltip=wxPyEmptyString) -> bool"""
+ """SetIcon(Icon icon, String tooltip=EmptyString) -> bool"""
return _windows.TaskBarIcon_SetIcon(*args, **kwargs)
def RemoveIcon(*args, **kwargs):
return _windows.ColourData_GetChooseFull(*args, **kwargs)
def GetColour(*args, **kwargs):
- """GetColour() -> wxColour"""
+ """GetColour() -> Colour"""
return _windows.ColourData_GetColour(*args, **kwargs)
def GetCustomColour(*args, **kwargs):
- """GetCustomColour(int i) -> wxColour"""
+ """GetCustomColour(int i) -> Colour"""
return _windows.ColourData_GetCustomColour(*args, **kwargs)
def SetChooseFull(*args, **kwargs):
return _windows.ColourData_SetChooseFull(*args, **kwargs)
def SetColour(*args, **kwargs):
- """SetColour(wxColour colour)"""
+ """SetColour(Colour colour)"""
return _windows.ColourData_SetColour(*args, **kwargs)
def SetCustomColour(*args, **kwargs):
- """SetCustomColour(int i, wxColour colour)"""
+ """SetCustomColour(int i, Colour colour)"""
return _windows.ColourData_SetCustomColour(*args, **kwargs)
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = ColourData
_windows.ColourData_swigregister(ColourDataPtr)
+FileSelectorPromptStr = cvar.FileSelectorPromptStr
+DirSelectorPromptStr = cvar.DirSelectorPromptStr
+DirDialogNameStr = cvar.DirDialogNameStr
+FileSelectorDefaultWildcardStr = cvar.FileSelectorDefaultWildcardStr
+GetTextFromUserPromptStr = cvar.GetTextFromUserPromptStr
+MessageBoxCaptionStr = cvar.MessageBoxCaptionStr
class ColourDialog(Dialog):
def __repr__(self):
return "<%s.%s; proxy of C++ wxDirDialog instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, wxString message=wxPyDirSelectorPromptStr,
- wxString defaultPath=wxPyEmptyString,
- long style=0, Point pos=DefaultPosition, Size size=DefaultSize,
- wxString name=wxPyDirDialogNameStr) -> DirDialog
+ __init__(Window parent, String message=DirSelectorPromptStr,
+ String defaultPath=EmptyString, long style=0,
+ Point pos=DefaultPosition, Size size=DefaultSize,
+ String name=DirDialogNameStr) -> DirDialog
"""
newobj = _windows.new_DirDialog(*args, **kwargs)
self.this = newobj.this
self._setOORInfo(self)
def GetPath(*args, **kwargs):
- """GetPath() -> wxString"""
+ """GetPath() -> String"""
return _windows.DirDialog_GetPath(*args, **kwargs)
def GetMessage(*args, **kwargs):
- """GetMessage() -> wxString"""
+ """GetMessage() -> String"""
return _windows.DirDialog_GetMessage(*args, **kwargs)
def GetStyle(*args, **kwargs):
return _windows.DirDialog_GetStyle(*args, **kwargs)
def SetMessage(*args, **kwargs):
- """SetMessage(wxString message)"""
+ """SetMessage(String message)"""
return _windows.DirDialog_SetMessage(*args, **kwargs)
def SetPath(*args, **kwargs):
- """SetPath(wxString path)"""
+ """SetPath(String path)"""
return _windows.DirDialog_SetPath(*args, **kwargs)
def ShowModal(*args, **kwargs):
return "<%s.%s; proxy of C++ wxFileDialog instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, wxString message=wxPyFileSelectorPromptStr,
- wxString defaultDir=wxPyEmptyString,
- wxString defaultFile=wxPyEmptyString, wxString wildcard=wxPyFileSelectorDefaultWildcardStr,
- long style=0,
- Point pos=DefaultPosition) -> FileDialog
+ __init__(Window parent, String message=FileSelectorPromptStr,
+ String defaultDir=EmptyString, String defaultFile=EmptyString,
+ String wildcard=FileSelectorDefaultWildcardStr,
+ long style=0, Point pos=DefaultPosition) -> FileDialog
"""
newobj = _windows.new_FileDialog(*args, **kwargs)
self.this = newobj.this
self._setOORInfo(self)
def SetMessage(*args, **kwargs):
- """SetMessage(wxString message)"""
+ """SetMessage(String message)"""
return _windows.FileDialog_SetMessage(*args, **kwargs)
def SetPath(*args, **kwargs):
- """SetPath(wxString path)"""
+ """SetPath(String path)"""
return _windows.FileDialog_SetPath(*args, **kwargs)
def SetDirectory(*args, **kwargs):
- """SetDirectory(wxString dir)"""
+ """SetDirectory(String dir)"""
return _windows.FileDialog_SetDirectory(*args, **kwargs)
def SetFilename(*args, **kwargs):
- """SetFilename(wxString name)"""
+ """SetFilename(String name)"""
return _windows.FileDialog_SetFilename(*args, **kwargs)
def SetWildcard(*args, **kwargs):
- """SetWildcard(wxString wildCard)"""
+ """SetWildcard(String wildCard)"""
return _windows.FileDialog_SetWildcard(*args, **kwargs)
def SetStyle(*args, **kwargs):
return _windows.FileDialog_SetFilterIndex(*args, **kwargs)
def GetMessage(*args, **kwargs):
- """GetMessage() -> wxString"""
+ """GetMessage() -> String"""
return _windows.FileDialog_GetMessage(*args, **kwargs)
def GetPath(*args, **kwargs):
- """GetPath() -> wxString"""
+ """GetPath() -> String"""
return _windows.FileDialog_GetPath(*args, **kwargs)
def GetDirectory(*args, **kwargs):
- """GetDirectory() -> wxString"""
+ """GetDirectory() -> String"""
return _windows.FileDialog_GetDirectory(*args, **kwargs)
def GetFilename(*args, **kwargs):
- """GetFilename() -> wxString"""
+ """GetFilename() -> String"""
return _windows.FileDialog_GetFilename(*args, **kwargs)
def GetWildcard(*args, **kwargs):
- """GetWildcard() -> wxString"""
+ """GetWildcard() -> String"""
return _windows.FileDialog_GetWildcard(*args, **kwargs)
def GetStyle(*args, **kwargs):
return "<%s.%s; proxy of C++ wxMultiChoiceDialog instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, wxString message, wxString caption,
- int LCOUNT, wxString choices, long style=CHOICEDLG_STYLE,
+ __init__(Window parent, String message, String caption, int LCOUNT,
+ String choices, long style=CHOICEDLG_STYLE,
Point pos=DefaultPosition) -> MultiChoiceDialog
"""
newobj = _windows.new_MultiChoiceDialog(*args, **kwargs)
return "<%s.%s; proxy of C++ wxSingleChoiceDialog instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, wxString message, wxString caption,
- int choices, wxString choices_array, long style=CHOICEDLG_STYLE,
+ __init__(Window parent, String message, String caption, int choices,
+ String choices_array, long style=CHOICEDLG_STYLE,
Point pos=DefaultPosition) -> SingleChoiceDialog
"""
newobj = _windows.new_SingleChoiceDialog(*args, **kwargs)
return _windows.SingleChoiceDialog_GetSelection(*args, **kwargs)
def GetStringSelection(*args, **kwargs):
- """GetStringSelection() -> wxString"""
+ """GetStringSelection() -> String"""
return _windows.SingleChoiceDialog_GetStringSelection(*args, **kwargs)
def SetSelection(*args, **kwargs):
return "<%s.%s; proxy of C++ wxTextEntryDialog instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, wxString message, wxString caption=wxPyGetTextFromUserPromptStr,
- wxString defaultValue=wxPyEmptyString,
- long style=wxOK|wxCANCEL|wxCENTRE,
- Point pos=DefaultPosition) -> TextEntryDialog
+ __init__(Window parent, String message, String caption=GetTextFromUserPromptStr,
+ String defaultValue=EmptyString,
+ long style=wxOK|wxCANCEL|wxCENTRE, Point pos=DefaultPosition) -> TextEntryDialog
"""
newobj = _windows.new_TextEntryDialog(*args, **kwargs)
self.this = newobj.this
self._setOORInfo(self)
def GetValue(*args, **kwargs):
- """GetValue() -> wxString"""
+ """GetValue() -> String"""
return _windows.TextEntryDialog_GetValue(*args, **kwargs)
def SetValue(*args, **kwargs):
- """SetValue(wxString value)"""
+ """SetValue(String value)"""
return _windows.TextEntryDialog_SetValue(*args, **kwargs)
def ShowModal(*args, **kwargs):
return _windows.FontData_GetAllowSymbols(*args, **kwargs)
def GetColour(*args, **kwargs):
- """GetColour() -> wxColour"""
+ """GetColour() -> Colour"""
return _windows.FontData_GetColour(*args, **kwargs)
def GetChosenFont(*args, **kwargs):
- """GetChosenFont() -> wxFont"""
+ """GetChosenFont() -> Font"""
return _windows.FontData_GetChosenFont(*args, **kwargs)
def GetEnableEffects(*args, **kwargs):
return _windows.FontData_GetEnableEffects(*args, **kwargs)
def GetInitialFont(*args, **kwargs):
- """GetInitialFont() -> wxFont"""
+ """GetInitialFont() -> Font"""
return _windows.FontData_GetInitialFont(*args, **kwargs)
def GetShowHelp(*args, **kwargs):
return _windows.FontData_SetAllowSymbols(*args, **kwargs)
def SetChosenFont(*args, **kwargs):
- """SetChosenFont(wxFont font)"""
+ """SetChosenFont(Font font)"""
return _windows.FontData_SetChosenFont(*args, **kwargs)
def SetColour(*args, **kwargs):
- """SetColour(wxColour colour)"""
+ """SetColour(Colour colour)"""
return _windows.FontData_SetColour(*args, **kwargs)
def SetInitialFont(*args, **kwargs):
- """SetInitialFont(wxFont font)"""
+ """SetInitialFont(Font font)"""
return _windows.FontData_SetInitialFont(*args, **kwargs)
def SetRange(*args, **kwargs):
return "<%s.%s; proxy of C++ wxMessageDialog instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, wxString message, wxString caption=wxPyMessageBoxCaptionStr,
+ __init__(Window parent, String message, String caption=MessageBoxCaptionStr,
long style=wxOK|wxCANCEL|wxCENTRE,
Point pos=DefaultPosition) -> MessageDialog
"""
return "<%s.%s; proxy of C++ wxProgressDialog instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(wxString title, wxString message, int maximum=100,
- Window parent=None, int style=wxPD_AUTO_HIDE|wxPD_APP_MODAL) -> ProgressDialog
+ __init__(String title, String message, int maximum=100, Window parent=None,
+ int style=wxPD_AUTO_HIDE|wxPD_APP_MODAL) -> ProgressDialog
"""
newobj = _windows.new_ProgressDialog(*args, **kwargs)
self.this = newobj.this
self._setOORInfo(self)
def Update(*args, **kwargs):
- """Update(int value, wxString newmsg=wxPyEmptyString) -> bool"""
+ """Update(int value, String newmsg=EmptyString) -> bool"""
return _windows.ProgressDialog_Update(*args, **kwargs)
def Resume(*args, **kwargs):
return _windows.FindDialogEvent_GetFlags(*args, **kwargs)
def GetFindString(*args, **kwargs):
- """GetFindString() -> wxString"""
+ """GetFindString() -> String"""
return _windows.FindDialogEvent_GetFindString(*args, **kwargs)
def GetReplaceString(*args, **kwargs):
- """GetReplaceString() -> wxString"""
+ """GetReplaceString() -> String"""
return _windows.FindDialogEvent_GetReplaceString(*args, **kwargs)
def GetDialog(*args, **kwargs):
return _windows.FindDialogEvent_SetFlags(*args, **kwargs)
def SetFindString(*args, **kwargs):
- """SetFindString(wxString str)"""
+ """SetFindString(String str)"""
return _windows.FindDialogEvent_SetFindString(*args, **kwargs)
def SetReplaceString(*args, **kwargs):
- """SetReplaceString(wxString str)"""
+ """SetReplaceString(String str)"""
return _windows.FindDialogEvent_SetReplaceString(*args, **kwargs)
except: pass
def GetFindString(*args, **kwargs):
- """GetFindString() -> wxString"""
+ """GetFindString() -> String"""
return _windows.FindReplaceData_GetFindString(*args, **kwargs)
def GetReplaceString(*args, **kwargs):
- """GetReplaceString() -> wxString"""
+ """GetReplaceString() -> String"""
return _windows.FindReplaceData_GetReplaceString(*args, **kwargs)
def GetFlags(*args, **kwargs):
return _windows.FindReplaceData_SetFlags(*args, **kwargs)
def SetFindString(*args, **kwargs):
- """SetFindString(wxString str)"""
+ """SetFindString(String str)"""
return _windows.FindReplaceData_SetFindString(*args, **kwargs)
def SetReplaceString(*args, **kwargs):
- """SetReplaceString(wxString str)"""
+ """SetReplaceString(String str)"""
return _windows.FindReplaceData_SetReplaceString(*args, **kwargs)
return "<%s.%s; proxy of C++ wxFindReplaceDialog instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, FindReplaceData data, wxString title,
+ __init__(Window parent, FindReplaceData data, String title,
int style=0) -> FindReplaceDialog
"""
newobj = _windows.new_FindReplaceDialog(*args, **kwargs)
def Create(*args, **kwargs):
"""
- Create(Window parent, FindReplaceData data, wxString title,
+ Create(Window parent, FindReplaceData data, String title,
int style=0) -> bool
"""
return _windows.FindReplaceDialog_Create(*args, **kwargs)
return "<%s.%s; proxy of C++ wxMDIParentFrame instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id, wxString title, Point pos=DefaultPosition,
+ __init__(Window parent, int id, String title, Point pos=DefaultPosition,
Size size=DefaultSize, long style=wxDEFAULT_FRAME_STYLE|wxVSCROLL|wxHSCROLL,
- wxString name=wxPyFrameNameStr) -> MDIParentFrame
+ String name=FrameNameStr) -> MDIParentFrame
"""
newobj = _windows.new_MDIParentFrame(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(Window parent, int id, wxString title, Point pos=DefaultPosition,
+ Create(Window parent, int id, String title, Point pos=DefaultPosition,
Size size=DefaultSize, long style=wxDEFAULT_FRAME_STYLE|wxVSCROLL|wxHSCROLL,
- wxString name=wxPyFrameNameStr) -> bool
+ String name=FrameNameStr) -> bool
"""
return _windows.MDIParentFrame_Create(*args, **kwargs)
return "<%s.%s; proxy of C++ wxMDIChildFrame instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(MDIParentFrame parent, int id, wxString title, Point pos=DefaultPosition,
- Size size=DefaultSize,
- long style=DEFAULT_FRAME_STYLE, wxString name=wxPyFrameNameStr) -> MDIChildFrame
+ __init__(MDIParentFrame parent, int id, String title, Point pos=DefaultPosition,
+ Size size=DefaultSize, long style=DEFAULT_FRAME_STYLE,
+ String name=FrameNameStr) -> MDIChildFrame
"""
newobj = _windows.new_MDIChildFrame(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
- Create(MDIParentFrame parent, int id, wxString title, Point pos=DefaultPosition,
- Size size=DefaultSize,
- long style=DEFAULT_FRAME_STYLE, wxString name=wxPyFrameNameStr) -> bool
+ Create(MDIParentFrame parent, int id, String title, Point pos=DefaultPosition,
+ Size size=DefaultSize, long style=DEFAULT_FRAME_STYLE,
+ String name=FrameNameStr) -> bool
"""
return _windows.MDIChildFrame_Create(*args, **kwargs)
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- long style=0, wxString name=PanelNameStr) -> PyWindow
+ long style=0, String name=PanelNameStr) -> PyWindow
"""
newobj = _windows.new_PyWindow(*args, **kwargs)
self.this = newobj.this
def __init__(self, *args, **kwargs):
"""
__init__(Window parent, int id, Point pos=DefaultPosition, Size size=DefaultSize,
- long style=0, wxString name=PanelNameStr) -> PyPanel
+ long style=0, String name=PanelNameStr) -> PyPanel
"""
newobj = _windows.new_PyPanel(*args, **kwargs)
self.this = newobj.this
return _windows.PrintData_Ok(*args, **kwargs)
def GetPrinterName(*args, **kwargs):
- """GetPrinterName() -> wxString"""
+ """GetPrinterName() -> String"""
return _windows.PrintData_GetPrinterName(*args, **kwargs)
def GetColour(*args, **kwargs):
return _windows.PrintData_GetColour(*args, **kwargs)
def GetDuplex(*args, **kwargs):
- """GetDuplex() -> wxDuplexMode"""
+ """GetDuplex() -> int"""
return _windows.PrintData_GetDuplex(*args, **kwargs)
def GetPaperId(*args, **kwargs):
- """GetPaperId() -> wxPaperSize"""
+ """GetPaperId() -> int"""
return _windows.PrintData_GetPaperId(*args, **kwargs)
def GetPaperSize(*args, **kwargs):
return _windows.PrintData_GetPaperSize(*args, **kwargs)
def GetQuality(*args, **kwargs):
- """GetQuality() -> wxPrintQuality"""
+ """GetQuality() -> int"""
return _windows.PrintData_GetQuality(*args, **kwargs)
def SetNoCopies(*args, **kwargs):
return _windows.PrintData_SetOrientation(*args, **kwargs)
def SetPrinterName(*args, **kwargs):
- """SetPrinterName(wxString name)"""
+ """SetPrinterName(String name)"""
return _windows.PrintData_SetPrinterName(*args, **kwargs)
def SetColour(*args, **kwargs):
return _windows.PrintData_SetColour(*args, **kwargs)
def SetDuplex(*args, **kwargs):
- """SetDuplex(wxDuplexMode duplex)"""
+ """SetDuplex(int duplex)"""
return _windows.PrintData_SetDuplex(*args, **kwargs)
def SetPaperId(*args, **kwargs):
- """SetPaperId(wxPaperSize sizeId)"""
+ """SetPaperId(int sizeId)"""
return _windows.PrintData_SetPaperId(*args, **kwargs)
def SetPaperSize(*args, **kwargs):
return _windows.PrintData_SetPaperSize(*args, **kwargs)
def SetQuality(*args, **kwargs):
- """SetQuality(wxPrintQuality quality)"""
+ """SetQuality(int quality)"""
return _windows.PrintData_SetQuality(*args, **kwargs)
def GetPrinterCommand(*args, **kwargs):
- """GetPrinterCommand() -> wxString"""
+ """GetPrinterCommand() -> String"""
return _windows.PrintData_GetPrinterCommand(*args, **kwargs)
def GetPrinterOptions(*args, **kwargs):
- """GetPrinterOptions() -> wxString"""
+ """GetPrinterOptions() -> String"""
return _windows.PrintData_GetPrinterOptions(*args, **kwargs)
def GetPreviewCommand(*args, **kwargs):
- """GetPreviewCommand() -> wxString"""
+ """GetPreviewCommand() -> String"""
return _windows.PrintData_GetPreviewCommand(*args, **kwargs)
def GetFilename(*args, **kwargs):
- """GetFilename() -> wxString"""
+ """GetFilename() -> String"""
return _windows.PrintData_GetFilename(*args, **kwargs)
def GetFontMetricPath(*args, **kwargs):
- """GetFontMetricPath() -> wxString"""
+ """GetFontMetricPath() -> String"""
return _windows.PrintData_GetFontMetricPath(*args, **kwargs)
def GetPrinterScaleX(*args, **kwargs):
return _windows.PrintData_GetPrinterTranslateY(*args, **kwargs)
def GetPrintMode(*args, **kwargs):
- """GetPrintMode() -> wxPrintMode"""
+ """GetPrintMode() -> int"""
return _windows.PrintData_GetPrintMode(*args, **kwargs)
def SetPrinterCommand(*args, **kwargs):
- """SetPrinterCommand(wxString command)"""
+ """SetPrinterCommand(String command)"""
return _windows.PrintData_SetPrinterCommand(*args, **kwargs)
def SetPrinterOptions(*args, **kwargs):
- """SetPrinterOptions(wxString options)"""
+ """SetPrinterOptions(String options)"""
return _windows.PrintData_SetPrinterOptions(*args, **kwargs)
def SetPreviewCommand(*args, **kwargs):
- """SetPreviewCommand(wxString command)"""
+ """SetPreviewCommand(String command)"""
return _windows.PrintData_SetPreviewCommand(*args, **kwargs)
def SetFilename(*args, **kwargs):
- """SetFilename(wxString filename)"""
+ """SetFilename(String filename)"""
return _windows.PrintData_SetFilename(*args, **kwargs)
def SetFontMetricPath(*args, **kwargs):
- """SetFontMetricPath(wxString path)"""
+ """SetFontMetricPath(String path)"""
return _windows.PrintData_SetFontMetricPath(*args, **kwargs)
def SetPrinterScaleX(*args, **kwargs):
return _windows.PrintData_SetPrinterTranslation(*args, **kwargs)
def SetPrintMode(*args, **kwargs):
- """SetPrintMode(wxPrintMode printMode)"""
+ """SetPrintMode(int printMode)"""
return _windows.PrintData_SetPrintMode(*args, **kwargs)
def __nonzero__(self): return self.Ok()
if not hasattr(self,"thisown"): self.thisown = 0
self.__class__ = PrintData
_windows.PrintData_swigregister(PrintDataPtr)
+PrintoutTitleStr = cvar.PrintoutTitleStr
+PreviewCanvasNameStr = cvar.PreviewCanvasNameStr
class PageSetupDialogData(core.Object):
def __repr__(self):
return _windows.PageSetupDialogData_GetMinMarginBottomRight(*args, **kwargs)
def GetPaperId(*args, **kwargs):
- """GetPaperId() -> wxPaperSize"""
+ """GetPaperId() -> int"""
return _windows.PageSetupDialogData_GetPaperId(*args, **kwargs)
def GetPaperSize(*args, **kwargs):
return _windows.PageSetupDialogData_SetMinMarginBottomRight(*args, **kwargs)
def SetPaperId(*args, **kwargs):
- """SetPaperId(wxPaperSize id)"""
+ """SetPaperId(int id)"""
return _windows.PageSetupDialogData_SetPaperId(*args, **kwargs)
def SetPaperSize(*args, **kwargs):
return _windows.PrintDialog_GetPrintDialogData(*args, **kwargs)
def GetPrintDC(*args, **kwargs):
- """GetPrintDC() -> wxDC"""
+ """GetPrintDC() -> DC"""
return _windows.PrintDialog_GetPrintDC(*args, **kwargs)
def ShowModal(*args, **kwargs):
return _windows.Printer_Print(*args, **kwargs)
def PrintDialog(*args, **kwargs):
- """PrintDialog(Window parent) -> wxDC"""
+ """PrintDialog(Window parent) -> DC"""
return _windows.Printer_PrintDialog(*args, **kwargs)
def ReportError(*args, **kwargs):
- """ReportError(Window parent, Printout printout, wxString message)"""
+ """ReportError(Window parent, Printout printout, String message)"""
return _windows.Printer_ReportError(*args, **kwargs)
def Setup(*args, **kwargs):
return _windows.Printer_GetAbort(*args, **kwargs)
def GetLastError(*args, **kwargs):
- """Printer.GetLastError() -> wxPrinterError"""
+ """Printer.GetLastError() -> int"""
return _windows.Printer_GetLastError(*args, **kwargs)
GetLastError = staticmethod(GetLastError)
_windows.Printer_swigregister(PrinterPtr)
def Printer_GetLastError(*args, **kwargs):
- """Printer_GetLastError() -> wxPrinterError"""
+ """Printer_GetLastError() -> int"""
return _windows.Printer_GetLastError(*args, **kwargs)
class Printout(core.Object):
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyPrintout instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(wxString title=wxPyPrintoutTitleStr) -> Printout"""
+ """__init__(String title=PrintoutTitleStr) -> Printout"""
newobj = _windows.new_Printout(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
return _windows.Printout__setCallbackInfo(*args, **kwargs)
def GetTitle(*args, **kwargs):
- """GetTitle() -> wxString"""
+ """GetTitle() -> String"""
return _windows.Printout_GetTitle(*args, **kwargs)
def GetDC(*args, **kwargs):
- """GetDC() -> wxDC"""
+ """GetDC() -> DC"""
return _windows.Printout_GetDC(*args, **kwargs)
def SetDC(*args, **kwargs):
- """SetDC(wxDC dc)"""
+ """SetDC(DC dc)"""
return _windows.Printout_SetDC(*args, **kwargs)
def SetPageSizePixels(*args, **kwargs):
"""
__init__(PrintPreview preview, Window parent, Point pos=DefaultPosition,
Size size=DefaultSize, long style=0,
- wxString name=wxPyPreviewCanvasNameStr) -> PreviewCanvas
+ String name=PreviewCanvasNameStr) -> PreviewCanvas
"""
newobj = _windows.new_PreviewCanvas(*args, **kwargs)
self.this = newobj.this
return "<%s.%s; proxy of C++ wxPreviewFrame instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(PrintPreview preview, Frame parent, wxString title,
- Point pos=DefaultPosition, Size size=DefaultSize,
- long style=DEFAULT_FRAME_STYLE, wxString name=wxPyFrameNameStr) -> PreviewFrame
+ __init__(PrintPreview preview, Frame parent, String title, Point pos=DefaultPosition,
+ Size size=DefaultSize,
+ long style=DEFAULT_FRAME_STYLE, String name=FrameNameStr) -> PreviewFrame
"""
newobj = _windows.new_PreviewFrame(*args, **kwargs)
self.this = newobj.this
"""
__init__(PrintPreview preview, long buttons, Window parent,
Point pos=DefaultPosition, Size size=DefaultSize,
- long style=TAB_TRAVERSAL, wxString name=PanelNameStr) -> PreviewControlBar
+ long style=TAB_TRAVERSAL, String name=PanelNameStr) -> PreviewControlBar
"""
newobj = _windows.new_PreviewControlBar(*args, **kwargs)
self.this = newobj.this
return _windows.PrintPreview_GetCanvas(*args, **kwargs)
def PaintPage(*args, **kwargs):
- """PaintPage(PreviewCanvas canvas, wxDC dc) -> bool"""
+ """PaintPage(PreviewCanvas canvas, DC dc) -> bool"""
return _windows.PrintPreview_PaintPage(*args, **kwargs)
def DrawBlankPage(*args, **kwargs):
- """DrawBlankPage(PreviewCanvas canvas, wxDC dc) -> bool"""
+ """DrawBlankPage(PreviewCanvas canvas, DC dc) -> bool"""
return _windows.PrintPreview_DrawBlankPage(*args, **kwargs)
def RenderPage(*args, **kwargs):
return _windows.PyPrintPreview_base_SetCurrentPage(*args, **kwargs)
def base_PaintPage(*args, **kwargs):
- """base_PaintPage(PreviewCanvas canvas, wxDC dc) -> bool"""
+ """base_PaintPage(PreviewCanvas canvas, DC dc) -> bool"""
return _windows.PyPrintPreview_base_PaintPage(*args, **kwargs)
def base_DrawBlankPage(*args, **kwargs):
- """base_DrawBlankPage(PreviewCanvas canvas, wxDC dc) -> bool"""
+ """base_DrawBlankPage(PreviewCanvas canvas, DC dc) -> bool"""
return _windows.PyPrintPreview_base_DrawBlankPage(*args, **kwargs)
def base_RenderPage(*args, **kwargs):
return "<%s.%s; proxy of C++ wxPyPreviewFrame instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(PrintPreview preview, Frame parent, wxString title,
- Point pos=DefaultPosition, Size size=DefaultSize,
- long style=DEFAULT_FRAME_STYLE, wxString name=wxPyFrameNameStr) -> PyPreviewFrame
+ __init__(PrintPreview preview, Frame parent, String title, Point pos=DefaultPosition,
+ Size size=DefaultSize,
+ long style=DEFAULT_FRAME_STYLE, String name=FrameNameStr) -> PyPreviewFrame
"""
newobj = _windows.new_PyPreviewFrame(*args, **kwargs)
self.this = newobj.this
"""
__init__(PrintPreview preview, long buttons, Window parent,
Point pos=DefaultPosition, Size size=DefaultSize,
- long style=0, wxString name=PanelNameStr) -> PyPreviewControlBar
+ long style=0, String name=PanelNameStr) -> PyPreviewControlBar
"""
newobj = _windows.new_PyPreviewControlBar(*args, **kwargs)
self.this = newobj.this
#define SWIGTYPE_p_wxPrintDialog swig_types[73]
#define SWIGTYPE_p_wxBitmap swig_types[74]
#define SWIGTYPE_p_wxCommandEvent swig_types[75]
-#define SWIGTYPE_p_wxPrintQuality swig_types[76]
-#define SWIGTYPE_p_wxPreviewControlBar swig_types[77]
-#define SWIGTYPE_p_wxPyPreviewControlBar swig_types[78]
-#define SWIGTYPE_p_wxColour swig_types[79]
-#define SWIGTYPE_p_wxToolBar swig_types[80]
+#define SWIGTYPE_p_wxPreviewControlBar swig_types[76]
+#define SWIGTYPE_p_wxPyPreviewControlBar swig_types[77]
+#define SWIGTYPE_p_wxColour swig_types[78]
+#define SWIGTYPE_p_wxToolBar swig_types[79]
+#define SWIGTYPE_p_wxPrintDialogData swig_types[80]
#define SWIGTYPE_p_wxPageSetupDialogData swig_types[81]
-#define SWIGTYPE_p_wxPrintDialogData swig_types[82]
-static swig_type_info *swig_types[84];
+static swig_type_info *swig_types[83];
/* -------- TYPES TABLE (END) -------- */
#include "wx/wxPython/wxPython.h"
#include "wx/wxPython/pyclasses.h"
- DECLARE_DEF_STRING(PanelNameStr);
- DECLARE_DEF_STRING(EmptyString);
-
+ static const wxString wxPyEmptyString(wxEmptyString);
+ static const wxString wxPyPanelNameStr(wxPanelNameStr);
return target;
}
-
- // Put some wx default wxChar* values into wxStrings.
- DECLARE_DEF_STRING(FrameNameStr);
- DECLARE_DEF_STRING(DialogNameStr);
- DECLARE_DEF_STRING(StatusLineNameStr);
- DECLARE_DEF_STRING(ToolBarNameStr);
-
+ static const wxString wxPyFrameNameStr(wxFrameNameStr);
+ static const wxString wxPyDialogNameStr(wxDialogNameStr);
+ static const wxString wxPyStatusLineNameStr(wxStatusLineNameStr);
+ static const wxString wxPyToolBarNameStr(wxToolBarNameStr);
bool wxDialog_IsModalShowing(wxDialog *self){
self->GetFieldRect(i, r);
return r;
}
-
- static const wxChar* wxSplitterNameStr = wxT("splitter");
- DECLARE_DEF_STRING(SplitterNameStr);
-
-
- static const wxChar* wxSashNameStr = wxT("sashWindow");
- DECLARE_DEF_STRING(SashNameStr);
- static const wxChar* wxSashLayoutNameStr = wxT("layoutWindow");
- DECLARE_DEF_STRING(SashLayoutNameStr);
-
+ static const wxString wxPySplitterNameStr(wxT(wxT("splitter")));
+ static const wxString wxPySashNameStr(wxT(wxT("sashWindow")));
+ static const wxString wxPySashLayoutNameStr(wxT(wxT("layoutWindow")));
#include <wx/popupwin.h>
#include <wx/vlbox.h>
-DECLARE_DEF_STRING(VListBoxNameStr);
+ static const wxString wxPyVListBoxNameStr(wxVListBoxNameStr);
class wxPyVListBox : public wxVListBox
{
};
#endif
-
-
- DECLARE_DEF_STRING(FileSelectorPromptStr);
- DECLARE_DEF_STRING(DirSelectorPromptStr);
- DECLARE_DEF_STRING(DirDialogNameStr);
- DECLARE_DEF_STRING(FileSelectorDefaultWildcardStr);
- DECLARE_DEF_STRING(GetTextFromUserPromptStr);
- DECLARE_DEF_STRING(MessageBoxCaptionStr);
-
-
+ static const wxString wxPyFileSelectorPromptStr(wxFileSelectorPromptStr);
+ static const wxString wxPyDirSelectorPromptStr(wxDirSelectorPromptStr);
+ static const wxString wxPyDirDialogNameStr(wxDirDialogNameStr);
+ static const wxString wxPyFileSelectorDefaultWildcardStr(wxFileSelectorDefaultWildcardStr);
+ static const wxString wxPyGetTextFromUserPromptStr(wxGetTextFromUserPromptStr);
+ static const wxString wxPyMessageBoxCaptionStr(wxMessageBoxCaptionStr);
PyObject *wxFileDialog_GetFilenames(wxFileDialog *self){
wxArrayString arr;
self->GetFilenames(arr);
#include "wx/wxPython/printfw.h"
- static const wxChar* wxPrintoutTitleStr = wxT("Printout");
- DECLARE_DEF_STRING(PrintoutTitleStr);
- static const wxChar* wxPreviewCanvasNameStr = wxT("previewcanvas");
- DECLARE_DEF_STRING(PreviewCanvasNameStr);
-
+ static const wxString wxPyPrintoutTitleStr(wxT(wxT("Printout")));
+ static const wxString wxPyPreviewCanvasNameStr(wxT(wxT("previewcanvas")));
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_FrameNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable FrameNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_FrameNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyFrameNameStr)->c_str(), (&wxPyFrameNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyFrameNameStr)->c_str(), (&wxPyFrameNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_DialogNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable DialogNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_DialogNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyDialogNameStr)->c_str(), (&wxPyDialogNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyDialogNameStr)->c_str(), (&wxPyDialogNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_StatusLineNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable StatusLineNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_StatusLineNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyStatusLineNameStr)->c_str(), (&wxPyStatusLineNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyStatusLineNameStr)->c_str(), (&wxPyStatusLineNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_ToolBarNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable ToolBarNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_ToolBarNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyToolBarNameStr)->c_str(), (&wxPyToolBarNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyToolBarNameStr)->c_str(), (&wxPyToolBarNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_TopLevelWindow_Maximize(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxTopLevelWindow *arg1 = (wxTopLevelWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_SplitterNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable SplitterNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_SplitterNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPySplitterNameStr)->c_str(), (&wxPySplitterNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPySplitterNameStr)->c_str(), (&wxPySplitterNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_SplitterWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_SashNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable SashNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_SashNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPySashNameStr)->c_str(), (&wxPySashNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPySashNameStr)->c_str(), (&wxPySashNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_SashLayoutNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable SashLayoutNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_SashLayoutNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPySashLayoutNameStr)->c_str(), (&wxPySashLayoutNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPySashLayoutNameStr)->c_str(), (&wxPySashLayoutNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_SashWindow(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_VListBoxNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable VListBoxNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_VListBoxNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyVListBoxNameStr)->c_str(), (&wxPyVListBoxNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyVListBoxNameStr)->c_str(), (&wxPyVListBoxNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_VListBox(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_FileSelectorPromptStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable FileSelectorPromptStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_FileSelectorPromptStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyFileSelectorPromptStr)->c_str(), (&wxPyFileSelectorPromptStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_DirSelectorPromptStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable DirSelectorPromptStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_DirSelectorPromptStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyDirSelectorPromptStr)->c_str(), (&wxPyDirSelectorPromptStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_DirDialogNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable DirDialogNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_DirDialogNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyDirDialogNameStr)->c_str(), (&wxPyDirDialogNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyDirDialogNameStr)->c_str(), (&wxPyDirDialogNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_FileSelectorDefaultWildcardStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable FileSelectorDefaultWildcardStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_FileSelectorDefaultWildcardStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyFileSelectorDefaultWildcardStr)->c_str(), (&wxPyFileSelectorDefaultWildcardStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_GetTextFromUserPromptStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable GetTextFromUserPromptStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_GetTextFromUserPromptStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyGetTextFromUserPromptStr)->c_str(), (&wxPyGetTextFromUserPromptStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyGetTextFromUserPromptStr)->c_str(), (&wxPyGetTextFromUserPromptStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_MessageBoxCaptionStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable MessageBoxCaptionStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_MessageBoxCaptionStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyMessageBoxCaptionStr)->c_str(), (&wxPyMessageBoxCaptionStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyMessageBoxCaptionStr)->c_str(), (&wxPyMessageBoxCaptionStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_ColourData(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxColourData *result;
Py_INCREF(obj);
return Py_BuildValue((char *)"");
}
+static int _wrap_PrintoutTitleStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable PrintoutTitleStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_PrintoutTitleStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyPrintoutTitleStr)->c_str(), (&wxPyPrintoutTitleStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyPrintoutTitleStr)->c_str(), (&wxPyPrintoutTitleStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
+static int _wrap_PreviewCanvasNameStr_set(PyObject *_val) {
+ PyErr_SetString(PyExc_TypeError,"Variable PreviewCanvasNameStr is read-only.");
+ return 1;
+}
+
+
+static PyObject *_wrap_PreviewCanvasNameStr_get() {
+ PyObject *pyobj;
+
+ {
+#if wxUSE_UNICODE
+ pyobj = PyUnicode_FromWideChar((&wxPyPreviewCanvasNameStr)->c_str(), (&wxPyPreviewCanvasNameStr)->Len());
+#else
+ pyobj = PyString_FromStringAndSize((&wxPyPreviewCanvasNameStr)->c_str(), (&wxPyPreviewCanvasNameStr)->Len());
+#endif
+ }
+ return pyobj;
+}
+
+
static PyObject *_wrap_new_PrintData(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxPrintData *result;
static PyObject *_wrap_PrintData_GetQuality(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxPrintData *arg1 = (wxPrintData *) 0 ;
- wxPrintQuality result;
+ int result;
PyObject * obj0 = 0 ;
char *kwnames[] = {
(char *) "self", NULL
if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPrintData,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
- result = (arg1)->GetQuality();
+ result = (int)(arg1)->GetQuality();
wxPyEndAllowThreads(__tstate);
if (PyErr_Occurred()) SWIG_fail;
}
- {
- wxPrintQuality * resultptr;
- resultptr = new wxPrintQuality((wxPrintQuality &) result);
- resultobj = SWIG_NewPointerObj((void *) resultptr, SWIGTYPE_p_wxPrintQuality, 1);
- }
+ resultobj = PyInt_FromLong((long)result);
return resultobj;
fail:
return NULL;
static PyObject *_wrap_PrintData_SetQuality(PyObject *self, PyObject *args, PyObject *kwargs) {
PyObject *resultobj;
wxPrintData *arg1 = (wxPrintData *) 0 ;
- wxPrintQuality arg2 ;
- wxPrintQuality *argp2 ;
+ int arg2 ;
PyObject * obj0 = 0 ;
- PyObject * obj1 = 0 ;
char *kwnames[] = {
(char *) "self",(char *) "quality", NULL
};
- if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PrintData_SetQuality",kwnames,&obj0,&obj1)) goto fail;
+ if(!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"Oi:PrintData_SetQuality",kwnames,&obj0,&arg2)) goto fail;
if ((SWIG_ConvertPtr(obj0,(void **) &arg1, SWIGTYPE_p_wxPrintData,SWIG_POINTER_EXCEPTION | 0 )) == -1) SWIG_fail;
- if ((SWIG_ConvertPtr(obj1,(void **) &argp2, SWIGTYPE_p_wxPrintQuality,SWIG_POINTER_EXCEPTION) == -1)) SWIG_fail;
- arg2 = *argp2;
{
PyThreadState* __tstate = wxPyBeginAllowThreads();
(arg1)->SetQuality(arg2);
static swig_type_info _swigt__p_wxPrintDialog[] = {{"_p_wxPrintDialog", 0, "wxPrintDialog *", 0},{"_p_wxPrintDialog"},{0}};
static swig_type_info _swigt__p_wxBitmap[] = {{"_p_wxBitmap", 0, "wxBitmap *", 0},{"_p_wxBitmap"},{0}};
static swig_type_info _swigt__p_wxCommandEvent[] = {{"_p_wxCommandEvent", 0, "wxCommandEvent *", 0},{"_p_wxChildFocusEvent", _p_wxChildFocusEventTo_p_wxCommandEvent},{"_p_wxScrollEvent", _p_wxScrollEventTo_p_wxCommandEvent},{"_p_wxWindowCreateEvent", _p_wxWindowCreateEventTo_p_wxCommandEvent},{"_p_wxUpdateUIEvent", _p_wxUpdateUIEventTo_p_wxCommandEvent},{"_p_wxFindDialogEvent", _p_wxFindDialogEventTo_p_wxCommandEvent},{"_p_wxWindowDestroyEvent", _p_wxWindowDestroyEventTo_p_wxCommandEvent},{"_p_wxContextMenuEvent", _p_wxContextMenuEventTo_p_wxCommandEvent},{"_p_wxSplitterEvent", _p_wxSplitterEventTo_p_wxCommandEvent},{"_p_wxCommandEvent"},{"_p_wxNotifyEvent", _p_wxNotifyEventTo_p_wxCommandEvent},{"_p_wxPyCommandEvent", _p_wxPyCommandEventTo_p_wxCommandEvent},{"_p_wxSashEvent", _p_wxSashEventTo_p_wxCommandEvent},{0}};
-static swig_type_info _swigt__p_wxPrintQuality[] = {{"_p_wxPrintQuality", 0, "wxPrintQuality *", 0},{"_p_wxPrintQuality"},{0}};
static swig_type_info _swigt__p_wxPreviewControlBar[] = {{"_p_wxPreviewControlBar", 0, "wxPreviewControlBar *", 0},{"_p_wxPreviewControlBar"},{"_p_wxPyPreviewControlBar", _p_wxPyPreviewControlBarTo_p_wxPreviewControlBar},{0}};
static swig_type_info _swigt__p_wxPyPreviewControlBar[] = {{"_p_wxPyPreviewControlBar", 0, "wxPyPreviewControlBar *", 0},{"_p_wxPyPreviewControlBar"},{0}};
static swig_type_info _swigt__p_wxColour[] = {{"_p_wxColour", 0, "wxColour *", 0},{"_p_wxColour"},{0}};
static swig_type_info _swigt__p_wxToolBar[] = {{"_p_wxToolBar", 0, "wxToolBar *", 0},{"_p_wxToolBar"},{0}};
-static swig_type_info _swigt__p_wxPageSetupDialogData[] = {{"_p_wxPageSetupDialogData", 0, "wxPageSetupDialogData *", 0},{"_p_wxPageSetupDialogData"},{0}};
static swig_type_info _swigt__p_wxPrintDialogData[] = {{"_p_wxPrintDialogData", 0, "wxPrintDialogData *", 0},{"_p_wxPrintDialogData"},{0}};
+static swig_type_info _swigt__p_wxPageSetupDialogData[] = {{"_p_wxPageSetupDialogData", 0, "wxPageSetupDialogData *", 0},{"_p_wxPageSetupDialogData"},{0}};
static swig_type_info *swig_types_initial[] = {
_swigt__p_wxQueryLayoutInfoEvent,
_swigt__p_wxPrintDialog,
_swigt__p_wxBitmap,
_swigt__p_wxCommandEvent,
-_swigt__p_wxPrintQuality,
_swigt__p_wxPreviewControlBar,
_swigt__p_wxPyPreviewControlBar,
_swigt__p_wxColour,
_swigt__p_wxToolBar,
-_swigt__p_wxPageSetupDialogData,
_swigt__p_wxPrintDialogData,
+_swigt__p_wxPageSetupDialogData,
0
};
}
SWIG_InstallConstants(d,swig_const_table);
+ PyDict_SetItemString(d,(char*)"cvar", SWIG_globals);
+ SWIG_addvarlink(SWIG_globals,(char*)"FrameNameStr",_wrap_FrameNameStr_get, _wrap_FrameNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"DialogNameStr",_wrap_DialogNameStr_get, _wrap_DialogNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"StatusLineNameStr",_wrap_StatusLineNameStr_get, _wrap_StatusLineNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"ToolBarNameStr",_wrap_ToolBarNameStr_get, _wrap_ToolBarNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"SplitterNameStr",_wrap_SplitterNameStr_get, _wrap_SplitterNameStr_set);
PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGED));
PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_SASH_POS_CHANGING));
PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_DOUBLECLICKED));
PyDict_SetItemString(d, "wxEVT_COMMAND_SPLITTER_UNSPLIT", PyInt_FromLong(wxEVT_COMMAND_SPLITTER_UNSPLIT));
+ SWIG_addvarlink(SWIG_globals,(char*)"SashNameStr",_wrap_SashNameStr_get, _wrap_SashNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"SashLayoutNameStr",_wrap_SashLayoutNameStr_get, _wrap_SashLayoutNameStr_set);
PyDict_SetItemString(d, "wxEVT_SASH_DRAGGED", PyInt_FromLong(wxEVT_SASH_DRAGGED));
PyDict_SetItemString(d, "wxEVT_QUERY_LAYOUT_INFO", PyInt_FromLong(wxEVT_QUERY_LAYOUT_INFO));
PyDict_SetItemString(d, "wxEVT_CALCULATE_LAYOUT", PyInt_FromLong(wxEVT_CALCULATE_LAYOUT));
+ SWIG_addvarlink(SWIG_globals,(char*)"VListBoxNameStr",_wrap_VListBoxNameStr_get, _wrap_VListBoxNameStr_set);
// Map renamed classes back to their common name for OOR
wxPyPtrTypeMap_Add("wxHtmlListBox", "wxPyHtmlListBox");
PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_UP", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_UP));
PyDict_SetItemString(d, "wxEVT_TASKBAR_LEFT_DCLICK", PyInt_FromLong(wxEVT_TASKBAR_LEFT_DCLICK));
PyDict_SetItemString(d, "wxEVT_TASKBAR_RIGHT_DCLICK", PyInt_FromLong(wxEVT_TASKBAR_RIGHT_DCLICK));
+ SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorPromptStr",_wrap_FileSelectorPromptStr_get, _wrap_FileSelectorPromptStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"DirSelectorPromptStr",_wrap_DirSelectorPromptStr_get, _wrap_DirSelectorPromptStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"DirDialogNameStr",_wrap_DirDialogNameStr_get, _wrap_DirDialogNameStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"FileSelectorDefaultWildcardStr",_wrap_FileSelectorDefaultWildcardStr_get, _wrap_FileSelectorDefaultWildcardStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"GetTextFromUserPromptStr",_wrap_GetTextFromUserPromptStr_get, _wrap_GetTextFromUserPromptStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"MessageBoxCaptionStr",_wrap_MessageBoxCaptionStr_get, _wrap_MessageBoxCaptionStr_set);
PyDict_SetItemString(d, "wxEVT_COMMAND_FIND", PyInt_FromLong(wxEVT_COMMAND_FIND));
PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_NEXT", PyInt_FromLong(wxEVT_COMMAND_FIND_NEXT));
PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_REPLACE", PyInt_FromLong(wxEVT_COMMAND_FIND_REPLACE));
PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_REPLACE_ALL", PyInt_FromLong(wxEVT_COMMAND_FIND_REPLACE_ALL));
PyDict_SetItemString(d, "wxEVT_COMMAND_FIND_CLOSE", PyInt_FromLong(wxEVT_COMMAND_FIND_CLOSE));
+ SWIG_addvarlink(SWIG_globals,(char*)"PrintoutTitleStr",_wrap_PrintoutTitleStr_get, _wrap_PrintoutTitleStr_set);
+ SWIG_addvarlink(SWIG_globals,(char*)"PreviewCanvasNameStr",_wrap_PreviewCanvasNameStr_get, _wrap_PreviewCanvasNameStr_set);
wxPyPtrTypeMap_Add("wxPrintout", "wxPyPrintout");
def __repr__(self):
return "<%s.%s; proxy of C++ wxWizardPage instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def Create(*args, **kwargs):
- """Create(Wizard parent, wxBitmap bitmap=wxNullBitmap, wxString resource=wxPyEmptyString) -> bool"""
+ """Create(Wizard parent, Bitmap bitmap=wxNullBitmap, String resource=EmptyString) -> bool"""
return _wizard.WizardPage_Create(*args, **kwargs)
def GetPrev(*args, **kwargs):
return _wizard.WizardPage_GetNext(*args, **kwargs)
def GetBitmap(*args, **kwargs):
- """GetBitmap() -> wxBitmap"""
+ """GetBitmap() -> Bitmap"""
return _wizard.WizardPage_GetBitmap(*args, **kwargs)
def __repr__(self):
return "<%s.%s; proxy of C++ wxPyWizardPage instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
- """__init__(Wizard parent, wxBitmap bitmap=&wxNullBitmap, wxString resource=&wxPyEmptyString) -> PyWizardPage"""
+ """__init__(Wizard parent, Bitmap bitmap=&wxNullBitmap, String resource=&wxPyEmptyString) -> PyWizardPage"""
newobj = _wizard.new_PyWizardPage(*args, **kwargs)
self.this = newobj.this
self.thisown = 1
self._setCallbackInfo(self, PyWizardPage);self._setOORInfo(self)
def Create(*args, **kwargs):
- """Create(Wizard parent, wxBitmap bitmap=wxNullBitmap, wxString resource=wxPyEmptyString) -> bool"""
+ """Create(Wizard parent, Bitmap bitmap=wxNullBitmap, String resource=EmptyString) -> bool"""
return _wizard.PyWizardPage_Create(*args, **kwargs)
def _setCallbackInfo(*args, **kwargs):
def __init__(self, *args, **kwargs):
"""
__init__(Wizard parent, WizardPage prev=None, WizardPage next=None,
- wxBitmap bitmap=wxNullBitmap, wxChar resource=None) -> WizardPageSimple
+ Bitmap bitmap=wxNullBitmap, wxChar resource=None) -> WizardPageSimple
"""
newobj = _wizard.new_WizardPageSimple(*args, **kwargs)
self.this = newobj.this
def Create(*args, **kwargs):
"""
Create(Wizard parent=None, WizardPage prev=None, WizardPage next=None,
- wxBitmap bitmap=wxNullBitmap, wxChar resource=None) -> bool
+ Bitmap bitmap=wxNullBitmap, wxChar resource=None) -> bool
"""
return _wizard.WizardPageSimple_Create(*args, **kwargs)
return "<%s.%s; proxy of C++ wxWizard instance at %s>" % (self.__class__.__module__, self.__class__.__name__, self.this,)
def __init__(self, *args, **kwargs):
"""
- __init__(Window parent, int id=-1, wxString title=wxEmptyString,
- wxBitmap bitmap=wxNullBitmap, Point pos=DefaultPosition,
+ __init__(Window parent, int id=-1, String title=EmptyString,
+ Bitmap bitmap=wxNullBitmap, Point pos=DefaultPosition,
long style=DEFAULT_DIALOG_STYLE) -> Wizard
"""
newobj = _wizard.new_Wizard(*args, **kwargs)
def Create(*args, **kwargs):
"""
- Create(Window parent, int id=-1, wxString title=wxEmptyString,
- wxBitmap bitmap=wxNullBitmap, Point pos=DefaultPosition) -> bool
+ Create(Window parent, int id=-1, String title=EmptyString,
+ Bitmap bitmap=wxNullBitmap, Point pos=DefaultPosition) -> bool
"""
return _wizard.Wizard_Create(*args, **kwargs)
#include <wx/wizard.h>
- static const wxString wxPyEmptyString(wxT(""));
+ static const wxString wxPyEmptyString(wxEmptyString);
bool wxWizardPage_Create(wxWizardPage *self,wxWizard *parent,wxBitmap const &bitmap,wxString const &resource){
wxChar* res = NULL;
if (resource.Length())
PyObject *resultobj;
wxWindow *arg1 = (wxWindow *) 0 ;
int arg2 = (int) -1 ;
- wxString const &arg3_defvalue = wxEmptyString ;
+ wxString const &arg3_defvalue = wxPyEmptyString ;
wxString *arg3 = (wxString *) &arg3_defvalue ;
wxBitmap const &arg4_defvalue = wxNullBitmap ;
wxBitmap *arg4 = (wxBitmap *) &arg4_defvalue ;
wxWizard *arg1 = (wxWizard *) 0 ;
wxWindow *arg2 = (wxWindow *) 0 ;
int arg3 = (int) -1 ;
- wxString const &arg4_defvalue = wxEmptyString ;
+ wxString const &arg4_defvalue = wxPyEmptyString ;
wxString *arg4 = (wxString *) &arg4_defvalue ;
wxBitmap const &arg5_defvalue = wxNullBitmap ;
wxBitmap *arg5 = (wxBitmap *) &arg5_defvalue ;
wxGenericFindWindowAtPoint = wx.misc.GenericFindWindowAtPoint
wxFindWindowAtPoint = wx.misc.FindWindowAtPoint
wxGetTopLevelParent = wx.misc.GetTopLevelParent
+wxGetKeyState = wx.misc.GetKeyState
wxWakeUpMainThread = wx.misc.WakeUpMainThread
wxMutexGuiEnter = wx.misc.MutexGuiEnter
wxMutexGuiLeave = wx.misc.MutexGuiLeave
projects / wxWidgets.git / commitdiff
