def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxPropertyGridPage') assert isinstance(c, etgtools.ClassDef) tools.ignoreConstOverloads(c) module.addGlobalStr('wxPropertyGridManagerNameStr', c) c = module.find('wxPropertyGridManager') tools.fixWindowClass(c, hideVirtuals=False, ignoreProtected=False) tools.ignoreConstOverloads(c) # wxPGPropArg is a typedef for "const wxPGPropArgCls&" so having the # wrappers treat it as a normal type can be problematic. ("new cannot be # applied to a reference type", etc.) Let's just ignore it an replace it # everywhere for the real type. for item in module.allItems(): if hasattr(item, 'type') and item.type == 'wxPGPropArg': item.type = 'const wxPGPropArgCls &' #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. module.addHeaderCode('#include <wx/ribbon/panel.h>') c = module.find('wxRibbonPanel') assert isinstance(c, etgtools.ClassDef) tools.fixWindowClass(c) tools.ignoreConstOverloads(c) c = module.find('wxRibbonPanelEvent') tools.fixEventClass(c) module.addPyCode("""\ EVT_RIBBONPANEL_EXTBUTTON_ACTIVATED = wx.PyEventBinder(wxEVT_RIBBONPANEL_EXTBUTTON_ACTIVATED, 1) """) #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxPropertyGridHitTestResult') assert isinstance(c, etgtools.ClassDef) c = module.find('wxPropertyGridIterator') # TODO: Add python iterator methods to this and other iterator classes c = module.find('wxPGVIterator') c.find('wxPGVIterator').findOverload('wxPGVIteratorBase').ignore() c = module.find('wxPropertyGridPageState') tools.ignoreConstOverloads(c) module.find('wxPG_IT_CHILDREN').ignore() #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxPropertyGridHitTestResult') assert isinstance(c, etgtools.ClassDef) c = module.find('wxPropertyGridIterator') # TODO: Add python iterator methods to this and other iterator classes c = module.find('wxPGVIterator') c.find('wxPGVIterator').findOverload('wxPGVIteratorBase').ignore() c = module.find('wxPropertyGridPageState') tools.ignoreConstOverloads(c) module.find('wxPG_IT_CHILDREN').ignore() # Switch all wxVariant types to wxPGVariant, so the propgrid-specific # version of the MappedType will be used for converting to/from Python # objects. for item in module.allItems(): if hasattr(item, 'type') and 'wxVariant' in item.type: item.type = item.type.replace('wxVariant', 'wxPGVariant') #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) # ----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find("wxPropertyGridPage") assert isinstance(c, etgtools.ClassDef) tools.ignoreConstOverloads(c) module.addGlobalStr("wxPropertyGridManagerNameStr", c) c = module.find("wxPropertyGridManager") tools.fixWindowClass(c, hideVirtuals=False, ignoreProtected=False) tools.ignoreConstOverloads(c) # wxPGPropArg is a typedef for "const wxPGPropArgCls&" so having the # wrappers treat it as a normal type can be problematic. ("new cannot be # applied to a reference type", etc.) Let's just ignore it an replace it # everywhere for the real type. for item in module.allItems(): if hasattr(item, "type") and item.type == "wxPGPropArg": item.type = "const wxPGPropArgCls &" # ----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxAuiNotebook') assert isinstance(c, etgtools.ClassDef) tools.fixWindowClass(c) tools.fixBookctrlClass(c) c = module.find('wxAuiTabContainer') tools.ignoreConstOverloads(c) module.addItem(tools.wxArrayWrapperTemplate( 'wxAuiNotebookPageArray', 'wxAuiNotebookPage', module)) module.addItem(tools.wxArrayWrapperTemplate( 'wxAuiTabContainerButtonArray', 'wxAuiTabContainerButton', module)) c = module.find('wxAuiTabArt') c.abstract = True c = module.find('wxAuiNotebookEvent') tools.fixEventClass(c) c.addPyCode("""\ EVT_AUINOTEBOOK_PAGE_CLOSE = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CLOSE, 1 ) EVT_AUINOTEBOOK_PAGE_CLOSED = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CLOSED, 1 ) EVT_AUINOTEBOOK_PAGE_CHANGED = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CHANGED, 1 ) EVT_AUINOTEBOOK_PAGE_CHANGING = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CHANGING, 1 ) EVT_AUINOTEBOOK_BUTTON = wx.PyEventBinder( wxEVT_AUINOTEBOOK_BUTTON, 1 ) EVT_AUINOTEBOOK_BEGIN_DRAG = wx.PyEventBinder( wxEVT_AUINOTEBOOK_BEGIN_DRAG, 1 ) EVT_AUINOTEBOOK_END_DRAG = wx.PyEventBinder( wxEVT_AUINOTEBOOK_END_DRAG, 1 ) EVT_AUINOTEBOOK_DRAG_MOTION = wx.PyEventBinder( wxEVT_AUINOTEBOOK_DRAG_MOTION, 1 ) EVT_AUINOTEBOOK_ALLOW_DND = wx.PyEventBinder( wxEVT_AUINOTEBOOK_ALLOW_DND, 1 ) EVT_AUINOTEBOOK_DRAG_DONE = wx.PyEventBinder( wxEVT_AUINOTEBOOK_DRAG_DONE, 1 ) EVT_AUINOTEBOOK_TAB_MIDDLE_DOWN = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_MIDDLE_DOWN, 1 ) EVT_AUINOTEBOOK_TAB_MIDDLE_UP = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_MIDDLE_UP, 1 ) EVT_AUINOTEBOOK_TAB_RIGHT_DOWN = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_RIGHT_DOWN, 1 ) EVT_AUINOTEBOOK_TAB_RIGHT_UP = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_RIGHT_UP, 1 ) EVT_AUINOTEBOOK_BG_DCLICK = wx.PyEventBinder( wxEVT_AUINOTEBOOK_BG_DCLICK, 1 ) """) #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxPropertyGridPage') assert isinstance(c, etgtools.ClassDef) tools.ignoreConstOverloads(c) module.addGlobalStr('wxPropertyGridManagerNameStr', c) c = module.find('wxPropertyGridManager') tools.fixWindowClass(c, hideVirtuals=False, ignoreProtected=False) tools.ignoreConstOverloads(c) c.find('AddPage.pageObj').transfer = True # Add some extra Python code to be executed when a wxPropertyGridManager # is constructed. In Classic with SWIG we did this with %pythonAppend, is # there any better way to do it with sip than monkey-patching? c.addPyCode("""\ _PropertyGridManager__init__orig = PropertyGridManager.__init__ def _PropertyGridManager__init__(self, *args, **kw): _PropertyGridManager__init__orig(self, *args, **kw) self.DoDefaultTypeMappings() self.edited_objects = {} self.DoDefaultValueTypeMappings() if not hasattr(self.__class__, '_vt2setter'): self.__class__._vt2setter = {} PropertyGridManager.__init__ = _PropertyGridManager__init__ """) # Make sure sip knows there is an implementation of this method c.addItem( etgtools.WigCode("""\ virtual void RefreshProperty( wxPGProperty* p ); """)) # wxPGPropArg is a typedef for "const wxPGPropArgCls&" so having the # wrappers treat it as a normal type can be problematic. ("new cannot be # applied to a reference type", etc.) Let's just ignore it an replace it # everywhere for the real type. for item in module.allItems(): if hasattr(item, 'type') and item.type == 'wxPGPropArg': item.type = 'const wxPGPropArgCls &' #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxPropertyGridPage') assert isinstance(c, etgtools.ClassDef) tools.ignoreConstOverloads(c) module.addGlobalStr('wxPropertyGridManagerNameStr', c) c = module.find('wxPropertyGridManager') tools.fixWindowClass(c, hideVirtuals=False, ignoreProtected=False) tools.ignoreConstOverloads(c) c.find('AddPage.pageObj').transfer = True # Add some extra Python code to be executed when a wxPropertyGridManager # is constructed. In Classic with SWIG we did this with %pythonAppend, is # there any better way to do it with sip than monkey-patching? c.addPyCode("""\ _PropertyGridManager__init__orig = PropertyGridManager.__init__ def _PropertyGridManager__init__(self, *args, **kw): _PropertyGridManager__init__orig(self, *args, **kw) self.DoDefaultTypeMappings() self.edited_objects = {} self.DoDefaultValueTypeMappings() if not hasattr(self.__class__, '_vt2setter'): self.__class__._vt2setter = {} PropertyGridManager.__init__ = _PropertyGridManager__init__ """) # wxPGPropArg is a typedef for "const wxPGPropArgCls&" so having the # wrappers treat it as a normal type can be problematic. ("new cannot be # applied to a reference type", etc.) Let's just ignore it an replace it # everywhere for the real type. for item in module.allItems(): if hasattr(item, 'type') and item.type == 'wxPGPropArg': item.type = 'const wxPGPropArgCls &' #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxAuiNotebook') assert isinstance(c, etgtools.ClassDef) tools.fixWindowClass(c) tools.fixBookctrlClass(c) c = module.find('wxAuiTabContainer') tools.ignoreConstOverloads(c) module.addItem( tools.wxArrayWrapperTemplate('wxAuiNotebookPageArray', 'wxAuiNotebookPage', module)) module.addItem( tools.wxArrayWrapperTemplate('wxAuiTabContainerButtonArray', 'wxAuiTabContainerButton', module)) c = module.find('wxAuiTabArt') c.abstract = True c = module.find('wxAuiNotebookEvent') tools.fixEventClass(c) module.addPyCode("""\ EVT_AUINOTEBOOK_PAGE_CLOSE = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CLOSE, 1 ) EVT_AUINOTEBOOK_PAGE_CLOSED = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CLOSED, 1 ) EVT_AUINOTEBOOK_PAGE_CHANGED = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CHANGED, 1 ) EVT_AUINOTEBOOK_PAGE_CHANGING = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CHANGING, 1 ) EVT_AUINOTEBOOK_BUTTON = wx.PyEventBinder( wxEVT_AUINOTEBOOK_BUTTON, 1 ) EVT_AUINOTEBOOK_BEGIN_DRAG = wx.PyEventBinder( wxEVT_AUINOTEBOOK_BEGIN_DRAG, 1 ) EVT_AUINOTEBOOK_END_DRAG = wx.PyEventBinder( wxEVT_AUINOTEBOOK_END_DRAG, 1 ) EVT_AUINOTEBOOK_DRAG_MOTION = wx.PyEventBinder( wxEVT_AUINOTEBOOK_DRAG_MOTION, 1 ) EVT_AUINOTEBOOK_ALLOW_DND = wx.PyEventBinder( wxEVT_AUINOTEBOOK_ALLOW_DND, 1 ) EVT_AUINOTEBOOK_DRAG_DONE = wx.PyEventBinder( wxEVT_AUINOTEBOOK_DRAG_DONE, 1 ) EVT_AUINOTEBOOK_TAB_MIDDLE_DOWN = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_MIDDLE_DOWN, 1 ) EVT_AUINOTEBOOK_TAB_MIDDLE_UP = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_MIDDLE_UP, 1 ) EVT_AUINOTEBOOK_TAB_RIGHT_DOWN = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_RIGHT_DOWN, 1 ) EVT_AUINOTEBOOK_TAB_RIGHT_UP = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_RIGHT_UP, 1 ) EVT_AUINOTEBOOK_BG_DCLICK = wx.PyEventBinder( wxEVT_AUINOTEBOOK_BG_DCLICK, 1 ) """) #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxRichTextFormattingDialog') assert isinstance(c, etgtools.ClassDef) tools.fixTopLevelWindowClass(c) tools.ignoreConstOverloads(c) #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxRichTextStyleListCtrl') assert isinstance(c, etgtools.ClassDef) tools.fixWindowClass(c) c = module.find('wxRichTextStyleListBox') tools.fixWindowClass(c) c.piBases = ['wx.html.HtmlListBox'] c.find('OnGetItem').ignore(False) c.find('CreateHTML.def').name = 'styleDef' c = module.find('wxRichTextStyleComboCtrl') tools.fixWindowClass(c) c = module.find('wxRichTextStyleDefinition') tools.ignoreConstOverloads(c) c.abstract = True c = module.find('wxRichTextStyleSheet') tools.ignoreConstOverloads(c) c.find('AddCharacterStyle.def').transfer = True c.find('AddListStyle.def').transfer = True c.find('AddParagraphStyle.def').transfer = True c.find('AddStyle.def').transfer = True # Change def --> styleDef for item in c.allItems(): if isinstance(item, etgtools.ParamDef) and item.name == 'def': item.name = 'styleDef' #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxPGValidationInfo') assert isinstance(c, etgtools.ClassDef) c = module.find('wxPropertyGrid') assert isinstance(c, etgtools.ClassDef) c.bases[ 0] = 'wxControl' # sip can't handle wxScrolled<wxControl>. See also below. tools.fixWindowClass(c) module.addGlobalStr('wxPropertyGridNameStr', c) for name in ['RegisterEditorClass', 'DoRegisterEditorClass']: for m in c.find(name).all(): m.find('editor').transfer = True # TODO: provide a way to use a Python callable as a sort function c.find('GetSortFunction').ignore() c.find('SetSortFunction').ignore() module.find('wxPGSortCallback').ignore() # Add some extra Python code to be executed when a wxPropertyGrid is # constructed. In Classic with SWIG we did this with %pythonAppend, is # there any better way to do it with sip than monkey-patching? c.addPyCode("""\ _PropertyGrid__init__orig = PropertyGrid.__init__ def _PropertyGrid__init__(self, *args, **kw): _PropertyGrid__init__orig(self, *args, **kw) self.DoDefaultTypeMappings() self.edited_objects = {} self.DoDefaultValueTypeMappings() if not hasattr(self.__class__, '_vt2setter'): self.__class__._vt2setter = {} PropertyGrid.__init__ = _PropertyGrid__init__ """) # See note in propgridiface.py for item in module.allItems(): if hasattr(item, 'type') and item.type == 'wxPGPropArg': item.type = 'const wxPGPropArgCls &' # We can't let sip create a wxScrolledControl via a typedef because of the # differences in the parameters of the Create methods, so instead let's just # copy the method definitions from wxScrolled<> here and let the compiler # sort it out. import scrolwin mod = scrolwin.parseAndTweakModule() klass = mod.find('wxScrolled') newItems = [ item for item in klass.items if not c.findItem(item.name) and not item.isCtor ] c.items.extend(newItems) c = module.find('wxPropertyGridEvent') tools.fixEventClass(c) module.addPyCode("""\ EVT_PG_CHANGED = wx.PyEventBinder( wxEVT_PG_CHANGED, 1 ) EVT_PG_CHANGING = wx.PyEventBinder( wxEVT_PG_CHANGING, 1 ) EVT_PG_SELECTED = wx.PyEventBinder( wxEVT_PG_SELECTED, 1 ) EVT_PG_HIGHLIGHTED = wx.PyEventBinder( wxEVT_PG_HIGHLIGHTED, 1 ) EVT_PG_RIGHT_CLICK = wx.PyEventBinder( wxEVT_PG_RIGHT_CLICK, 1 ) EVT_PG_PAGE_CHANGED = wx.PyEventBinder( wxEVT_PG_PAGE_CHANGED, 1 ) EVT_PG_ITEM_COLLAPSED = wx.PyEventBinder( wxEVT_PG_ITEM_COLLAPSED, 1 ) EVT_PG_ITEM_EXPANDED = wx.PyEventBinder( wxEVT_PG_ITEM_EXPANDED, 1 ) EVT_PG_DOUBLE_CLICK = wx.PyEventBinder( wxEVT_PG_DOUBLE_CLICK, 1 ) EVT_PG_LABEL_EDIT_BEGIN = wx.PyEventBinder( wxEVT_PG_LABEL_EDIT_BEGIN, 1 ) EVT_PG_LABEL_EDIT_ENDING = wx.PyEventBinder( wxEVT_PG_LABEL_EDIT_ENDING, 1 ) EVT_PG_COL_BEGIN_DRAG = wx.PyEventBinder( wxEVT_PG_COL_BEGIN_DRAG, 1 ) EVT_PG_COL_DRAGGING = wx.PyEventBinder( wxEVT_PG_COL_DRAGGING, 1 ) EVT_PG_COL_END_DRAG = wx.PyEventBinder( wxEVT_PG_COL_END_DRAG, 1 ) """) # Switch all wxVariant types to wxPGVariant, so the propgrid-specific # version of the MappedType will be used for converting to/from Python # objects. for item in module.allItems(): if hasattr(item, 'type') and 'wxVariant' in item.type: item.type = item.type.replace('wxVariant', 'wxPGVariant') # Switch wxPGVFBFlags to unsigned char td = module.find('wxPGVFBFlags') td.ignore() for name in [ 'wxPGValidationInfo.GetFailureBehavior', 'wxPGValidationInfo.SetFailureBehavior.failureBehavior', 'wxPropertyGridEvent.GetValidationFailureBehavior', 'wxPropertyGridEvent.SetValidationFailureBehavior.flags', ]: item = module.find(name) assert item.type == 'wxPGVFBFlags' item.type = 'byte' c = module.find('wxPropertyGridPopulator') tools.ignoreConstOverloads(c) #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxPGValidationInfo') assert isinstance(c, etgtools.ClassDef) c = module.find('wxPropertyGrid') assert isinstance(c, etgtools.ClassDef) c.bases.remove('wxScrollHelper') tools.fixWindowClass(c) module.addGlobalStr('wxPropertyGridNameStr', c) for name in ['RegisterEditorClass', 'DoRegisterEditorClass']: for m in c.find(name).all(): m.find('editor').transfer = True # TODO: provide a way to use a Python callable as a sort function c.find('GetSortFunction').ignore() c.find('SetSortFunction').ignore() module.find('wxPGSortCallback').ignore() # Add some extra Python code to be executed when a wxPropertyGrid is # constructed. In Classic with SWIG we did this with %pythonAppend, is # there any better way to do it with sip than monkey-patching? c.addPyCode("""\ _PropertyGrid__init__orig = PropertyGrid.__init__ def _PropertyGrid__init__(self, *args, **kw): _PropertyGrid__init__orig(self, *args, **kw) self.DoDefaultTypeMappings() self.edited_objects = {} self.DoDefaultValueTypeMappings() if not hasattr(self.__class__, '_vt2setter'): self.__class__._vt2setter = {} PropertyGrid.__init__ = _PropertyGrid__init__ """) # See note in propgridiface.py for item in module.allItems(): if hasattr(item, 'type') and item.type == 'wxPGPropArg': item.type = 'const wxPGPropArgCls &' c = module.find('wxPropertyGridEvent') tools.fixEventClass(c) module.addPyCode("""\ EVT_PG_CHANGED = wx.PyEventBinder( wxEVT_PG_CHANGED, 1 ) EVT_PG_CHANGING = wx.PyEventBinder( wxEVT_PG_CHANGING, 1 ) EVT_PG_SELECTED = wx.PyEventBinder( wxEVT_PG_SELECTED, 1 ) EVT_PG_HIGHLIGHTED = wx.PyEventBinder( wxEVT_PG_HIGHLIGHTED, 1 ) EVT_PG_RIGHT_CLICK = wx.PyEventBinder( wxEVT_PG_RIGHT_CLICK, 1 ) EVT_PG_PAGE_CHANGED = wx.PyEventBinder( wxEVT_PG_PAGE_CHANGED, 1 ) EVT_PG_ITEM_COLLAPSED = wx.PyEventBinder( wxEVT_PG_ITEM_COLLAPSED, 1 ) EVT_PG_ITEM_EXPANDED = wx.PyEventBinder( wxEVT_PG_ITEM_EXPANDED, 1 ) EVT_PG_DOUBLE_CLICK = wx.PyEventBinder( wxEVT_PG_DOUBLE_CLICK, 1 ) EVT_PG_LABEL_EDIT_BEGIN = wx.PyEventBinder( wxEVT_PG_LABEL_EDIT_BEGIN, 1 ) EVT_PG_LABEL_EDIT_ENDING = wx.PyEventBinder( wxEVT_PG_LABEL_EDIT_ENDING, 1 ) EVT_PG_COL_BEGIN_DRAG = wx.PyEventBinder( wxEVT_PG_COL_BEGIN_DRAG, 1 ) EVT_PG_COL_DRAGGING = wx.PyEventBinder( wxEVT_PG_COL_DRAGGING, 1 ) EVT_PG_COL_END_DRAG = wx.PyEventBinder( wxEVT_PG_COL_END_DRAG, 1 ) """) # Switch all wxVariant types to wxPGVariant, so the propgrid-specific # version of the MappedType will be used for converting to/from Python # objects. for item in module.allItems(): if hasattr(item, 'type') and 'wxVariant' in item.type: item.type = item.type.replace('wxVariant', 'wxPGVariant') # Switch wxPGVFBFlags to unsigned char td = module.find('wxPGVFBFlags') td.ignore() for name in ['wxPGValidationInfo.GetFailureBehavior', 'wxPGValidationInfo.SetFailureBehavior.failureBehavior', 'wxPropertyGridEvent.GetValidationFailureBehavior', 'wxPropertyGridEvent.SetValidationFailureBehavior.flags', ]: item = module.find(name) assert item.type == 'wxPGVFBFlags' item.type = 'byte' c = module.find('wxPropertyGridPopulator') tools.ignoreConstOverloads(c) #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxPGCellData') assert isinstance(c, etgtools.ClassDef) c.find('~wxPGCellData').ignore(False) c.bases = ['wxRefCounter'] #--------------------------------------------------------- c = module.find('wxPGCell') tools.ignoreConstOverloads(c) #--------------------------------------------------------- c = module.find('wxPGCellRenderer') c.bases = ['wxRefCounter'] #--------------------------------------------------------- c = module.find('wxPGAttributeStorage') c.find('const_iterator').ignore() c.find('StartIteration').ignore() c.find('GetNext').ignore() #--------------------------------------------------------- c = module.find('wxPGProperty') tools.ignoreConstOverloads(c) c.find('StringToValue.variant').out = True c.find('IntToValue.variant').out = True c.find('HasFlag').findOverload('FlagType').ignore() c.addProperty('m_value GetValue SetValue') # SIP needs to be able to make a copy of the wxPGAttributeStorage value # but the C++ class doesn't have a copy ctor and the default will cause it # to lose references to the variants it contains, so let's just override # the use of the MappedType and convert it to a Python dictionary here # instead. m = c.find('GetAttributes') m.type = 'PyObject*' m.setCppCode("""\ const wxPGAttributeStorage& attrs = self->GetAttributes(); wxPGAttributeStorage::const_iterator it = attrs.StartIteration(); wxVariant v; wxPyThreadBlocker blocker; PyObject* dict = PyDict_New(); if ( !dict ) return NULL; while ( attrs.GetNext( it, v ) ) { const wxString& name = v.GetName(); PyObject* pyStr = wx2PyString(name); PyObject* pyVal = wxPGVariant_out_helper(v); int res = PyDict_SetItem( dict, pyStr, pyVal ); } return dict; """) # SetAttributes uses wxPGAttributeStorage too, but we'll just replace it # with a simple Python method. c.find('SetAttributes').ignore() c.addPyMethod('SetAttributes', '(self, attributes)', doc="Set the property's attributes from a Python dictionary.", body="""\ for name,value in attributes.items(): self.SetAttribute(name, value) """) c.find('AddPrivateChild.prop').transfer = True c.find('AddChild.prop').transfer = True # The [G|S]etClientData methods deal with untyped void* values, which we # don't support. The [G|S]etClientObject methods use wxClientData instances # which we have a MappedType for, so make the ClientData methods just be # aliases for ClientObjects. From the Python programmer's perspective they # would be virtually the same anyway. c.find('SetClientObject.clientObject').transfer = True c.find('SetClientObject.clientObject').name = 'data' c.find('GetClientData').ignore() c.find('SetClientData').ignore() c.find('GetClientObject').pyName = 'GetClientData' c.find('SetClientObject').pyName = 'SetClientData' c.addPyMethod('GetClientObject', '(self, n)', doc="Alias for :meth:`GetClientData`", body="return self.GetClientData(n)") c.addPyMethod('SetClientObject', '(self, n, data)', doc="Alias for :meth:`SetClientData`", body="self.SetClientData(n, data)") c.find('GetEditorDialog').factory = True # deprecated and removed c.find('AddChild').ignore() c.find('GetValueString').ignore() #--------------------------------------------------------- c = module.find('wxPGChoicesData') tools.ignoreConstOverloads(c) c.bases = ['wxRefCounter'] c.find('~wxPGChoicesData').ignore(False) #--------------------------------------------------------- c = module.find('wxPGChoices') c.find('wxPGChoices').findOverload('wxChar **').ignore() tools.ignoreConstOverloads(c) c.find('operator[]').ignore() c.find('GetId').type = 'wxIntPtr' c.find('GetId').setCppCode_sip("""\ sipRes = new ::wxIntPtr((wxIntPtr)sipCpp->GetId()); """) c.addPyMethod('__getitem__', '(self, index)', doc="Returns a reference to a :class:PGChoiceEntry using Python list syntax.", body="return self.Item(index)", ) c.addPyMethod('__len__', '(self)', doc="", body="return self.GetCount()", ) #--------------------------------------------------------- # Ignore some string constants (#defines) coming from dox, and add them # back in Python code. They are wchar_t* values and this seemed the # simplest way to deal with them. for name in [ 'wxPG_ATTR_DEFAULT_VALUE', 'wxPG_ATTR_MIN', 'wxPG_ATTR_MAX', 'wxPG_ATTR_UNITS', 'wxPG_ATTR_HINT', 'wxPG_ATTR_AUTOCOMPLETE', 'wxPG_BOOL_USE_CHECKBOX', 'wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING', 'wxPG_FLOAT_PRECISION', 'wxPG_STRING_PASSWORD', 'wxPG_UINT_BASE', 'wxPG_UINT_PREFIX', 'wxPG_FILE_WILDCARD', 'wxPG_FILE_SHOW_FULL_PATH', 'wxPG_FILE_SHOW_RELATIVE_PATH', 'wxPG_FILE_INITIAL_PATH', 'wxPG_FILE_DIALOG_TITLE', 'wxPG_FILE_DIALOG_STYLE', 'wxPG_DIR_DIALOG_MESSAGE', 'wxPG_ARRAY_DELIMITER', 'wxPG_DATE_FORMAT', 'wxPG_DATE_PICKER_STYLE', 'wxPG_ATTR_SPINCTRL_STEP', 'wxPG_ATTR_SPINCTRL_WRAP', 'wxPG_ATTR_SPINCTRL_MOTION', 'wxPG_ATTR_MULTICHOICE_USERSTRINGMODE', 'wxPG_COLOUR_ALLOW_CUSTOM', 'wxPG_COLOUR_HAS_ALPHA', # and some other #defines with similar issues 'wxNullProperty', 'wxPGChoicesEmptyData', ]: module.find(name).ignore() module.addPyCode("""\ PG_ATTR_DEFAULT_VALUE = u"DefaultValue" PG_ATTR_MIN = u"Min" PG_ATTR_MAX = u"Max" PG_ATTR_UNITS = u"Units" PG_ATTR_HINT = u"Hint" PG_ATTR_INLINE_HELP = PG_ATTR_HINT PG_ATTR_AUTOCOMPLETE = u"AutoComplete" PG_BOOL_USE_CHECKBOX = u"UseCheckbox" PG_BOOL_USE_DOUBLE_CLICK_CYCLING = u"UseDClickCycling" PG_FLOAT_PRECISION = u"Precision" PG_STRING_PASSWORD = u"Password" PG_UINT_BASE = u"Base" PG_UINT_PREFIX = u"Prefix" PG_FILE_WILDCARD = u"Wildcard" PG_FILE_SHOW_FULL_PATH = u"ShowFullPath" PG_FILE_SHOW_RELATIVE_PATH = u"ShowRelativePath" PG_FILE_INITIAL_PATH = u"InitialPath" PG_FILE_DIALOG_TITLE = u"DialogTitle" PG_FILE_DIALOG_STYLE = u"DialogStyle" PG_DIR_DIALOG_MESSAGE = u"DialogMessage" PG_ARRAY_DELIMITER = u"Delimiter" PG_DATE_FORMAT = u"DateFormat" PG_DATE_PICKER_STYLE = u"PickerStyle" PG_ATTR_SPINCTRL_STEP = u"Step" PG_ATTR_SPINCTRL_WRAP = u"Wrap" PG_ATTR_SPINCTRL_MOTION = u"MotionSpin" PG_ATTR_SPINCTRL_MOTIONSPIN = PG_ATTR_SPINCTRL_MOTION PG_ATTR_MULTICHOICE_USERSTRINGMODE= u"UserStringMode" PG_COLOUR_ALLOW_CUSTOM = u"AllowCustom" PG_COLOUR_HAS_ALPHA = u"HasAlpha" NullProperty = None PGChoicesEmptyData = None """) # Switch all wxVariant types to wxPGVariant, so the propgrid-specific # version of the MappedType will be used for converting to/from Python # objects. for item in module.allItems(): if hasattr(item, 'type') and 'wxVariant' in item.type: item.type = item.type.replace('wxVariant', 'wxPGVariant') #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. # Use wxPyUserData for the clientData values instead of a plain wxObject def _fixClientData(c): for item in c.allItems(): if isinstance(item, etgtools.ParamDef) and item.name == 'clientData': item.type = 'wxPyUserData*' item.transfer = True #--------------------------------------------- c = module.find('wxToolBarToolBase') assert isinstance(c, etgtools.ClassDef) c.abstract = True tools.removeVirtuals(c) _fixClientData(c) # Switch all wxToolBarBase to wxToolBar for item in c.allItems(): if isinstance(item, etgtools.ParamDef) and item.name == 'tbar': item.type = 'wxToolBar*' c.find('GetToolBar').ignore() c.addCppMethod('wxToolBar*', 'GetToolBar', '()', doc="Return the toolbar this tool is a member of.", body="""\ return (wxToolBar*)self->GetToolBar(); """) gcd = c.find('GetClientData') gcd.type = 'wxPyUserData*' gcd.setCppCode( 'return dynamic_cast<wxPyUserData*>(self->GetClientData());') c.find('SetDropdownMenu.menu').transfer = True #--------------------------------------------- c = module.find('wxToolBar') tools.fixWindowClass(c) tools.ignoreConstOverloads(c) _fixClientData(c) module.addGlobalStr('wxToolBarNameStr', c) gcd = c.find('GetToolClientData') gcd.type = 'wxPyUserData*' gcd.setCppCode( 'return dynamic_cast<wxPyUserData*>(self->GetToolClientData(toolId));') c.find('AddTool.tool').transfer = True c.find('InsertTool.tool').transfer = True # Conform the help text parameters. m = c.find('AddTool') for method in m.all(): for helper in ('shortHelp', 'longHelp'): try: param = method.find("{}String".format(helper)) param.name = helper except ExtractorError: pass c.find('OnLeftClick').ignore() c.find('OnMouseEnter').ignore() c.find('OnRightClick').ignore() c.find('OnLeftClick').ignore() c.find('SetDropdownMenu.menu').transfer = True # Add some deprecated methods to aid with Classic compatibility. # TODO: Which others are commonly enough used that they should be here too? c.addPyMethod( 'AddSimpleTool', '(self, toolId, bitmap, shortHelpString="", longHelpString="", isToggle=0)', doc='Old style method to add a tool to the toolbar.', deprecated='Use :meth:`AddTool` instead.', body="""\ kind = wx.ITEM_NORMAL if isToggle: kind = wx.ITEM_CHECK return self.AddTool(toolId, '', bitmap, wx.NullBitmap, kind, shortHelpString, longHelpString) """) c.addPyMethod( 'AddLabelTool', '(self, id, label, bitmap, bmpDisabled=wx.NullBitmap, kind=wx.ITEM_NORMAL,' ' shortHelp="", longHelp="", clientData=None)', doc='Old style method to add a tool in the toolbar.', deprecated='Use :meth:`AddTool` instead.', body="""\ return self.AddTool(id, label, bitmap, bmpDisabled, kind, shortHelp, longHelp, clientData) """) c.addPyMethod( 'InsertSimpleTool', '(self, pos, toolId, bitmap, shortHelpString="", longHelpString="", isToggle=0)', doc='Old style method to insert a tool in the toolbar.', deprecated='Use :meth:`InsertTool` instead.', body="""\ kind = wx.ITEM_NORMAL if isToggle: kind = wx.ITEM_CHECK return self.InsertTool(pos, toolId, '', bitmap, wx.NullBitmap, kind, shortHelpString, longHelpString) """) c.addPyMethod( 'InsertLabelTool', '(self, pos, id, label, bitmap, bmpDisabled=wx.NullBitmap, kind=wx.ITEM_NORMAL,' ' shortHelp="", longHelp="", clientData=None)', doc='Old style method to insert a tool in the toolbar.', deprecated='Use :meth:`InsertTool` instead.', body="""\ return self.InsertTool(pos, id, label, bitmap, bmpDisabled, kind, shortHelp, longHelp, clientData) """) #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. module.addHeaderCode('#include <wx/richtext/richtextbuffer.h>') module.addItem( tools.wxArrayWrapperTemplate('wxRichTextRangeArray', 'wxRichTextRange', module)) module.addItem( tools.wxArrayWrapperTemplate('wxRichTextAttrArray', 'wxRichTextAttr', module)) module.addItem( tools.wxArrayWrapperTemplate('wxRichTextVariantArray', 'wxVariant', module)) module.addItem( tools.wxListWrapperTemplate('wxRichTextObjectList', 'wxRichTextObject', module)) module.addItem( tools.wxListWrapperTemplate('wxRichTextLineList', 'wxRichTextLine', module)) # Can this even work? Apparently it does. module.addItem( tools.wxArrayPtrWrapperTemplate('wxRichTextObjectPtrArray', 'wxRichTextObject', module)) module.addItem( tools.wxArrayWrapperTemplate('wxRichTextObjectPtrArrayArray', 'wxRichTextObjectPtrArray', module)) module.find('wxRICHTEXT_ALL').ignore() module.find('wxRICHTEXT_NONE').ignore() module.find('wxRICHTEXT_NO_SELECTION').ignore() code = etgtools.PyCodeDef("""\ RICHTEXT_ALL = RichTextRange(-2, -2) RICHTEXT_NONE = RichTextRange(-1, -1) RICHTEXT_NO_SELECTION = RichTextRange(-2, -2) """) module.insertItemAfter(module.find('wxRichTextRange'), code) module.insertItem( 0, etgtools.WigCode("""\ // forward declarations class wxRichTextFloatCollector; """)) #------------------------------------------------------- c = module.find('wxTextAttrDimension') assert isinstance(c, etgtools.ClassDef) c.find('SetValue').findOverload('units').ignore() c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextAttrDimensions') tools.ignoreConstOverloads(c) c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextAttrSize') tools.ignoreConstOverloads(c) c.find('SetWidth').findOverload('units').ignore() c.find('SetHeight').findOverload('units').ignore() c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextAttrBorder') tools.ignoreConstOverloads(c) c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextAttrBorders') tools.ignoreConstOverloads(c) c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextBoxAttr') tools.ignoreConstOverloads(c) #------------------------------------------------------- c = module.find('wxRichTextAttr') tools.ignoreConstOverloads(c) #------------------------------------------------------- c = module.find('wxRichTextProperties') tools.ignoreConstOverloads(c) c.find('SetProperty').findOverload('bool').ignore() c.find('operator[]').ignore() #------------------------------------------------------- c = module.find('wxRichTextSelection') tools.ignoreConstOverloads(c) c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") c.find('operator[]').ignore() #------------------------------------------------------- def _fixDrawObject(c, addMissingVirtuals=True): assert isinstance(c, etgtools.ClassDef) if c.findItem('HitTest'): c.find('HitTest.textPosition').out = True c.find('HitTest.obj').out = True c.find('HitTest.contextObj').out = True if c.findItem('FindPosition'): c.find('FindPosition.pt').out = True c.find('FindPosition.height').out = True if c.findItem('GetBoxRects'): c.find('GetBoxRects.marginRect').out = True c.find('GetBoxRects.borderRect').out = True c.find('GetBoxRects.contentRect').out = True c.find('GetBoxRects.paddingRect').out = True c.find('GetBoxRects.outlineRect').out = True if c.findItem('GetTotalMargin'): c.find('GetTotalMargin.leftMargin').out = True c.find('GetTotalMargin.rightMargin').out = True c.find('GetTotalMargin.topMargin').out = True c.find('GetTotalMargin.bottomMargin').out = True if c.findItem('CalculateRange'): c.find('CalculateRange.end' ).out = True # TODO: should it be an inOut? # This are the pure virtuals in the base class. SIP needs to see that # all the drived classes have an implementation, otherwise it will # consider them to be ABCs/ if not c.findItem('Draw') and addMissingVirtuals: c.addItem( etgtools.WigCode("""\ virtual bool Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);""" )) if not c.findItem('Layout') and addMissingVirtuals: c.addItem( etgtools.WigCode("""\ virtual bool Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style);""")) # TODO: Some of these args are output parameters. How should they be dealt with? if not c.findItem('GetRangeSize') and addMissingVirtuals: c.addItem( etgtools.WigCode("""\ virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, const wxPoint& position = wxPoint(0,0), const wxSize& parentSize = wxDefaultSize, wxArrayInt* partialExtents = NULL) const;""")) #------------------------------------------------------- c = module.find('wxRichTextObject') #c.find('ImportFromXML').ignore() tools.ignoreConstOverloads(c) _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextCompositeObject') tools.ignoreConstOverloads(c) _fixDrawObject(c, addMissingVirtuals=False) #------------------------------------------------------- c = module.find('wxRichTextParagraphLayoutBox') tools.ignoreConstOverloads(c) _fixDrawObject(c) c.find('MoveAnchoredObjectToParagraph.from').name = 'from_' c.find('MoveAnchoredObjectToParagraph.to').name = 'to_' c.find('DoNumberList.def').name = 'styleDef' c.find('SetListStyle.def').name = 'styleDef' #------------------------------------------------------- c = module.find('wxRichTextBox') _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextField') _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextLine') tools.ignoreConstOverloads(c) c.find('SetRange.from').name = 'from_' c.find('SetRange.to').name = 'to_' #------------------------------------------------------- c = module.find('wxRichTextParagraph') _fixDrawObject(c) # These methods use an untyped wxList, but since we know what is in it # we'll make a fake typed list for wxPython so we can know what kinds of # values to get from it. module.addItem( tools.wxListWrapperTemplate('wxList', 'wxRichTextObject', module, fakeListClassName='wxRichTextObjectList_')) c.find('MoveToList.list').type = 'wxRichTextObjectList_&' c.find('MoveFromList.list').type = 'wxRichTextObjectList_&' #------------------------------------------------------- c = module.find('wxRichTextPlainText') _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextImage') _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextBuffer') tools.ignoreConstOverloads(c) _fixDrawObject(c) # More untyped wxLists module.addItem( tools.wxListWrapperTemplate( 'wxList', 'wxRichTextFileHandler', module, fakeListClassName='wxRichTextFileHandlerList')) c.find('GetHandlers').type = 'wxRichTextFileHandlerList&' c.find('GetHandlers').noCopy = True module.addItem( tools.wxListWrapperTemplate( 'wxList', 'wxRichTextDrawingHandler', module, fakeListClassName='wxRichTextDrawingHandlerList')) c.find('GetDrawingHandlers').type = 'wxRichTextDrawingHandlerList&' c.find('GetDrawingHandlers').noCopy = True # TODO: Need a template to wrap STRING_HASH_MAP c.find('GetFieldTypes').ignore() c.find('AddHandler.handler').transfer = True c.find('InsertHandler.handler').transfer = True c.find('AddDrawingHandler.handler').transfer = True c.find('InsertDrawingHandler.handler').transfer = True c.find('AddFieldType.fieldType').transfer = True # TODO: Transfer ownership with AddEventHandler? TransferBack with Remove? #------------------------------------------------------- c = module.find('wxRichTextTable') tools.ignoreConstOverloads(c) _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextObjectAddress') tools.ignoreConstOverloads(c) #------------------------------------------------------- c = module.find('wxRichTextCommand') module.addItem( tools.wxListWrapperTemplate('wxList', 'wxRichTextAction', module, fakeListClassName='wxRichTextActionList')) c.find('GetActions').type = 'wxRichTextActionList&' c.find('GetActions').noCopy = True c.find('AddAction.action').transfer = True #------------------------------------------------------- c = module.find('wxRichTextAction') tools.ignoreConstOverloads(c) #------------------------------------------------------- c = module.find('wxRichTextFileHandler') c.find('DoLoadFile').ignore(False) c.find('DoSaveFile').ignore(False) c = module.find('wxRichTextPlainTextHandler') c.find('DoLoadFile').ignore(False) c.find('DoSaveFile').ignore(False) #------------------------------------------------------- # Ignore all Dump() methods since we don't wrap wxTextOutputStream. # TODO: try swithcing the parameter type to wxOutputStream and then in # the wrapper code create a wxTextOutputStream from that to pass on to # Dump. for m in module.findAll('Dump'): if m.findItem('stream'): m.ignore() #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxAuiNotebook') assert isinstance(c, etgtools.ClassDef) tools.fixWindowClass(c) tools.fixBookctrlClass(c) c = module.find('wxAuiTabContainer') tools.ignoreConstOverloads(c) module.addItem( tools.wxArrayWrapperTemplate('wxAuiNotebookPageArray', 'wxAuiNotebookPage', module)) module.addItem( tools.wxArrayWrapperTemplate('wxAuiTabContainerButtonArray', 'wxAuiTabContainerButton', module)) c = module.find('wxAuiTabArt') c.abstract = True c = module.find('wxAuiNotebookEvent') tools.fixEventClass(c) module.addPyCode("""\ EVT_AUINOTEBOOK_PAGE_CLOSE = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CLOSE, 1 ) EVT_AUINOTEBOOK_PAGE_CLOSED = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CLOSED, 1 ) EVT_AUINOTEBOOK_PAGE_CHANGED = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CHANGED, 1 ) EVT_AUINOTEBOOK_PAGE_CHANGING = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CHANGING, 1 ) EVT_AUINOTEBOOK_BUTTON = wx.PyEventBinder( wxEVT_AUINOTEBOOK_BUTTON, 1 ) EVT_AUINOTEBOOK_BEGIN_DRAG = wx.PyEventBinder( wxEVT_AUINOTEBOOK_BEGIN_DRAG, 1 ) EVT_AUINOTEBOOK_END_DRAG = wx.PyEventBinder( wxEVT_AUINOTEBOOK_END_DRAG, 1 ) EVT_AUINOTEBOOK_DRAG_MOTION = wx.PyEventBinder( wxEVT_AUINOTEBOOK_DRAG_MOTION, 1 ) EVT_AUINOTEBOOK_ALLOW_DND = wx.PyEventBinder( wxEVT_AUINOTEBOOK_ALLOW_DND, 1 ) EVT_AUINOTEBOOK_DRAG_DONE = wx.PyEventBinder( wxEVT_AUINOTEBOOK_DRAG_DONE, 1 ) EVT_AUINOTEBOOK_TAB_MIDDLE_DOWN = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_MIDDLE_DOWN, 1 ) EVT_AUINOTEBOOK_TAB_MIDDLE_UP = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_MIDDLE_UP, 1 ) EVT_AUINOTEBOOK_TAB_RIGHT_DOWN = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_RIGHT_DOWN, 1 ) EVT_AUINOTEBOOK_TAB_RIGHT_UP = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_RIGHT_UP, 1 ) EVT_AUINOTEBOOK_BG_DCLICK = wx.PyEventBinder( wxEVT_AUINOTEBOOK_BG_DCLICK, 1 ) """) #----------------------------------------------------------------- # Add AuiTabCtrl in. c = etgtools.ClassDef( name="wxAuiTabCtrl", bases=["wxControl", "wxAuiTabContainer"], mustHaveAppFlag=True, items=[ etgtools.MethodDef(name="wxAuiTabCtrl", classname="wxAuiTabCtrl", isCtor=True, items=[ etgtools.ParamDef(type="wxWindow*", name="parent"), etgtools.ParamDef(type="wxWindowID", name="id", default="wxID_ANY"), etgtools.ParamDef( type="const wxPoint&", name="pos", default="wxDefaultPosition"), etgtools.ParamDef(type="const wxSize&", name="size", default="wxDefaultSize"), etgtools.ParamDef(type="long", name="style", default="0") ]), etgtools.MethodDef(type="bool", name="IsDragging", classname="wxAuiTabCtrl", isConst=True) ]) tools.fixWindowClass(c) module.addItem(c) #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. #----------------------------------------------------------------- # ignore some macros since most of this set are not simple numbers for item in module.items: if item.name.startswith('wxRICHTEXT_DEFAULT'): item.ignore() #----------------------------------------------------------------- c = module.find('wxRichTextContextMenuPropertiesInfo') assert isinstance(c, etgtools.ClassDef) tools.ignoreConstOverloads(c) #----------------------------------------------------------------- c = module.find('wxRichTextCtrl') tools.fixWindowClass(c) c.bases = ['wxControl' ] # wxTextCtrlIface, wxScrollHelper are also bases... c.find('GetSelection').findOverload('from').ignore() tools.ignoreConstOverloads(c) c.find('PositionToXY.x').out = True c.find('PositionToXY.y').out = True c.find('HitTest.pos').out = True c.find('HitTest.col').out = True c.find('HitTest.row').out = True c.find('HitTest').renameOverload('row', 'HitTestXY') c.find('GetRange.from').name = 'from_' c.find('GetRange.to').name = 'to_' c.find('Remove.from').name = 'from_' c.find('Remove.to').name = 'to_' c.find('Replace.from').name = 'from_' c.find('Replace.to').name = 'to_' c.find('SetSelection.from').name = 'from_' c.find('SetSelection.to').name = 'to_' c.find('SetListStyle.def').name = 'styleDef' c.find('ApplyStyle.def').name = 'styleDef' c.addPyMethod('GetDefaultStyle', '(self)', 'return self.GetDefaultStyleEx()', deprecated='Use GetDefaultStyleEx instead') # Make sure that all the methods from wxTextEntry are included. This is # needed because we are pretending that this class only derives from # wxControl but the real C++ class also derives from wxTextCtrlIface # which derives from wxTextEntryBase. import textentry mod = textentry.parseAndTweakModule() klass = mod.find('wxTextEntry') items = [ item for item in klass.items if isinstance(item, etgtools.MethodDef) and not item.isCtor and not item.isDtor and not c.findItem(item.name) ] c.items.extend(items) # TODO: What about the wxScrollHelper base class #----------------------------------------------------------------- c = module.find('wxRichTextEvent') tools.fixEventClass(c) module.addPyCode("""\ EVT_RICHTEXT_LEFT_CLICK = wx.PyEventBinder(wxEVT_RICHTEXT_LEFT_CLICK) EVT_RICHTEXT_RIGHT_CLICK = wx.PyEventBinder(wxEVT_RICHTEXT_RIGHT_CLICK) EVT_RICHTEXT_MIDDLE_CLICK = wx.PyEventBinder(wxEVT_RICHTEXT_MIDDLE_CLICK) EVT_RICHTEXT_LEFT_DCLICK = wx.PyEventBinder(wxEVT_RICHTEXT_LEFT_DCLICK) EVT_RICHTEXT_RETURN = wx.PyEventBinder(wxEVT_RICHTEXT_RETURN) EVT_RICHTEXT_CHARACTER = wx.PyEventBinder(wxEVT_RICHTEXT_CHARACTER) EVT_RICHTEXT_DELETE = wx.PyEventBinder(wxEVT_RICHTEXT_DELETE) EVT_RICHTEXT_STYLESHEET_CHANGING = wx.PyEventBinder(wxEVT_RICHTEXT_STYLESHEET_CHANGING) EVT_RICHTEXT_STYLESHEET_CHANGED = wx.PyEventBinder(wxEVT_RICHTEXT_STYLESHEET_CHANGED) EVT_RICHTEXT_STYLESHEET_REPLACING = wx.PyEventBinder(wxEVT_RICHTEXT_STYLESHEET_REPLACING) EVT_RICHTEXT_STYLESHEET_REPLACED = wx.PyEventBinder(wxEVT_RICHTEXT_STYLESHEET_REPLACED) EVT_RICHTEXT_CONTENT_INSERTED = wx.PyEventBinder(wxEVT_RICHTEXT_CONTENT_INSERTED) EVT_RICHTEXT_CONTENT_DELETED = wx.PyEventBinder(wxEVT_RICHTEXT_CONTENT_DELETED) EVT_RICHTEXT_STYLE_CHANGED = wx.PyEventBinder(wxEVT_RICHTEXT_STYLE_CHANGED) EVT_RICHTEXT_STYLE_CHANGED = wx.PyEventBinder(wxEVT_RICHTEXT_PROPERTIES_CHANGED) EVT_RICHTEXT_SELECTION_CHANGED = wx.PyEventBinder(wxEVT_RICHTEXT_SELECTION_CHANGED) EVT_RICHTEXT_BUFFER_RESET = wx.PyEventBinder(wxEVT_RICHTEXT_BUFFER_RESET) EVT_RICHTEXT_FOCUS_OBJECT_CHANGED = wx.PyEventBinder(wxEVT_RICHTEXT_FOCUS_OBJECT_CHANGED) """) #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxPGCellData') assert isinstance(c, etgtools.ClassDef) c.find('~wxPGCellData').ignore(False) c = module.find('wxPGAttributeStorage') # TODO: Add methods to add a Python iterator using these methods c.find('StartIteration').ignore() c.find('GetNext').ignore() c.find('const_iterator').ignore() c = module.find('wxPGProperty') tools.ignoreConstOverloads(c) c.find('StringToValue.variant').out = True c.find('IntToValue.variant').out = True # TODO: Some other wxPGProperty methods should be pythonized a bit... c = module.find('wxPGChoicesData') tools.ignoreConstOverloads(c) #c.addDtor() c.find('~wxPGChoicesData').ignore(False) c = module.find('wxPGChoices') c.find('wxPGChoices').findOverload('wxChar **').ignore() tools.ignoreConstOverloads(c) # Ignore some string constants (#defines) coming from dox, and add them # back in Python code. They are wchar_t* values and this seemed the # simplest way to deal with them. for name in [ 'wxPG_ATTR_DEFAULT_VALUE', 'wxPG_ATTR_MIN', 'wxPG_ATTR_MAX', 'wxPG_ATTR_UNITS', 'wxPG_ATTR_HINT', 'wxPG_ATTR_INLINE_HELP', 'wxPG_ATTR_AUTOCOMPLETE', 'wxPG_BOOL_USE_CHECKBOX', 'wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING', 'wxPG_FLOAT_PRECISION', 'wxPG_STRING_PASSWORD', 'wxPG_UINT_BASE', 'wxPG_UINT_PREFIX', 'wxPG_FILE_WILDCARD', 'wxPG_FILE_SHOW_FULL_PATH', 'wxPG_FILE_SHOW_RELATIVE_PATH', 'wxPG_FILE_INITIAL_PATH', 'wxPG_FILE_DIALOG_TITLE', 'wxPG_FILE_DIALOG_STYLE', 'wxPG_DIR_DIALOG_MESSAGE', 'wxPG_ARRAY_DELIMITER', 'wxPG_DATE_FORMAT', 'wxPG_DATE_PICKER_STYLE', 'wxPG_ATTR_SPINCTRL_STEP', 'wxPG_ATTR_SPINCTRL_WRAP', 'wxPG_ATTR_SPINCTRL_MOTIONSPIN', 'wxPG_ATTR_MULTICHOICE_USERSTRINGMODE', 'wxPG_COLOUR_ALLOW_CUSTOM', 'wxPG_COLOUR_HAS_ALPHA', # and some other #defines with similar issues 'wxNullProperty', 'wxPGChoicesEmptyData', ]: module.find(name).ignore() module.addPyCode("""\ PG_ATTR_DEFAULT_VALUE = u"DefaultValue" PG_ATTR_MIN = u"Min" PG_ATTR_MAX = u"Max" PG_ATTR_UNITS = u"Units" PG_ATTR_HINT = u"Hint" PG_ATTR_INLINE_HELP = u"InlineHelp" PG_ATTR_AUTOCOMPLETE = u"AutoComplete" PG_BOOL_USE_CHECKBOX = u"UseCheckbox" PG_BOOL_USE_DOUBLE_CLICK_CYCLING = u"UseDClickCycling" PG_FLOAT_PRECISION = u"Precision" PG_STRING_PASSWORD = u"Password" PG_UINT_BASE = u"Base" PG_UINT_PREFIX = u"Prefix" PG_FILE_WILDCARD = u"Wildcard" PG_FILE_SHOW_FULL_PATH = u"ShowFullPath" PG_FILE_SHOW_RELATIVE_PATH = u"ShowRelativePath" PG_FILE_INITIAL_PATH = u"InitialPath" PG_FILE_DIALOG_TITLE = u"DialogTitle" PG_FILE_DIALOG_STYLE = u"DialogStyle" PG_DIR_DIALOG_MESSAGE = u"DialogMessage" PG_ARRAY_DELIMITER = u"Delimiter" PG_DATE_FORMAT = u"DateFormat" PG_DATE_PICKER_STYLE = u"PickerStyle" PG_ATTR_SPINCTRL_STEP = u"Step" PG_ATTR_SPINCTRL_WRAP = u"Wrap" PG_ATTR_SPINCTRL_MOTIONSPIN = u"MotionSpin" PG_ATTR_MULTICHOICE_USERSTRINGMODE= u"UserStringMode" PG_COLOUR_ALLOW_CUSTOM = u"AllowCustom" PG_COLOUR_HAS_ALPHA = u"HasAlpha" NullProperty = None PGChoicesEmptyData = None """) #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. # These are duplicates, ignore the ones in this module module.find('wxPG_PROPERTYVALUES_FLAGS').ignore() module.find('wxPG_LABEL').ignore() module.find('wxPG_LABEL_STRING').ignore() module.find('wxPG_COLOUR_BLACK').ignore() module.find('wxPG_COLOUR').ignore() module.find('wxPG_DEFAULT_IMAGE_SIZE').ignore() #---------------------------------------------------------- c = module.find('wxPGPropArgCls') assert isinstance(c, etgtools.ClassDef) c.find('wxPGPropArgCls').findOverload('wxString &').ignore() c.find('wxPGPropArgCls').findOverload('char *').ignore() c.find('wxPGPropArgCls').findOverload('wchar_t *').ignore() c.find('wxPGPropArgCls').findOverload('int').ignore() c.find('wxPGPropArgCls').findOverload('deallocPtr').ignore() # Make a string ctor that uses the wxPython-specific version of # the C++ class' ctor newCtor = c.addCppCtor('(const wxString& str)', doc="Creates a PGPropArgCls from a string.", body="""\ wxString* name = new wxString(*str); return new wxPGPropArgCls(name, true); """) # Make it be the first overload instead of the last ctor = c.find('wxPGPropArgCls') overloads = list(ctor.overloads) del overloads[overloads.index(newCtor)] overloads.insert(0, newCtor) ctor.overloads = overloads c.find('GetPtr').overloads[0].ignore() c.convertFromPyObject = """\ // Code to test a PyObject for compatibility with wxPGPropArgCls if (!sipIsErr) { if (sipCanConvertToType(sipPy, sipType_wxPGPropArgCls, SIP_NO_CONVERTORS)) return TRUE; if (PyBytes_Check(sipPy) || PyUnicode_Check(sipPy)) return TRUE; if (sipPy == Py_None) return TRUE; if (sipCanConvertToType(sipPy, sipType_wxPGProperty, SIP_NO_CONVERTORS)) return TRUE; return FALSE; } // Code to convert a compatible PyObject to a wxPGPropArgCls if (PyBytes_Check(sipPy) || PyUnicode_Check(sipPy)) { wxString* name = new wxString(Py2wxString(sipPy)); *sipCppPtr = new wxPGPropArgCls(name, true); return sipGetState(sipTransferObj); } else if (sipCanConvertToType(sipPy, sipType_wxPGProperty, SIP_NO_CONVERTORS)) { int state = 0; wxPGProperty* prop = reinterpret_cast<wxPGProperty*>( sipConvertToType(sipPy, sipType_wxPGProperty, sipTransferObj, SIP_NO_CONVERTORS, &state, sipIsErr)); *sipCppPtr = new wxPGPropArgCls(prop); sipReleaseType(prop, sipType_wxPGProperty, state); return sipGetState(sipTransferObj); } else if (sipPy == Py_None) { *sipCppPtr = new wxPGPropArgCls(static_cast< wxPGProperty * >(NULL)); return sipGetState(sipTransferObj); } else { // It's already a wxPGPropArgCls, just fetch the pointer and return *sipCppPtr = reinterpret_cast<wxPGPropArgCls*>(sipConvertToType( sipPy, sipType_wxPGPropArgCls, sipTransferObj, SIP_NO_CONVERTORS, 0, sipIsErr)); return 0; // not a new instance } """ #---------------------------------------------------------- c = module.find('wxPropertyGridInterface') c.abstract = True for m in c.findAll('GetIterator'): if m.type == 'wxPropertyGridConstIterator': m.ignore() tools.ignoreConstOverloads(c) spv = c.find('SetPropertyValue') spv.findOverload('int value').ignore() spv.findOverload('wxLongLong value').ignore() spv.findOverload('wxLongLong_t value').ignore() spv.findOverload('wxULongLong value').ignore() spv.findOverload('wxULongLong_t value').ignore() spv.findOverload('wxObject *value').ignore() spv.findOverload('wchar_t *value').ignore() spv.findOverload('char *value').ignore() # Reorder SetPropertyValue overloads so the one taking a long int is not # first. Mark others that could be auto-converted from int as # "constrained" so they will only be used for that specific type. This # should result in SetPropertyValue(id, double) only used for floats and # not ints, or other things that can convert to int. spv.findOverload('bool value').find('value').constrained = True spv.findOverload('double value').find('value').constrained = True spv_long = spv.findOverload('long value') spv_long.ignore() spv.reorderOverloads() # Ensures an ignored item is not first, spv_long.ignore(False) # and then we can unignore it. c.find('Append.property').transfer = True c.find('AppendIn.newProperty').transfer = True for m in c.find('Insert').all(): m.find('newProperty').transfer = True # Fix some syntax that sip doesn't like p = c.find('GetPropertiesWithFlag.iterFlags') if p.default.startswith('('): p.default = p.default[1:-1] # Tons of Python method implementations ported from Classic... module.addPyCode("""\ _type2property = None _vt2getter = None """) c.addPyMethod('MapType', '(self, class_, factory)', doc="""\ Registers Python type/class to property mapping. :param `factory`: Property builder function/class. """, body="""\ global _type2property if _type2property is None: raise AssertionError("call only after a propertygrid or " "manager instance constructed") _type2property[class_] = factory """) c.addPyMethod('DoDefaultTypeMappings', '(self)', doc="Add built-in properties to the map.", body="""\ import sys global _type2property if _type2property is not None: return _type2property = dict() _type2property[str] = StringProperty if sys.version_info.major < 2: _type2property[unicode] = StringProperty _type2property[int] = IntProperty _type2property[float] = FloatProperty _type2property[bool] = BoolProperty _type2property[list] = ArrayStringProperty _type2property[tuple] = ArrayStringProperty _type2property[wx.Font] = FontProperty _type2property[wx.Colour] = ColourProperty #_type2property[wx.Size] = SizeProperty #_type2property[wx.Point] = PointProperty #_type2property[wx.FontData] = FontDataProperty """) # TODO: is this still needed? c.addPyMethod('DoDefaultValueTypeMappings', '(self)', doc="Map pg value type ids to getter methods.", body="""\ global _vt2getter if _vt2getter is not None: return _vt2getter = dict() """) c.find('GetPropertyValues').ignore() c.addPyMethod('GetPropertyValues', '(self, dict_=None, as_strings=False, inc_attributes=False)', doc="""\ Returns all property values in the grid.\n :param `dict_`: A to fill with the property values. If not given, then a new one is created. The dict_ can be an object as well, in which case it's __dict__ is used. :param `as_strings`: if True, then string representations of values are fetched instead of native types. Useful for config and such. :param `inc_attributes`: if True, then property attributes are added in the form of "@<propname>@<attr>". :returns: A dictionary with values. It is always a dictionary, so if dict_ was and object with __dict__ attribute, then that attribute is returned. """, body="""\ if dict_ is None: dict_ = {} elif hasattr(dict_,'__dict__'): dict_ = dict_.__dict__ getter = self.GetPropertyValue if not as_strings else self.GetPropertyValueAsString it = self.GetVIterator(PG_ITERATE_PROPERTIES) while not it.AtEnd(): p = it.GetProperty() name = p.GetName() dict_[name] = getter(p) if inc_attributes: attrs = p.GetAttributes() if attrs and len(attrs): dict_['@%s@attr'%name] = attrs it.Next() return dict_ """) for m in c.find('SetPropertyValues').all(): m.ignore() c.addPyMethod('SetPropertyValues', '(self, dict_, autofill=False)', doc="""\ Sets property values from a dictionary.\n :param `dict_`: the source of the property values to set, which can be either a dictionary or an object with a __dict__ attribute. :param `autofill`: If true, keys with not relevant properties are auto-created. For more info, see :method:`AutoFill`. :note: * Keys starting with underscore are ignored. * Attributes can be set with entries named like "@<propname>@<attr>". """, body="""\ if dict_ is None: dict_ = {} elif hasattr(dict_,'__dict__'): dict_ = dict_.__dict__ attr_dicts = [] def set_sub_obj(k0, dict_): for k,v in dict_.items(): if k[0] != '_': if k.endswith('@attr'): attr_dicts.append((k[1:-5],v)) else: try: self.SetPropertyValue(k,v) except: try: if autofill: self._AutoFillOne(k0,k,v) continue except: if isinstance(v,dict): set_sub_obj(k,v) elif hasattr(v,'__dict__'): set_sub_obj(k,v.__dict__) for k,v in attr_dicts: p = self.GetPropertyByName(k) if not p: raise AssertionError("No such property: '%s'"%k) for an,av in v.items(): p.SetAttribute(an, av) cur_page = False is_manager = isinstance(self, PropertyGridManager) try: set_sub_obj(self.GetGrid().GetRoot(), dict_) except: import traceback traceback.print_exc() self.Refresh() """) # TODO: should these be marked as deprecated? module.addPyCode("""\ PropertyGridInterface.GetValues = PropertyGridInterface.GetPropertyValues PropertyGridInterface.SetValues = PropertyGridInterface.SetPropertyValues """) c.addPyMethod('_AutoFillMany', '(self,cat,dict_)', body="""\ for k,v in dict_.items(): self._AutoFillOne(cat,k,v) """) c.addPyMethod('_AutoFillOne', '(self,cat,k,v)', body="""\ global _type2property factory = _type2property.get(v.__class__,None) if factory: self.AppendIn(cat, factory(k,k,v)) elif hasattr(v,'__dict__'): cat2 = self.AppendIn(cat, PropertyCategory(k)) self._AutoFillMany(cat2, v.__dict__) elif isinstance(v, dict): cat2 = self.AppendIn(cat, PropertyCategory(k)) self._AutoFillMany(cat2, v) elif not k.startswith('_'): raise AssertionError("member '%s' is of unregistered type/" "class '%s'"%(k,v.__class__)) """) c.addPyMethod('AutoFill', '(self, obj, parent=None)', doc="""\ "Clears properties and re-fills to match members and values of the given object or dictionary obj. """, body="""\ self.edited_objects[parent] = obj cur_page = False is_manager = isinstance(self, PropertyGridManager) if not parent: if is_manager: page = self.GetCurrentPage() page.Clear() parent = page.GetRoot() else: self.Clear() parent = self.GetGrid().GetRoot() else: it = self.GetIterator(PG_ITERATE_PROPERTIES, parent) it.Next() # Skip the parent while not it.AtEnd(): p = it.GetProperty() if not p.IsSomeParent(parent): break self.DeleteProperty(p) name = p.GetName() it.Next() if not is_manager or page == self.GetCurrentPage(): self.Freeze() cur_page = True try: self._AutoFillMany(parent,obj.__dict__) except: import traceback traceback.print_exc() if cur_page: self.Thaw() """) c.addPyMethod('RegisterEditor', '(self, editor, editorName=None)', doc="Register a new editor, either an instance or a class.", body="""\ if not isinstance(editor, PGEditor): editor = editor() if not editorName: editorName = editor.__class__.__name__ try: self._editor_instances.append(editor) except: self._editor_instances = [editor] return PropertyGrid.DoRegisterEditorClass(editor, editorName) """) c.find('GetPropertyClientData').ignore() c.addPyMethod('GetPropertyClientData', '(self, p)', body="""\ if isinstance(p, str): p = self.GetPropertyByName(p) return p.GetClientData() """) c.find('SetPropertyClientData').ignore() c.addPyMethod('SetPropertyClientData', '(self, p, data)', body="""\ if isinstance(p, str): p = self.GetPropertyByName(p) return p.SetClientData(data) """) c.addPyMethod('GetPyIterator', '(self, flags=PG_ITERATE_DEFAULT, firstProperty=None)', doc="""\ Returns a pythonic property iterator for a single :ref:`PropertyGrid` or page in :ref:`PropertyGridManager`. Arguments are same as for :ref:`GetIterator`. The following example demonstrates iterating absolutely all items in a single grid:: iterator = propGrid.GetPyIterator(wx.propgrid.PG_ITERATE_ALL) for prop in iterator: print(prop) :see: `wx.propgrid.PropertyGridInterface.Properties` `wx.propgrid.PropertyGridInterface.Items` """, body="""\ it = self.GetIterator(flags, firstProperty) while not it.AtEnd(): yield it.GetProperty() it.Next() """) c.addPyMethod('GetPyVIterator', '(self, flags=PG_ITERATE_DEFAULT)', doc="""\ Similar to :ref:`GetVIterator` but returns a pythonic iterator. """, body="""\ it = self.GetVIterator(flags) while not it.AtEnd(): yield it.GetProperty() it.Next() """) c.addPyMethod('_Properties', '(self)', doc="""\ This attribute is a pythonic iterator over all properties in this `PropertyGrid` property container. It will only skip categories and private child properties. Usage is simple:: for prop in propGrid.Properties: print(prop) :see: `wx.propgrid.PropertyGridInterface.Items` `wx.propgrid.PropertyGridInterface.GetPyIterator` """, body="""\ it = self.GetIterator(PG_ITERATE_NORMAL) while not it.AtEnd(): yield it.GetProperty() it.Next() """) c.addPyProperty('Properties', '_Properties') c.addPyMethod('_Items', '(self)', doc="""\ This attribute is a pythonic iterator over all items in this `PropertyGrid` property container, excluding only private child properties. Usage is simple:: for prop in propGrid.Items: print(prop) :see: `wx.propgrid.PropertyGridInterface.Properties` `wx.propgrid.PropertyGridInterface.GetPyVIterator` """, body="""\ it = self.GetVIterator(PG_ITERATE_NORMAL | PG_ITERATE_CATEGORIES) while not it.AtEnd(): yield it.GetProperty() it.Next() """) c.addPyProperty('Items', '_Items') #---------------------------------------------------------- module.addItem( tools.wxArrayPtrWrapperTemplate('wxArrayPGProperty', 'wxPGProperty', module)) # wxPGPropArg is a typedef for "const wxPGPropArgCls&" so having the # wrappers treat it as a normal type can be problematic. ("new cannot be # applied to a reference type", etc.) Let's just ignore it and replace it # everywhere for the real type. module.find('wxPGPropArg').ignore() for item in module.allItems(): if hasattr(item, 'type') and item.type == 'wxPGPropArg': item.type = 'const wxPGPropArgCls &' # Switch all wxVariant types to wxPGVariant, so the propgrid-specific # version of the MappedType will be used for converting to/from Python # objects. for item in module.allItems(): if hasattr(item, 'type') and 'wxVariant' in item.type: item.type = item.type.replace('wxVariant', 'wxPGVariant') #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. # These are duplicates, ignore the ones in this module module.find('wxPG_PROPERTYVALUES_FLAGS').ignore() module.find('wxPG_LABEL').ignore() module.find('wxPG_LABEL_STRING').ignore() module.find('wxPG_COLOUR_BLACK').ignore() module.find('wxPG_COLOUR').ignore() module.find('wxPG_DEFAULT_IMAGE_SIZE').ignore() #---------------------------------------------------------- c = module.find('wxPGPropArgCls') assert isinstance(c, etgtools.ClassDef) c.find('wxPGPropArgCls').findOverload('wxString &').ignore() c.find('wxPGPropArgCls').findOverload('char *').ignore() c.find('wxPGPropArgCls').findOverload('wchar_t *').ignore() c.find('wxPGPropArgCls').findOverload('int').ignore() c.find('wxPGPropArgCls').findOverload('deallocPtr').ignore() # Make a string ctor that uses the wxPython-specific version of # the C++ class' ctor newCtor = c.addCppCtor('(const wxString& str)', doc="Creates a PGPropArgCls from a string.", body="""\ wxString* name = new wxString(*str); return new wxPGPropArgCls(name, true); """ ) # Make it be the first overload instead of the last ctor = c.find('wxPGPropArgCls') overloads = list(ctor.overloads) del overloads[overloads.index(newCtor)] overloads.insert(0, newCtor) ctor.overloads = overloads c.find('GetPtr').overloads[0].ignore() c.convertFromPyObject = """\ // Code to test a PyObject for compatibility with wxPGPropArgCls if (!sipIsErr) { if (sipCanConvertToType(sipPy, sipType_wxPGPropArgCls, SIP_NO_CONVERTORS)) return TRUE; if (PyBytes_Check(sipPy) || PyUnicode_Check(sipPy)) return TRUE; if (sipPy == Py_None) return TRUE; if (sipCanConvertToType(sipPy, sipType_wxPGProperty, SIP_NO_CONVERTORS)) return TRUE; return FALSE; } // Code to convert a compatible PyObject to a wxPGPropArgCls if (PyBytes_Check(sipPy) || PyUnicode_Check(sipPy)) { wxString* name = new wxString(Py2wxString(sipPy)); *sipCppPtr = new wxPGPropArgCls(name, true); return sipGetState(sipTransferObj); } else if (sipCanConvertToType(sipPy, sipType_wxPGProperty, SIP_NO_CONVERTORS)) { int state = 0; wxPGProperty* prop = reinterpret_cast<wxPGProperty*>( sipConvertToType(sipPy, sipType_wxPGProperty, sipTransferObj, SIP_NO_CONVERTORS, &state, sipIsErr)); *sipCppPtr = new wxPGPropArgCls(prop); sipReleaseType(prop, sipType_wxPGProperty, state); return sipGetState(sipTransferObj); } else if (sipPy == Py_None) { *sipCppPtr = new wxPGPropArgCls(reinterpret_cast< wxPGProperty * >(NULL)); return sipGetState(sipTransferObj); } else { // It's already a wxPGPropArgCls, just fetch the pointer and return *sipCppPtr = reinterpret_cast<wxPGPropArgCls*>(sipConvertToType( sipPy, sipType_wxPGPropArgCls, sipTransferObj, SIP_NO_CONVERTORS, 0, sipIsErr)); return 0; // not a new instance } """ #---------------------------------------------------------- c = module.find('wxPropertyGridInterface') c.abstract = True for m in c.findAll('GetIterator'): if m.type == 'wxPropertyGridConstIterator': m.ignore() tools.ignoreConstOverloads(c) spv = c.find('SetPropertyValue') spv.findOverload('int value').ignore() spv.findOverload('wxLongLong_t value').ignore() spv.findOverload('wxULongLong_t value').ignore() spv.findOverload('wxObject *value').ignore() # Reorder SetPropertyValue overloads so the one taking a long int is not # first. Mark others that could be auto-converted from int as # "constrained" so they will only be used for that specific type. This # should result in SetPropertyValue(id, double) only used for floats and # not ints, or other things that can convert to int. spv.findOverload('bool value').find('value').constrained = True spv.findOverload('double value').find('value').constrained = True spv_long = spv.findOverload('long value') spv_long.ignore() spv.reorderOverloads() # Ensures an ignored item is not first, spv_long.ignore(False) # and then we can unignore it. c.find('Append.property').transfer = True c.find('AppendIn.newProperty').transfer = True for m in c.find('Insert').all(): m.find('newProperty').transfer = True # Fix some syntax that sip doesn't like p = c.find('GetPropertiesWithFlag.iterFlags') if p.default.startswith('('): p.default = p.default[1:-1] # Tons of Python method implementations ported from Classic... module.addPyCode("""\ _type2property = None _vt2getter = None """) c.addPyMethod('MapType', '(self, class_, factory)', doc="""\ Registers Python type/class to property mapping. :param `factory`: Property builder function/class. """, body="""\ global _type2property if _type2property is None: raise AssertionError("call only after a propertygrid or " "manager instance constructed") _type2property[class_] = factory """) c.addPyMethod('DoDefaultTypeMappings', '(self)', doc="Add built-in properties to the map.", body="""\ import sys global _type2property if _type2property is not None: return _type2property = dict() _type2property[str] = StringProperty if sys.version_info.major < 2: _type2property[unicode] = StringProperty _type2property[int] = IntProperty _type2property[float] = FloatProperty _type2property[bool] = BoolProperty _type2property[list] = ArrayStringProperty _type2property[tuple] = ArrayStringProperty _type2property[wx.Font] = FontProperty _type2property[wx.Colour] = ColourProperty #_type2property[wx.Size] = SizeProperty #_type2property[wx.Point] = PointProperty #_type2property[wx.FontData] = FontDataProperty """) # TODO: is this still needed? c.addPyMethod('DoDefaultValueTypeMappings', '(self)', doc="Map pg value type ids to getter methods.", body="""\ global _vt2getter if _vt2getter is not None: return _vt2getter = dict() """) c.find('GetPropertyValues').ignore() c.addPyMethod('GetPropertyValues', '(self, dict_=None, as_strings=False, inc_attributes=False)', doc="""\ Returns all property values in the grid.\n :param `dict_`: A to fill with the property values. If not given, then a new one is created. The dict_ can be an object as well, in which case it's __dict__ is used. :param `as_strings`: if True, then string representations of values are fetched instead of native types. Useful for config and such. :param `inc_attributes`: if True, then property attributes are added in the form of "@<propname>@<attr>". :returns: A dictionary with values. It is always a dictionary, so if dict_ was and object with __dict__ attribute, then that attribute is returned. """, body="""\ if dict_ is None: dict_ = {} elif hasattr(dict_,'__dict__'): dict_ = dict_.__dict__ getter = self.GetPropertyValue if not as_strings else self.GetPropertyValueAsString it = self.GetVIterator(PG_ITERATE_PROPERTIES) while not it.AtEnd(): p = it.GetProperty() name = p.GetName() dict_[name] = getter(p) if inc_attributes: attrs = p.GetAttributes() if attrs and len(attrs): dict_['@%s@attr'%name] = attrs it.Next() return dict_ """) for m in c.find('SetPropertyValues').all(): m.ignore() c.addPyMethod('SetPropertyValues', '(self, dict_, autofill=False)', doc="""\ Sets property values from a dictionary.\n :param `dict_`: the source of the property values to set, which can be either a dictionary or an object with a __dict__ attribute. :param `autofill`: If true, keys with not relevant properties are auto-created. For more info, see :method:`AutoFill`. :note: * Keys starting with underscore are ignored. * Attributes can be set with entries named like "@<propname>@<attr>". """, body="""\ if dict_ is None: dict_ = {} elif hasattr(dict_,'__dict__'): dict_ = dict_.__dict__ attr_dicts = [] def set_sub_obj(k0, dict_): for k,v in dict_.items(): if k[0] != '_': if k.endswith('@attr'): attr_dicts.append((k[1:-5],v)) else: try: self.SetPropertyValue(k,v) except: try: if autofill: self._AutoFillOne(k0,k,v) continue except: if isinstance(v,dict): set_sub_obj(k,v) elif hasattr(v,'__dict__'): set_sub_obj(k,v.__dict__) for k,v in attr_dicts: p = self.GetPropertyByName(k) if not p: raise AssertionError("No such property: '%s'"%k) for an,av in v.items(): p.SetAttribute(an, av) cur_page = False is_manager = isinstance(self, PropertyGridManager) try: set_sub_obj(self.GetGrid().GetRoot(), dict_) except: import traceback traceback.print_exc() self.Refresh() """) # TODO: should these be marked as deprecated? module.addPyCode("""\ PropertyGridInterface.GetValues = PropertyGridInterface.GetPropertyValues PropertyGridInterface.SetValues = PropertyGridInterface.SetPropertyValues """) c.addPyMethod('_AutoFillMany', '(self,cat,dict_)', body="""\ for k,v in dict_.items(): self._AutoFillOne(cat,k,v) """) c.addPyMethod('_AutoFillOne', '(self,cat,k,v)', body="""\ global _type2property factory = _type2property.get(v.__class__,None) if factory: self.AppendIn(cat, factory(k,k,v)) elif hasattr(v,'__dict__'): cat2 = self.AppendIn(cat, PropertyCategory(k)) self._AutoFillMany(cat2, v.__dict__) elif isinstance(v, dict): cat2 = self.AppendIn(cat, PropertyCategory(k)) self._AutoFillMany(cat2, v) elif not k.startswith('_'): raise AssertionError("member '%s' is of unregistered type/" "class '%s'"%(k,v.__class__)) """) c.addPyMethod('AutoFill', '(self, obj, parent=None)', doc="""\ "Clears properties and re-fills to match members and values of the given object or dictionary obj. """, body="""\ self.edited_objects[parent] = obj cur_page = False is_manager = isinstance(self, PropertyGridManager) if not parent: if is_manager: page = self.GetCurrentPage() page.Clear() parent = page.GetRoot() else: self.Clear() parent = self.GetGrid().GetRoot() else: it = self.GetIterator(PG_ITERATE_PROPERTIES, parent) it.Next() # Skip the parent while not it.AtEnd(): p = it.GetProperty() if not p.IsSomeParent(parent): break self.DeleteProperty(p) name = p.GetName() it.Next() if not is_manager or page == self.GetCurrentPage(): self.Freeze() cur_page = True try: self._AutoFillMany(parent,obj.__dict__) except: import traceback traceback.print_exc() if cur_page: self.Thaw() """) c.addPyMethod('RegisterEditor', '(self, editor, editorName=None)', doc="Register a new editor, either an instance or a class.", body="""\ if not isinstance(editor, PGEditor): editor = editor() if not editorName: editorName = editor.__class__.__name__ try: self._editor_instances.append(editor) except: self._editor_instances = [editor] return PropertyGrid.DoRegisterEditorClass(editor, editorName) """ ) c.find('GetPropertyClientData').ignore() c.addPyMethod('GetPropertyClientData', '(self, p)', body="""\ if isinstance(p, str): p = self.GetPropertyByName(p) return p.GetClientData() """) c.find('SetPropertyClientData').ignore() c.addPyMethod('SetPropertyClientData', '(self, p, data)', body="""\ if isinstance(p, str): p = self.GetPropertyByName(p) return p.SetClientData(data) """) c.addPyMethod('GetPyIterator', '(self, flags=PG_ITERATE_DEFAULT, firstProperty=None)', doc="""\ Returns a pythonic property iterator for a single :ref:`PropertyGrid` or page in :ref:`PropertyGridManager`. Arguments are same as for :ref:`GetIterator`. The following example demonstrates iterating absolutely all items in a single grid:: iterator = propGrid.GetPyIterator(wx.propgrid.PG_ITERATE_ALL) for prop in iterator: print(prop) :see: `wx.propgrid.PropertyGridInterface.Properties` `wx.propgrid.PropertyGridInterface.Items` """, body="""\ it = self.GetIterator(flags, firstProperty) while not it.AtEnd(): yield it.GetProperty() it.Next() """) c.addPyMethod('GetPyVIterator', '(self, flags=PG_ITERATE_DEFAULT)', doc="""\ Similar to :ref:`GetVIterator` but returns a pythonic iterator. """, body="""\ it = self.GetVIterator(flags) while not it.AtEnd(): yield it.GetProperty() it.Next() """) c.addPyMethod('_Properties', '(self)', doc="""\ This attribute is a pythonic iterator over all properties in this `PropertyGrid` property container. It will only skip categories and private child properties. Usage is simple:: for prop in propGrid.Properties: print(prop) :see: `wx.propgrid.PropertyGridInterface.Items` `wx.propgrid.PropertyGridInterface.GetPyIterator` """, body="""\ it = self.GetIterator(PG_ITERATE_NORMAL) while not it.AtEnd(): yield it.GetProperty() it.Next() """) c.addPyProperty('Properties', '_Properties') c.addPyMethod('_Items', '(self)', doc="""\ This attribute is a pythonic iterator over all items in this `PropertyGrid` property container, excluding only private child properties. Usage is simple:: for prop in propGrid.Items: print(prop) :see: `wx.propgrid.PropertyGridInterface.Properties` `wx.propgrid.PropertyGridInterface.GetPyVIterator` """, body="""\ it = self.GetVIterator(PG_ITERATE_NORMAL | PG_ITERATE_CATEGORIES) while not it.AtEnd(): yield it.GetProperty() it.Next() """) c.addPyProperty('Items', '_Items') #---------------------------------------------------------- module.addItem( tools.wxArrayPtrWrapperTemplate('wxArrayPGProperty', 'wxPGProperty', module)) # wxPGPropArg is a typedef for "const wxPGPropArgCls&" so having the # wrappers treat it as a normal type can be problematic. ("new cannot be # applied to a reference type", etc.) Let's just ignore it and replace it # everywhere for the real type. module.find('wxPGPropArg').ignore() for item in module.allItems(): if hasattr(item, 'type') and item.type == 'wxPGPropArg': item.type = 'const wxPGPropArgCls &' # Switch all wxVariant types to wxPGVariant, so the propgrid-specific # version of the MappedType will be used for converting to/from Python # objects. for item in module.allItems(): if hasattr(item, 'type') and 'wxVariant' in item.type: item.type = item.type.replace('wxVariant', 'wxPGVariant') #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxPGCellData') assert isinstance(c, etgtools.ClassDef) c.find('~wxPGCellData').ignore(False) c.bases = ['wxRefCounter'] c = module.find('wxPGCellRenderer') c.bases = ['wxRefCounter'] c = module.find('wxPGProperty') tools.ignoreConstOverloads(c) c.find('StringToValue.variant').out = True c.find('IntToValue.variant').out = True c.addProperty('m_value GetValue SetValue') # SIP needs to be able to make a copy of the wxPGAttributeStorage value # but the C++ class doesn't have a copy ctor and the default will cause it # to lose references to the variants it contains, so let's just override # the use of the MappedType and convert it to a Python dictionary here # instead. m = c.find('GetAttributes') m.type = 'PyObject*' m.setCppCode("""\ const wxPGAttributeStorage& attrs = self->GetAttributes(); wxPGAttributeStorage::const_iterator it = attrs.StartIteration(); wxVariant v; wxPyThreadBlocker blocker; PyObject* dict = PyDict_New(); if ( !dict ) return NULL; while ( attrs.GetNext( it, v ) ) { const wxString& name = v.GetName(); PyObject* pyStr = wx2PyString(name); PyObject* pyVal = wxPGVariant_out_helper(v); int res = PyDict_SetItem( dict, pyStr, pyVal ); } return dict; """) # SetAttributes uses wxPGAttributeStorage too, but we'll just replace it # with a simple Python method. c.find('SetAttributes').ignore() c.addPyMethod('SetAttributes', '(self, attributes)', doc="Set the property's attributes from a Python dictionary.", body="""\ for name,value in attributes.items(): self.SetAttribute(name, value) """) c.find('AddPrivateChild.prop').transfer = True c.find('AddChild.prop').transfer = True # The [G|S]etClientData methods deal with untyped void* values, which we # don't support. The [G|S]etClientObject methods use wxClientData instances # which we have a MappedType for, so make the ClientData methods just be # aliases for ClientObjects. From the Python programmer's perspective they # would be virtually the same anyway. c.find('SetClientObject.clientObject').transfer = True c.find('SetClientObject.clientObject').name = 'data' c.find('GetClientData').ignore() c.find('SetClientData').ignore() c.find('GetClientObject').pyName = 'GetClientData' c.find('SetClientObject').pyName = 'SetClientData' c.addPyMethod('GetClientObject', '(self, n)', doc="Alias for :meth:`GetClientData`", body="return self.GetClientData(n)") c.addPyMethod('SetClientObject', '(self, n, data)', doc="Alias for :meth:`SetClientData`", body="self.SetClientData(n, data)") c = module.find('wxPGChoicesData') tools.ignoreConstOverloads(c) c.bases = ['wxRefCounter'] c.find('~wxPGChoicesData').ignore(False) c = module.find('wxPGChoices') c.find('wxPGChoices').findOverload('wxChar **').ignore() tools.ignoreConstOverloads(c) c.find('operator[]').ignore() c.addPyMethod('__getitem__', '(self, index)', doc="Returns a reference to a :class:PGChoiceEntry using Python list syntax.", body="return self.Item(index)", ) c.addPyMethod('__len__', '(self)', doc="", body="return self.GetCount()", ) # Ignore some string constants (#defines) coming from dox, and add them # back in Python code. They are wchar_t* values and this seemed the # simplest way to deal with them. for name in [ 'wxPG_ATTR_DEFAULT_VALUE', 'wxPG_ATTR_MIN', 'wxPG_ATTR_MAX', 'wxPG_ATTR_UNITS', 'wxPG_ATTR_HINT', 'wxPG_ATTR_INLINE_HELP', 'wxPG_ATTR_AUTOCOMPLETE', 'wxPG_BOOL_USE_CHECKBOX', 'wxPG_BOOL_USE_DOUBLE_CLICK_CYCLING', 'wxPG_FLOAT_PRECISION', 'wxPG_STRING_PASSWORD', 'wxPG_UINT_BASE', 'wxPG_UINT_PREFIX', 'wxPG_FILE_WILDCARD', 'wxPG_FILE_SHOW_FULL_PATH', 'wxPG_FILE_SHOW_RELATIVE_PATH', 'wxPG_FILE_INITIAL_PATH', 'wxPG_FILE_DIALOG_TITLE', 'wxPG_FILE_DIALOG_STYLE', 'wxPG_DIR_DIALOG_MESSAGE', 'wxPG_ARRAY_DELIMITER', 'wxPG_DATE_FORMAT', 'wxPG_DATE_PICKER_STYLE', 'wxPG_ATTR_SPINCTRL_STEP', 'wxPG_ATTR_SPINCTRL_WRAP', 'wxPG_ATTR_SPINCTRL_MOTIONSPIN', 'wxPG_ATTR_MULTICHOICE_USERSTRINGMODE', 'wxPG_COLOUR_ALLOW_CUSTOM', 'wxPG_COLOUR_HAS_ALPHA', # and some other #defines with similar issues 'wxNullProperty', 'wxPGChoicesEmptyData', ]: module.find(name).ignore() module.addPyCode("""\ PG_ATTR_DEFAULT_VALUE = u"DefaultValue" PG_ATTR_MIN = u"Min" PG_ATTR_MAX = u"Max" PG_ATTR_UNITS = u"Units" PG_ATTR_HINT = u"Hint" PG_ATTR_INLINE_HELP = u"InlineHelp" PG_ATTR_AUTOCOMPLETE = u"AutoComplete" PG_BOOL_USE_CHECKBOX = u"UseCheckbox" PG_BOOL_USE_DOUBLE_CLICK_CYCLING = u"UseDClickCycling" PG_FLOAT_PRECISION = u"Precision" PG_STRING_PASSWORD = u"Password" PG_UINT_BASE = u"Base" PG_UINT_PREFIX = u"Prefix" PG_FILE_WILDCARD = u"Wildcard" PG_FILE_SHOW_FULL_PATH = u"ShowFullPath" PG_FILE_SHOW_RELATIVE_PATH = u"ShowRelativePath" PG_FILE_INITIAL_PATH = u"InitialPath" PG_FILE_DIALOG_TITLE = u"DialogTitle" PG_FILE_DIALOG_STYLE = u"DialogStyle" PG_DIR_DIALOG_MESSAGE = u"DialogMessage" PG_ARRAY_DELIMITER = u"Delimiter" PG_DATE_FORMAT = u"DateFormat" PG_DATE_PICKER_STYLE = u"PickerStyle" PG_ATTR_SPINCTRL_STEP = u"Step" PG_ATTR_SPINCTRL_WRAP = u"Wrap" PG_ATTR_SPINCTRL_MOTIONSPIN = u"MotionSpin" PG_ATTR_MULTICHOICE_USERSTRINGMODE= u"UserStringMode" PG_COLOUR_ALLOW_CUSTOM = u"AllowCustom" PG_COLOUR_HAS_ALPHA = u"HasAlpha" NullProperty = None PGChoicesEmptyData = None """) # Switch all wxVariant types to wxPGVariant, so the propgrid-specific # version of the MappedType will be used for converting to/from Python # objects. for item in module.allItems(): if hasattr(item, 'type') and 'wxVariant' in item.type: item.type = item.type.replace('wxVariant', 'wxPGVariant') #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. #----------------------------------------------------------------- # ignore some macros since most of this set are not simple numbers for item in module.items: if item.name.startswith('wxRICHTEXT_DEFAULT'): item.ignore() #----------------------------------------------------------------- c = module.find('wxRichTextContextMenuPropertiesInfo') assert isinstance(c, etgtools.ClassDef) tools.ignoreConstOverloads(c) #----------------------------------------------------------------- c = module.find('wxRichTextCtrl') tools.fixWindowClass(c) c.bases = ['wxControl'] # wxTextCtrlIface, wxScrollHelper are also bases... c.find('GetSelection').findOverload('from').ignore() tools.ignoreConstOverloads(c) c.find('PositionToXY.x').out = True c.find('PositionToXY.y').out = True c.find('HitTest.pos').out = True c.find('HitTest.col').out = True c.find('HitTest.row').out = True c.find('HitTest').renameOverload('row', 'HitTestXY') c.find('GetRange.from').name = 'from_' c.find('GetRange.to').name = 'to_' c.find('Remove.from').name = 'from_' c.find('Remove.to').name = 'to_' c.find('Replace.from').name = 'from_' c.find('Replace.to').name = 'to_' c.find('SetSelection.from').name = 'from_' c.find('SetSelection.to').name = 'to_' c.find('SetListStyle.def').name = 'styleDef' c.find('ApplyStyle.def').name = 'styleDef' c.addPyMethod('GetDefaultStyle', '(self)', 'return self.GetDefaultStyleEx()', deprecated='Use GetDefaultStyleEx instead') # Make sure that all the methods from wxTextEntry are included. This is # needed because we are pretending that this class only derives from # wxControl but the real C++ class also derives from wxTextCtrlIface # which derives from wxTextEntryBase. import textentry mod = textentry.parseAndTweakModule() klass = mod.find('wxTextEntry') items = [item for item in klass.items if isinstance(item, etgtools.MethodDef) and not item.isCtor and not item.isDtor and not c.findItem(item.name)] c.items.extend(items) # TODO: What about the wxScrollHelper base class #----------------------------------------------------------------- c = module.find('wxRichTextEvent') tools.fixEventClass(c) module.addPyCode("""\ EVT_RICHTEXT_LEFT_CLICK = wx.PyEventBinder(wxEVT_RICHTEXT_LEFT_CLICK) EVT_RICHTEXT_RIGHT_CLICK = wx.PyEventBinder(wxEVT_RICHTEXT_RIGHT_CLICK) EVT_RICHTEXT_MIDDLE_CLICK = wx.PyEventBinder(wxEVT_RICHTEXT_MIDDLE_CLICK) EVT_RICHTEXT_LEFT_DCLICK = wx.PyEventBinder(wxEVT_RICHTEXT_LEFT_DCLICK) EVT_RICHTEXT_RETURN = wx.PyEventBinder(wxEVT_RICHTEXT_RETURN) EVT_RICHTEXT_CHARACTER = wx.PyEventBinder(wxEVT_RICHTEXT_CHARACTER) EVT_RICHTEXT_DELETE = wx.PyEventBinder(wxEVT_RICHTEXT_DELETE) EVT_RICHTEXT_STYLESHEET_CHANGING = wx.PyEventBinder(wxEVT_RICHTEXT_STYLESHEET_CHANGING) EVT_RICHTEXT_STYLESHEET_CHANGED = wx.PyEventBinder(wxEVT_RICHTEXT_STYLESHEET_CHANGED) EVT_RICHTEXT_STYLESHEET_REPLACING = wx.PyEventBinder(wxEVT_RICHTEXT_STYLESHEET_REPLACING) EVT_RICHTEXT_STYLESHEET_REPLACED = wx.PyEventBinder(wxEVT_RICHTEXT_STYLESHEET_REPLACED) EVT_RICHTEXT_CONTENT_INSERTED = wx.PyEventBinder(wxEVT_RICHTEXT_CONTENT_INSERTED) EVT_RICHTEXT_CONTENT_DELETED = wx.PyEventBinder(wxEVT_RICHTEXT_CONTENT_DELETED) EVT_RICHTEXT_STYLE_CHANGED = wx.PyEventBinder(wxEVT_RICHTEXT_STYLE_CHANGED) EVT_RICHTEXT_STYLE_CHANGED = wx.PyEventBinder(wxEVT_RICHTEXT_PROPERTIES_CHANGED) EVT_RICHTEXT_SELECTION_CHANGED = wx.PyEventBinder(wxEVT_RICHTEXT_SELECTION_CHANGED) EVT_RICHTEXT_BUFFER_RESET = wx.PyEventBinder(wxEVT_RICHTEXT_BUFFER_RESET) EVT_RICHTEXT_FOCUS_OBJECT_CHANGED = wx.PyEventBinder(wxEVT_RICHTEXT_FOCUS_OBJECT_CHANGED) """); #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. module.addHeaderCode('#include <wx/richtext/richtextbuffer.h>') module.addItem( tools.wxArrayWrapperTemplate('wxRichTextRangeArray', 'wxRichTextRange', module)) module.addItem( tools.wxArrayWrapperTemplate('wxRichTextAttrArray', 'wxRichTextAttr', module)) module.addItem( tools.wxArrayWrapperTemplate('wxRichTextVariantArray', 'wxVariant', module)) module.addItem( tools.wxListWrapperTemplate('wxRichTextObjectList', 'wxRichTextObject', module)) module.addItem( tools.wxListWrapperTemplate('wxRichTextLineList', 'wxRichTextLine', module)) # Can this even work? Apparently it does. module.addItem( tools.wxArrayPtrWrapperTemplate('wxRichTextObjectPtrArray', 'wxRichTextObject', module)) module.addItem( tools.wxArrayWrapperTemplate('wxRichTextObjectPtrArrayArray', 'wxRichTextObjectPtrArray', module)) module.find('wxRICHTEXT_ALL').ignore() module.find('wxRICHTEXT_NONE').ignore() module.find('wxRICHTEXT_NO_SELECTION').ignore() code = etgtools.PyCodeDef("""\ RICHTEXT_ALL = RichTextRange(-2, -2) RICHTEXT_NONE = RichTextRange(-1, -1) RICHTEXT_NO_SELECTION = RichTextRange(-2, -2) """) module.insertItemAfter(module.find('wxRichTextRange'), code) module.insertItem(0, etgtools.WigCode("""\ // forward declarations class wxRichTextFloatCollector; """)) #------------------------------------------------------- c = module.find('wxTextAttrDimension') assert isinstance(c, etgtools.ClassDef) c.find('SetValue').findOverload('units').ignore() c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextAttrDimensions') tools.ignoreConstOverloads(c) c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextAttrSize') tools.ignoreConstOverloads(c) c.find('SetWidth').findOverload('units').ignore() c.find('SetHeight').findOverload('units').ignore() c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextAttrBorder') tools.ignoreConstOverloads(c) c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextAttrBorders') tools.ignoreConstOverloads(c) c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextBoxAttr') tools.ignoreConstOverloads(c) #------------------------------------------------------- c = module.find('wxRichTextAttr') tools.ignoreConstOverloads(c) #------------------------------------------------------- c = module.find('wxRichTextProperties') tools.ignoreConstOverloads(c) c.find('SetProperty').findOverload('bool').ignore() c.find('operator[]').ignore() #------------------------------------------------------- c = module.find('wxRichTextSelection') tools.ignoreConstOverloads(c) c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") c.find('operator[]').ignore() #------------------------------------------------------- c = module.find('wxRichTextRange') tools.addAutoProperties(c) # wxRichTextRange typemap c.convertFromPyObject = tools.convertTwoIntegersTemplate('wxRichTextRange') c.addCppMethod('PyObject*', 'Get', '()', """\ wxPyThreadBlocker blocker; return sipBuildResult(0, "(ii)", self->GetStart(), self->GetEnd()); """, pyArgsString="() -> (start, end)", briefDoc="Return the start and end properties as a tuple.") tools.addGetIMMethodTemplate(module, c, ['Start', 'End']) # Add sequence protocol methods and other goodies c.addPyMethod('__str__', '(self)', 'return str(self.Get())') c.addPyMethod('__repr__', '(self)', 'return "RichTextRange"+str(self.Get())') c.addPyMethod('__len__', '(self)', 'return len(self.Get())') c.addPyMethod('__nonzero__', '(self)', 'return self.Get() != (0,0)') c.addPyMethod('__reduce__', '(self)', 'return (RichTextRange, self.Get())') c.addPyMethod('__getitem__', '(self, idx)', 'return self.Get()[idx]') c.addPyMethod('__setitem__', '(self, idx, val)', """\ if idx == 0: self.Start = val elif idx == 1: self.End = val else: raise IndexError """) c.addPyCode('RichTextRange.__safe_for_unpickling__ = True') #------------------------------------------------------- def _fixDrawObject(c, addMissingVirtuals=True): assert isinstance(c, etgtools.ClassDef) if c.findItem('HitTest'): c.find('HitTest.textPosition').out = True c.find('HitTest.obj').out = True c.find('HitTest.contextObj').out = True if c.findItem('FindPosition'): c.find('FindPosition.pt').out = True c.find('FindPosition.height').out = True if c.findItem('GetBoxRects'): c.find('GetBoxRects.marginRect').out = True c.find('GetBoxRects.borderRect').out = True c.find('GetBoxRects.contentRect').out = True c.find('GetBoxRects.paddingRect').out = True c.find('GetBoxRects.outlineRect').out = True if c.findItem('GetTotalMargin'): c.find('GetTotalMargin.leftMargin').out = True c.find('GetTotalMargin.rightMargin').out = True c.find('GetTotalMargin.topMargin').out = True c.find('GetTotalMargin.bottomMargin').out = True if c.findItem('CalculateRange'): c.find('CalculateRange.end').out = True # TODO: should it be an inOut? if c.findItem('Clone'): c.find('Clone').factory = True else: c.addItem(etgtools.WigCode("""\ virtual wxRichTextObject* Clone() const /Factory/; """)) # These are the pure virtuals in the base class. SIP needs to see that # all the derived classes have an implementation, otherwise it will # consider them to be ABCs. if not c.findItem('Draw') and addMissingVirtuals: c.addItem(etgtools.WigCode("""\ virtual bool Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);""")) if not c.findItem('Layout') and addMissingVirtuals: c.addItem(etgtools.WigCode("""\ virtual bool Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style);""")) # TODO: Some of these args are output parameters. How should they be dealt with? if not c.findItem('GetRangeSize') and addMissingVirtuals: c.addItem(etgtools.WigCode("""\ virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, const wxPoint& position = wxPoint(0,0), const wxSize& parentSize = wxDefaultSize, wxArrayInt* partialExtents = NULL) const;""")) #------------------------------------------------------- c = module.find('wxRichTextObject') #c.find('ImportFromXML').ignore() tools.ignoreConstOverloads(c) _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextCompositeObject') tools.ignoreConstOverloads(c) _fixDrawObject(c, addMissingVirtuals=False) #------------------------------------------------------- c = module.find('wxRichTextParagraphLayoutBox') tools.ignoreConstOverloads(c) _fixDrawObject(c) c.find('MoveAnchoredObjectToParagraph.from').name = 'from_' c.find('MoveAnchoredObjectToParagraph.to').name = 'to_' c.find('DoNumberList.def').name = 'styleDef' c.find('SetListStyle.def').name = 'styleDef' #------------------------------------------------------- c = module.find('wxRichTextBox') _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextCell') _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextField') _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextLine') tools.ignoreConstOverloads(c) c.find('SetRange.from').name = 'from_' c.find('SetRange.to').name = 'to_' c.find('Clone').factory = True #------------------------------------------------------- c = module.find('wxRichTextParagraph') _fixDrawObject(c) # These methods use an untyped wxList, but since we know what is in it # we'll make a fake typed list for wxPython so we can know what kinds of # values to get from it. module.addItem( tools.wxListWrapperTemplate('wxList', 'wxRichTextObject', module, fakeListClassName='wxRichTextObjectList_')) c.find('MoveToList.list').type = 'wxRichTextObjectList_&' c.find('MoveFromList.list').type = 'wxRichTextObjectList_&' #------------------------------------------------------- c = module.find('wxRichTextPlainText') _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextImage') _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextBuffer') tools.ignoreConstOverloads(c) _fixDrawObject(c) # More untyped wxLists module.addItem( tools.wxListWrapperTemplate('wxList', 'wxRichTextFileHandler', module, fakeListClassName='wxRichTextFileHandlerList')) c.find('GetHandlers').type = 'wxRichTextFileHandlerList&' c.find('GetHandlers').noCopy = True module.addItem( tools.wxListWrapperTemplate('wxList', 'wxRichTextDrawingHandler', module, fakeListClassName='wxRichTextDrawingHandlerList')) c.find('GetDrawingHandlers').type = 'wxRichTextDrawingHandlerList&' c.find('GetDrawingHandlers').noCopy = True # TODO: Need a template to wrap STRING_HASH_MAP c.find('GetFieldTypes').ignore() c.find('AddHandler.handler').transfer = True c.find('InsertHandler.handler').transfer = True c.find('AddDrawingHandler.handler').transfer = True c.find('InsertDrawingHandler.handler').transfer = True c.find('AddFieldType.fieldType').transfer = True # TODO: Transfer ownership with AddEventHandler? TransferBack with Remove? c.find('FindHandler').renameOverload('name', 'FindHandlerByName') c.find('FindHandler').renameOverload('extension', 'FindHandlerByExtension') c.find('FindHandler').pyName = 'FindHandlerByType' c.find('FindHandlerFilenameOrType').pyName = 'FindHandlerByFilename' c.find('GetExtWildcard').ignore() c.addCppMethod('PyObject*', 'GetExtWildcard', '(bool combine=false, bool save=false)', doc="""\ Gets a wildcard string for the file dialog based on all the currently loaded richtext file handlers, and a list that can be used to map those filter types to the file handler type.""", body="""\ wxString wildcards; wxArrayInt types; wildcards = wxRichTextBuffer::GetExtWildcard(combine, save, &types); wxPyThreadBlocker blocker; PyObject* list = PyList_New(0); for (size_t i=0; i < types.GetCount(); i++) { PyObject* number = wxPyInt_FromLong(types[i]); PyList_Append(list, number); Py_DECREF(number); } PyObject* tup = PyTuple_New(2); PyTuple_SET_ITEM(tup, 0, wx2PyString(wildcards)); PyTuple_SET_ITEM(tup, 1, list); return tup; """, isStatic=True) #------------------------------------------------------- c = module.find('wxRichTextTable') tools.ignoreConstOverloads(c) _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextObjectAddress') tools.ignoreConstOverloads(c) #------------------------------------------------------- c = module.find('wxRichTextCommand') module.addItem( tools.wxListWrapperTemplate('wxList', 'wxRichTextAction', module, fakeListClassName='wxRichTextActionList')) c.find('GetActions').type = 'wxRichTextActionList&' c.find('GetActions').noCopy = True c.find('AddAction.action').transfer = True #------------------------------------------------------- c = module.find('wxRichTextAction') tools.ignoreConstOverloads(c) #------------------------------------------------------- c = module.find('wxRichTextFileHandler') c.find('DoLoadFile').ignore(False) c.find('DoSaveFile').ignore(False) c = module.find('wxRichTextPlainTextHandler') c.find('DoLoadFile').ignore(False) c.find('DoSaveFile').ignore(False) #------------------------------------------------------- # Ignore all Dump() methods since we don't wrap wxTextOutputStream. # TODO: try swithcing the parameter type to wxOutputStream and then in # the wrapper code create a wxTextOutputStream from that to pass on to # Dump. for m in module.findAll('Dump'): if m.findItem('stream'): m.ignore() # Correct the type for this define as it is a float module.find('wxSCRIPT_MUL_FACTOR').type = 'float' #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. module.addHeaderCode('#include <wx/richtext/richtextbuffer.h>') module.addItem( tools.wxArrayWrapperTemplate('wxRichTextRangeArray', 'wxRichTextRange', module)) module.addItem( tools.wxArrayWrapperTemplate('wxRichTextAttrArray', 'wxRichTextAttr', module)) module.addItem( tools.wxArrayWrapperTemplate('wxRichTextVariantArray', 'wxVariant', module)) module.addItem( tools.wxListWrapperTemplate('wxRichTextObjectList', 'wxRichTextObject', module)) module.addItem( tools.wxListWrapperTemplate('wxRichTextLineList', 'wxRichTextLine', module)) # Can this even work? Apparently it does. module.addItem( tools.wxArrayPtrWrapperTemplate('wxRichTextObjectPtrArray', 'wxRichTextObject', module)) module.addItem( tools.wxArrayWrapperTemplate('wxRichTextObjectPtrArrayArray', 'wxRichTextObjectPtrArray', module)) module.find('wxRICHTEXT_ALL').ignore() module.find('wxRICHTEXT_NONE').ignore() module.find('wxRICHTEXT_NO_SELECTION').ignore() code = etgtools.PyCodeDef("""\ RICHTEXT_ALL = RichTextRange(-2, -2) RICHTEXT_NONE = RichTextRange(-1, -1) RICHTEXT_NO_SELECTION = RichTextRange(-2, -2) """) module.insertItemAfter(module.find('wxRichTextRange'), code) module.insertItem(0, etgtools.WigCode("""\ // forward declarations class wxRichTextFloatCollector; """)) #------------------------------------------------------- c = module.find('wxTextAttrDimension') assert isinstance(c, etgtools.ClassDef) c.find('SetValue').findOverload('units').ignore() c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextAttrDimensions') tools.ignoreConstOverloads(c) c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextAttrSize') tools.ignoreConstOverloads(c) c.find('SetWidth').findOverload('units').ignore() c.find('SetHeight').findOverload('units').ignore() c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextAttrBorder') tools.ignoreConstOverloads(c) c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextAttrBorders') tools.ignoreConstOverloads(c) c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") #------------------------------------------------------- c = module.find('wxTextAttrShadow') tools.ignoreConstOverloads(c) #------------------------------------------------------- c = module.find('wxTextBoxAttr') tools.ignoreConstOverloads(c) #------------------------------------------------------- c = module.find('wxRichTextAttr') tools.ignoreConstOverloads(c) #------------------------------------------------------- c = module.find('wxRichTextProperties') tools.ignoreConstOverloads(c) c.find('SetProperty').findOverload('bool').ignore() c.find('operator[]').ignore() #------------------------------------------------------- c = module.find('wxRichTextSelection') tools.ignoreConstOverloads(c) c.addCppMethod('int', '__nonzero__', '()', "return self->IsValid();") c.find('operator[]').ignore() #------------------------------------------------------- def _fixDrawObject(c, addMissingVirtuals=True): assert isinstance(c, etgtools.ClassDef) if c.findItem('HitTest'): c.find('HitTest.textPosition').out = True c.find('HitTest.obj').out = True c.find('HitTest.contextObj').out = True if c.findItem('FindPosition'): c.find('FindPosition.pt').out = True c.find('FindPosition.height').out = True if c.findItem('GetBoxRects'): c.find('GetBoxRects.marginRect').out = True c.find('GetBoxRects.borderRect').out = True c.find('GetBoxRects.contentRect').out = True c.find('GetBoxRects.paddingRect').out = True c.find('GetBoxRects.outlineRect').out = True if c.findItem('GetTotalMargin'): c.find('GetTotalMargin.leftMargin').out = True c.find('GetTotalMargin.rightMargin').out = True c.find('GetTotalMargin.topMargin').out = True c.find('GetTotalMargin.bottomMargin').out = True if c.findItem('CalculateRange'): c.find('CalculateRange.end').out = True # TODO: should it be an inOut? # This are the pure virtuals in the base class. SIP needs to see that # all the drived classes have an implementation, otherwise it will # consider them to be ABCs/ if not c.findItem('Draw') and addMissingVirtuals: c.addItem(etgtools.WigCode("""\ virtual bool Draw(wxDC& dc, wxRichTextDrawingContext& context, const wxRichTextRange& range, const wxRichTextSelection& selection, const wxRect& rect, int descent, int style);""")) if not c.findItem('Layout') and addMissingVirtuals: c.addItem(etgtools.WigCode("""\ virtual bool Layout(wxDC& dc, wxRichTextDrawingContext& context, const wxRect& rect, const wxRect& parentRect, int style);""")) # TODO: Some of these args are output parameters. How should they be dealt with? if not c.findItem('GetRangeSize') and addMissingVirtuals: c.addItem(etgtools.WigCode("""\ virtual bool GetRangeSize(const wxRichTextRange& range, wxSize& size, int& descent, wxDC& dc, wxRichTextDrawingContext& context, int flags, const wxPoint& position = wxPoint(0,0), const wxSize& parentSize = wxDefaultSize, wxArrayInt* partialExtents = NULL) const;""")) #------------------------------------------------------- c = module.find('wxRichTextObject') #c.find('ImportFromXML').ignore() tools.ignoreConstOverloads(c) _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextCompositeObject') tools.ignoreConstOverloads(c) _fixDrawObject(c, addMissingVirtuals=False) #------------------------------------------------------- c = module.find('wxRichTextParagraphLayoutBox') tools.ignoreConstOverloads(c) _fixDrawObject(c) c.find('MoveAnchoredObjectToParagraph.from').name = 'from_' c.find('MoveAnchoredObjectToParagraph.to').name = 'to_' c.find('DoNumberList.def').name = 'styleDef' c.find('SetListStyle.def').name = 'styleDef' #------------------------------------------------------- c = module.find('wxRichTextBox') _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextField') _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextLine') tools.ignoreConstOverloads(c) c.find('SetRange.from').name = 'from_' c.find('SetRange.to').name = 'to_' #------------------------------------------------------- c = module.find('wxRichTextParagraph') _fixDrawObject(c) # These methods use an untyped wxList, but since we know what is in it # we'll make a fake typed list for wxPython so we can know what kinds of # values to get from it. module.addItem( tools.wxListWrapperTemplate('wxList', 'wxRichTextObject', module, fakeListClassName='wxRichTextObjectList_')) c.find('MoveToList.list').type = 'wxRichTextObjectList_&' c.find('MoveFromList.list').type = 'wxRichTextObjectList_&' #------------------------------------------------------- c = module.find('wxRichTextPlainText') _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextImage') tools.ignoreConstOverloads(c) _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextBuffer') tools.ignoreConstOverloads(c) _fixDrawObject(c) # More untyped wxLists module.addItem( tools.wxListWrapperTemplate('wxList', 'wxRichTextFileHandler', module, fakeListClassName='wxRichTextFileHandlerList')) c.find('GetHandlers').type = 'wxRichTextFileHandlerList&' c.find('GetHandlers').noCopy = True module.addItem( tools.wxListWrapperTemplate('wxList', 'wxRichTextDrawingHandler', module, fakeListClassName='wxRichTextDrawingHandlerList')) c.find('GetDrawingHandlers').type = 'wxRichTextDrawingHandlerList&' c.find('GetDrawingHandlers').noCopy = True # TODO: Need a template to wrap STRING_HASH_MAP c.find('GetFieldTypes').ignore() c.find('AddHandler.handler').transfer = True c.find('InsertHandler.handler').transfer = True c.find('AddDrawingHandler.handler').transfer = True c.find('InsertDrawingHandler.handler').transfer = True c.find('AddFieldType.fieldType').transfer = True # TODO: Transfer ownership with AddEventHandler? TransferBack with Remove? #------------------------------------------------------- c = module.find('wxRichTextTable') tools.ignoreConstOverloads(c) _fixDrawObject(c) #------------------------------------------------------- c = module.find('wxRichTextObjectAddress') tools.ignoreConstOverloads(c) #------------------------------------------------------- c = module.find('wxRichTextCommand') module.addItem( tools.wxListWrapperTemplate('wxList', 'wxRichTextAction', module, fakeListClassName='wxRichTextActionList')) c.find('GetActions').type = 'wxRichTextActionList&' c.find('GetActions').noCopy = True c.find('AddAction.action').transfer = True #------------------------------------------------------- c = module.find('wxRichTextAction') tools.ignoreConstOverloads(c) #------------------------------------------------------- c = module.find('wxRichTextFileHandler') c.find('DoLoadFile').ignore(False) c.find('DoSaveFile').ignore(False) c = module.find('wxRichTextPlainTextHandler') c.find('DoLoadFile').ignore(False) c.find('DoSaveFile').ignore(False) #------------------------------------------------------- # Ignore all Dump() methods since we don't wrap wxTextOutputStream. # TODO: try swithcing the parameter type to wxOutputStream and then in # the wrapper code create a wxTextOutputStream from that to pass on to # Dump. for m in module.findAll('Dump'): if m.findItem('stream'): m.ignore() #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. # Use wxPyUserData for the clientData values instead of a plain wxObject def _fixClientData(c): for item in c.allItems(): if isinstance(item, etgtools.ParamDef) and item.name == 'clientData': item.type = 'wxPyUserData*' item.transfer = True #--------------------------------------------- c = module.find('wxToolBarToolBase') assert isinstance(c, etgtools.ClassDef) c.abstract = True tools.removeVirtuals(c) _fixClientData(c) # Switch all wxToolBarBase to wxToolBar for item in c.allItems(): if isinstance(item, etgtools.ParamDef) and item.name == 'tbar': item.type = 'wxToolBar*' c.find('GetToolBar').ignore() c.addCppMethod('wxToolBar*', 'GetToolBar', '()', doc="Return the toolbar this tool is a member of.", body="""\ return (wxToolBar*)self->GetToolBar(); """) gcd = c.find('GetClientData') gcd.type = 'wxPyUserData*' gcd.setCppCode('return dynamic_cast<wxPyUserData*>(self->GetClientData());') c.find('SetDropdownMenu.menu').transfer = True #--------------------------------------------- c = module.find('wxToolBar') tools.fixWindowClass(c) tools.ignoreConstOverloads(c) _fixClientData(c) module.addGlobalStr('wxToolBarNameStr', c) gcd = c.find('GetToolClientData') gcd.type = 'wxPyUserData*' gcd.setCppCode('return dynamic_cast<wxPyUserData*>(self->GetToolClientData(toolId));') c.find('AddTool.tool').transfer = True c.find('InsertTool.tool').transfer = True # Conform the help text parameters. m = c.find('AddTool') for method in m.all(): for helper in ('shortHelp', 'longHelp'): try: param = method.find("{}String".format(helper)) param.name = helper except ExtractorError: pass c.find('OnLeftClick').ignore() c.find('OnMouseEnter').ignore() c.find('OnRightClick').ignore() c.find('OnLeftClick').ignore() c.find('SetDropdownMenu.menu').transfer = True # Add some deprecated methods to aid with Classic compatibility. # TODO: Which others are commonly enough used that they should be here too? c.addPyMethod('AddSimpleTool', '(self, toolId, bitmap, shortHelpString="", longHelpString="", isToggle=0)', doc='Old style method to add a tool to the toolbar.', deprecated='Use :meth:`AddTool` instead.', body="""\ kind = wx.ITEM_NORMAL if isToggle: kind = wx.ITEM_CHECK return self.AddTool(toolId, '', bitmap, wx.NullBitmap, kind, shortHelpString, longHelpString) """) c.addPyMethod('AddLabelTool', '(self, id, label, bitmap, bmpDisabled=wx.NullBitmap, kind=wx.ITEM_NORMAL,' ' shortHelp="", longHelp="", clientData=None)', doc='Old style method to add a tool in the toolbar.', deprecated='Use :meth:`AddTool` instead.', body="""\ return self.AddTool(id, label, bitmap, bmpDisabled, kind, shortHelp, longHelp, clientData) """) c.addPyMethod('InsertSimpleTool', '(self, pos, toolId, bitmap, shortHelpString="", longHelpString="", isToggle=0)', doc='Old style method to insert a tool in the toolbar.', deprecated='Use :meth:`InsertTool` instead.', body="""\ kind = wx.ITEM_NORMAL if isToggle: kind = wx.ITEM_CHECK return self.InsertTool(pos, toolId, '', bitmap, wx.NullBitmap, kind, shortHelpString, longHelpString) """) c.addPyMethod('InsertLabelTool', '(self, pos, id, label, bitmap, bmpDisabled=wx.NullBitmap, kind=wx.ITEM_NORMAL,' ' shortHelp="", longHelp="", clientData=None)', doc='Old style method to insert a tool in the toolbar.', deprecated='Use :meth:`InsertTool` instead.', body="""\ return self.InsertTool(pos, id, label, bitmap, bmpDisabled, kind, shortHelp, longHelp, clientData) """) #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)
def run(): # Parse the XML file(s) building a collection of Extractor objects module = etgtools.ModuleDef(PACKAGE, MODULE, NAME, DOCSTRING) etgtools.parseDoxyXML(module, ITEMS) #----------------------------------------------------------------- # Tweak the parsed meta objects in the module object as needed for # customizing the generated code and docstrings. c = module.find('wxAuiNotebook') assert isinstance(c, etgtools.ClassDef) tools.fixWindowClass(c) tools.fixBookctrlClass(c) c.find('SetArtProvider.art').transfer = True c = module.find('wxAuiTabContainer') tools.ignoreConstOverloads(c) module.addItem(tools.wxArrayWrapperTemplate( 'wxAuiNotebookPageArray', 'wxAuiNotebookPage', module)) module.addItem(tools.wxArrayWrapperTemplate( 'wxAuiTabContainerButtonArray', 'wxAuiTabContainerButton', module)) c = module.find('wxAuiTabArt') c.abstract = True c = module.find('wxAuiNotebookEvent') tools.fixEventClass(c) module.addPyCode("""\ EVT_AUINOTEBOOK_PAGE_CLOSE = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CLOSE, 1 ) EVT_AUINOTEBOOK_PAGE_CLOSED = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CLOSED, 1 ) EVT_AUINOTEBOOK_PAGE_CHANGED = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CHANGED, 1 ) EVT_AUINOTEBOOK_PAGE_CHANGING = wx.PyEventBinder( wxEVT_AUINOTEBOOK_PAGE_CHANGING, 1 ) EVT_AUINOTEBOOK_BUTTON = wx.PyEventBinder( wxEVT_AUINOTEBOOK_BUTTON, 1 ) EVT_AUINOTEBOOK_BEGIN_DRAG = wx.PyEventBinder( wxEVT_AUINOTEBOOK_BEGIN_DRAG, 1 ) EVT_AUINOTEBOOK_END_DRAG = wx.PyEventBinder( wxEVT_AUINOTEBOOK_END_DRAG, 1 ) EVT_AUINOTEBOOK_DRAG_MOTION = wx.PyEventBinder( wxEVT_AUINOTEBOOK_DRAG_MOTION, 1 ) EVT_AUINOTEBOOK_ALLOW_DND = wx.PyEventBinder( wxEVT_AUINOTEBOOK_ALLOW_DND, 1 ) EVT_AUINOTEBOOK_DRAG_DONE = wx.PyEventBinder( wxEVT_AUINOTEBOOK_DRAG_DONE, 1 ) EVT_AUINOTEBOOK_TAB_MIDDLE_DOWN = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_MIDDLE_DOWN, 1 ) EVT_AUINOTEBOOK_TAB_MIDDLE_UP = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_MIDDLE_UP, 1 ) EVT_AUINOTEBOOK_TAB_RIGHT_DOWN = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_RIGHT_DOWN, 1 ) EVT_AUINOTEBOOK_TAB_RIGHT_UP = wx.PyEventBinder( wxEVT_AUINOTEBOOK_TAB_RIGHT_UP, 1 ) EVT_AUINOTEBOOK_BG_DCLICK = wx.PyEventBinder( wxEVT_AUINOTEBOOK_BG_DCLICK, 1 ) """) #----------------------------------------------------------------- # Add AuiTabCtrl in. c = etgtools.ClassDef(name = "wxAuiTabCtrl", bases = ["wxControl", "wxAuiTabContainer"], mustHaveAppFlag = True, items = [ etgtools.MethodDef(name = "wxAuiTabCtrl", classname="wxAuiTabCtrl", isCtor=True, items = [ etgtools.ParamDef(type = "wxWindow*", name = "parent"), etgtools.ParamDef(type = "wxWindowID", name = "id", default="wxID_ANY"), etgtools.ParamDef(type = "const wxPoint&", name = "pos", default = "wxDefaultPosition"), etgtools.ParamDef(type = "const wxSize&", name = "size", default = "wxDefaultSize"), etgtools.ParamDef(type = "long", name = "style", default = "0") ]), etgtools.MethodDef(type = "bool", name = "IsDragging", classname = "wxAuiTabCtrl", isConst = True) ]) tools.fixWindowClass(c) module.addItem(c) #----------------------------------------------------------------- tools.doCommonTweaks(module) tools.runGenerators(module)