rem
stringlengths 0
322k
| add
stringlengths 0
2.05M
| context
stringlengths 8
228k
|
|---|---|---|
self.sfT.SetDimensions(trPos.x +3, trPos.y -2, trSze.x - 2*3, frmWid) self.sfR.SetDimensions(trPos.x + trSze.x, trPos.y +3, frmWid, trSze.y - 2*3) self.sfB.SetDimensions(trPos.x +3, trPos.y + trSze.y, trSze.x - 2*3, frmWid) self.sfL.SetDimensions(trPos.x -2, trPos.y +3, frmWid, trSze.y - 2*3)
|
self.sfT.SetDimensions(trPos.x -frmWid, trPos.y -2, trSze.x +frmWid, frmWid) self.sfR.SetDimensions(trPos.x + trSze.x, trPos.y -frmWid, frmWid, trSze.y+frmWid) self.sfB.SetDimensions(trPos.x -frmWid, trPos.y + trSze.y, trSze.x +frmWid, frmWid) self.sfL.SetDimensions(trPos.x -2, trPos.y-frmWid, frmWid, trSze.y +frmWid)
|
def setSelection(self): position = self.position size = self.size
|
self.position = trPos self.size = trSze def OnSizeBegin(self, event): self.dragTag = self.senders.getObject(event) self.showFramedTags(self.dragTag) def OnSizeEnd(self, event): self.resizeCtrl() self.showTags() self.dragTag = None
|
self.position = trPos self.size = trSze
|
def setSelection(self): position = self.position size = self.size
|
event.Skip()
|
event.Skip() class SingleSelectionGroup(SelectionGroup): def __init__(self, parent, senders, inspector, designer): SelectionGroup.__init__(self, parent, senders, inspector, designer, wxBLACK, 0) def selectCtrl(self, ctrl, compn): SelectionGroup.selectCtrl(self, ctrl, compn) if self.selection: self.inspSel = ctrl self.inspector.selectObject(compn) def setSelection(self): position = self.position size = self.size trPos = wxPoint(granularise(position.x), granularise(position.y)) trSze = wxSize(granularise(size.x -1), granularise(size.y -1)) self.stTL.SetDimensions(trPos.x -4, trPos.y -4, tagSize, tagSize) self.stTR.SetDimensions(trPos.x -3 + trSze.x, trPos.y -4, tagSize, tagSize) self.stBR.SetDimensions(trPos.x -3 + trSze.x, trPos.y -3 + trSze.y, tagSize, tagSize) self.stBL.SetDimensions(trPos.x -4, trPos.y -3 + trSze.y, tagSize, tagSize) self.stT.SetDimensions(trPos.x -4 + trSze.x/2, trPos.y -4, tagSize, tagSize) self.stB.SetDimensions(trPos.x -4 + trSze.x/2, trPos.y -3 + trSze.y, tagSize, tagSize) self.stL.SetDimensions(trPos.x -4, trPos.y -4 + trSze.y/2, tagSize, tagSize) self.stR.SetDimensions(trPos.x -3 +trSze.x, trPos.y -4 + trSze.y/2, tagSize, tagSize) self.sfT.SetDimensions(trPos.x -frmWid, trPos.y -2, trSze.x +frmWid, frmWid) self.sfR.SetDimensions(trPos.x + trSze.x, trPos.y -frmWid, frmWid, trSze.y+frmWid*2) self.sfB.SetDimensions(trPos.x -frmWid, trPos.y + trSze.y, trSze.x +frmWid*2, frmWid) self.sfL.SetDimensions(trPos.x -2, trPos.y-frmWid, frmWid, trSze.y +frmWid) self.position = trPos self.size = trSze def OnSizeBegin(self, event): self.dragTag = self.senders.getObject(event) self.showFramedTags(self.dragTag) def OnSizeEnd(self, event): self.resizeCtrl() self.showTags() self.dragTag = None class MultiSelectionGroup(SelectionGroup): def __init__(self, parent, senders, inspector, designer): SelectionGroup.__init__(self, parent, senders, inspector, designer, wxColour(160, 160, 160), wxSIMPLE_BORDER) def selectCtrl(self, ctrl, compn): SelectionGroup.selectCtrl(self, ctrl, compn) self.inspSel = None self.inspector.cleanup() def setSelection(self): position = self.position size = self.size trPos = wxPoint(granularise(position.x), granularise(position.y)) trSze = wxSize(granularise(size.x -1), granularise(size.y -1)) if not self.dragging: self.stTL.SetDimensions(trPos.x -4, trPos.y -4, tagSize, tagSize) self.stTR.SetDimensions(trPos.x -3 + trSze.x, trPos.y -4, tagSize, tagSize) self.stBR.SetDimensions(trPos.x -3 + trSze.x, trPos.y -3 + trSze.y, tagSize, tagSize) self.stBL.SetDimensions(trPos.x -4, trPos.y -3 + trSze.y, tagSize, tagSize) self.stT.SetDimensions(trPos.x -4 + trSze.x/2, trPos.y -4, tagSize, tagSize) self.stB.SetDimensions(trPos.x -4 + trSze.x/2, trPos.y -3 + trSze.y, tagSize, tagSize) self.stL.SetDimensions(trPos.x -4, trPos.y -4 + trSze.y/2, tagSize, tagSize) self.stR.SetDimensions(trPos.x -3 +trSze.x, trPos.y -4 + trSze.y/2, tagSize, tagSize) self.sfT.SetDimensions(trPos.x -frmWid, trPos.y -2, trSze.x +frmWid, frmWid) self.sfR.SetDimensions(trPos.x + trSze.x, trPos.y -frmWid, frmWid, trSze.y+frmWid*2) self.sfB.SetDimensions(trPos.x -frmWid, trPos.y + trSze.y, trSze.x +frmWid*2, frmWid) self.sfL.SetDimensions(trPos.x -2, trPos.y-frmWid, frmWid, trSze.y +frmWid) self.position = trPos self.size = trSze def OnSizeBegin(self, event): event.Skip() def OnSizeEnd(self, event): event.Skip()
|
def OnMouseOver(self, event): if event.Dragging(): pos = event.GetPosition() ctrl = self.senders.getObject(event) self.moving(ctrl, pos)
|
def __init__(self, parent, cursor, size, group, pnlStyle = 0): wxPanel.__init__(self, parent, -1, style = pnlStyle)
|
def __init__(self, parent, cursor, tagSize, group, pnlStyle): wxPanel.__init__(self, parent, -1, size = wxSize(tagSize, tagSize), style = pnlStyle) self.Show(false)
|
def __init__(self, parent, cursor, size, group, pnlStyle = 0): wxPanel.__init__(self, parent, -1, style = pnlStyle) self.group = group self.SetSize(wxSize(size, size)) self.SetBackgroundColour(wxBLACK) self.SetForegroundColour(wxBLACK) self.SetCursor(wxStockCursor(cursor)) self.selection = None
|
self.SetSize(wxSize(size, size)) self.SetBackgroundColour(wxBLACK)
|
self.SetBackgroundColour(group.colour)
|
def __init__(self, parent, cursor, size, group, pnlStyle = 0): wxPanel.__init__(self, parent, -1, style = pnlStyle) self.group = group self.SetSize(wxSize(size, size)) self.SetBackgroundColour(wxBLACK) self.SetForegroundColour(wxBLACK) self.SetCursor(wxStockCursor(cursor)) self.selection = None
|
grp.size.x = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x grp.size.y = 0 if oldPos and oldSize: grp.position.y = oldPos.y + oldSize.y
|
grp.size.x, grp.size.y = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x grp.position.y = oldPos.y + oldSize.y
|
def setPos(self, position, mirrorX, mirrorY, mirrorXY, oldPos = None, oldSize = None): grp = self.group if grp.size.x < 0 and grp.size.y < 0: grp.size.x = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x grp.size.y = 0 if oldPos and oldSize: grp.position.y = oldPos.y + oldSize.y grp.dragTag = mirrorXY elif grp.size.x < 0: grp.size.x = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x grp.dragTag = mirrorX elif self.group.size.y < 0: grp.size.y = 0 if oldPos and oldSize: grp.position.y = oldPos.y + oldSize.y grp.dragTag = mirrorY grp.setSelection()
|
self.lcFiles.node.setFilter(self.editorFilter)
|
self.editorFilterNode.setFilter(self.editorFilter)
|
def open(self, node): if node: if node.isFolderish(): self.lcFiles.refreshItems(self.modImages, node) self.updatePathLabel() if self.style & wxSAVE: btn = saveStr else: btn = openStr self.btOK.SetLabel(btn) return if self.tcFilename.GetValue(): self.lcFiles.node.setFilter(self.editorFilter) wxBoaFileDialog.currentDir = self.GetDirectory() self.EndModal(wxID_OK)
|
self.lcFiles.node.setFilter(self.editorFilter)
|
self.editorFilterNode.setFilter(self.editorFilter)
|
def OnBtcancelButton(self, event): self.lcFiles.node.setFilter(self.editorFilter) self.EndModal(wxID_CANCEL)
|
if not value[1:-1]:
|
strVal = eval(value) if not strVal:
|
def getValue(self): if self.editorCtrl: value = self.editorCtrl.getValue() if type(value) in StringTypes: value = `self.editorCtrl.getValue()` else: value = self.getCtrlValue()
|
for c in value[1:-1]:
|
for c in strVal:
|
def getValue(self): if self.editorCtrl: value = self.editorCtrl.getValue() if type(value) in StringTypes: value = `self.editorCtrl.getValue()` else: value = self.getCtrlValue()
|
class SingleSelectionGroup(SelectionGroup): def __init__(self, parent, senders, inspector, designer): SelectionGroup.__init__(self, parent, senders, inspector, designer, wxBLACK, 0) def selectCtrl(self, ctrl, compn): SelectionGroup.selectCtrl(self, ctrl, compn) if self.selection: self.inspSel = ctrl self.inspector.selectObject(compn) def positionUpdate(self): self.inspector.constructorUpdate('Position') def sizeUpdate(self): self.inspector.constructorUpdate('Size') self.inspector.propertyUpdate('ClientSize') def OnSizeBegin(self, event): self.dragTag = self.senders.getObject(event) self.showFramedTags(self.dragTag) self.initStartVals() def OnSizeEnd(self, event): self.resizeCtrl() self.showTags() self.dragTag = None self.setSelection()
|
def OnMouseOver(self, event): if event.Dragging(): pos = event.GetPosition() ctrl = self.senders.getObject(event) self.moving(ctrl, pos) event.Skip()
|
|
'Images/Shared/NewItems.png', 'More new ...', self.OnNewClick)
|
'Images/Shared/NewItems.png', 'More new ...', self.OnMoreNewClick)
|
def __init__(self, parent, collEditView, additAdders = (), lvStyle = wxLC_REPORT): self.collEditPos = (-1, -1) self.collEditPos = getNextDefaultPos() self._init_ctrls(parent)
|
self.additAdders = 0
|
self.additAdders = additAdders = 0
|
def __init__(self, parent, collEditView, additAdders = (), lvStyle = wxLC_REPORT): self._init_ctrls(parent)
|
self.filename = model.filename
|
def __init__(self, model, stack = None): bdb.Bdb.__init__(self) wxFrame.__init__(self, model.editor, -1, 'Debugger - %s - %s' \ % (path.basename(model.filename), model.filename), wxPoint(0, Preferences.paletteHeight + Preferences.windowManagerTop + \ Preferences.windowManagerBottom), wxSize(Preferences.inspWidth, Preferences.bottomHeight))
|
|
'Images/Debug/DebugBrowse.bmp', 'Namespace in shell',
|
'Images/Debug/ShellDebug.bmp', 'Eval in shell',
|
def __init__(self, model, stack = None): bdb.Bdb.__init__(self) wxFrame.__init__(self, model.editor, -1, 'Debugger - %s - %s' \ % (path.basename(model.filename), model.filename), wxPoint(0, Preferences.paletteHeight + Preferences.windowManagerTop + \ Preferences.windowManagerBottom), wxSize(Preferences.inspWidth, Preferences.bottomHeight))
|
self.splitter = wxSplitterWindow(self, -1, style = wxSP_NOBORDER)
|
self.splitter = wxSplitterWindow(self, -1, style = wxSP_NOBORDER| wxSP_3DSASH | wxSP_FULLSASH)
|
def __init__(self, model, stack = None): bdb.Bdb.__init__(self) wxFrame.__init__(self, model.editor, -1, 'Debugger - %s - %s' \ % (path.basename(model.filename), model.filename), wxPoint(0, Preferences.paletteHeight + Preferences.windowManagerTop + \ Preferences.windowManagerBottom), wxSize(Preferences.inspWidth, Preferences.bottomHeight))
|
print 'getVarValue', name
|
def getVarValue(self, name): print 'getVarValue', name if self.frame: try: return pprint.pformat(eval(name, self.frame.f_globals, self.frame.f_locals)) except Exception, message: return pprint.pformat(str(message)) else: return '(No current frame)'
|
|
wxPhonyApp.debugger = self wxPython.wx.wxApp = wxPhonyApp wxPython.wx.wxPySimpleApp = wxPhonyApp
|
wxPython.wx.wxApp.debugger = self
|
def debug_file(self, filename, params = None): filename = path.join(pyPath, filename) saveout = sys.stdout saveerr = sys.stderr if params is None: params = []
|
sys.path.append(self.modpath)
|
sys.path.insert(0, self.modpath)
|
def debug_file(self, filename, params = None): filename = path.join(pyPath, filename) saveout = sys.stdout saveerr = sys.stderr if params is None: params = []
|
sys.stderr = ShellEditor.PseudoFileErrTC(owin)
|
sys.stderr = PseudoFileErrTC(owin)
|
def debug_file(self, filename, params = None): filename = path.join(pyPath, filename) saveout = sys.stdout saveerr = sys.stderr if params is None: params = []
|
sys.stdout = ShellEditor.PseudoFileOutTC(owin)
|
sys.stdout = PseudoFileOutTC(owin)
|
def debug_file(self, filename, params = None): filename = path.join(pyPath, filename) saveout = sys.stdout saveerr = sys.stderr if params is None: params = []
|
print "I''m frozen!"
|
print "I'm frozen!"
|
def debug_file(self, filename, params = None): filename = path.join(pyPath, filename) saveout = sys.stdout saveerr = sys.stderr if params is None: params = []
|
wxPython.wx.wxApp = tmpApp wxPython.wx.wxPySimpleApp = tmpSimpleApp
|
del wxPython.wx.wxApp.debugger
|
def debug_file(self, filename, params = None): filename = path.join(pyPath, filename) saveout = sys.stdout saveerr = sys.stderr if params is None: params = []
|
self.sb.status.SetLabel('')
|
self.sb.status.SetLabel('Running')
|
def interaction(self, frame, info=None): self.frame = frame code = frame.f_code file = code.co_filename base = os.path.basename(file) lineno = frame.f_lineno
|
self.stopMainLoop()
|
def OnDebug(self, event): if self.interacting: self.set_continue() self.stopMainLoop() else: self.debug_file(self.filename) self.stopMainLoop()
|
|
wxPhonyApp.inMainLoop = false
|
def OnStop(self, event): wxPhonyApp.inMainLoop = false self.set_quit() self.model.editor.clearAllStepPoints() self.stackView.load_stack([])
|
|
self.model.editor.clearAllStepPoints() self.stackView.load_stack([])
|
if hasattr(self.model, 'editor'): self.model.editor.clearAllStepPoints() self.stackView.load_stack([]) self.frame = None self.stopMainLoop()
|
def OnStop(self, event): wxPhonyApp.inMainLoop = false self.set_quit() self.model.editor.clearAllStepPoints() self.stackView.load_stack([])
|
self.model.editor.debugger = None print 'quiting from Debug window' self.app.quit = true
|
if hasattr(self.model, 'editor'): self.model.editor.debugger = None
|
def OnCloseWindow(self, event): try: if self.interacting: # XXX mmm self.OnStop(None) self.locs.destroy() self.globs.destroy() self.breakpts.destroy() self.watches.destroy() self.model.editor.debugger = None
|
dlg = wxFileDialog(self, 'Save as...', '', '', '*.html',
|
dlg = wxFileDialog(self, 'Save as...', '.', '', '*.html',
|
def OnSaveHTML(self, event): from FileDlg import wxFileDialog dlg = wxFileDialog(self, 'Save as...', '', '', '*.html', wxSAVE | wxOVERWRITE_PROMPT) try: if dlg.ShowModal() == wxID_OK: from Explorers.Explorer import openEx trpt = openEx(dlg.GetPath()) trpt.save(trpt.currentFilename(), self.data) finally: dlg.Destroy()
|
return 'import wx.lib.stattext.GenStaticText'
|
return 'import wx.lib.stattext'
|
def writeImports(self): return 'import wx.lib.stattext.GenStaticText'
|
if dsgn.selection: dsgn.selection.sizeFromCtrl() dsgn.selection.setSelection() finally: event.Skip() def OnControlDClick(self, event): dsgn = self.designer if dsgn.selection: ctrl = dsgn.senderMapper.getObject(event) dsgn.selectControlByPos(ctrl, event.GetPosition(), event.ShiftDown()) if ctrl == dsgn: companion = dsgn.companion ctrlName = '' else: ctrlName = ctrl.GetName() companion = dsgn.objects[ctrlName][0] selCtrl, selCompn, selPos = \ dsgn.checkChildCtrlClick(ctrlName, ctrl, companion, event.GetPosition()) selCompn.defaultAction() class InspectableObjectCollectionView(EditorViews.EditorView): viewName = 'InspectableObjectCollection' collectionMethod = 'init_' collectionParams = 'self' handledProps = [] supportsParentView = false def setupArgs(self, ctrlName, params, dontEval): """ Create a dictionary of parameters for the constructor of the control from a dictionary of string/source parameters. Catches design time parameter overrides. """ args = {} for paramKey in params.keys(): value = params[paramKey] if len(value) >= 11 and value[:11] == 'self._init_': collItem = methodparse.CollectionInitParse(value) self.addCollView(paramKey, collItem.method, false) if paramKey in dontEval: args[paramKey] = params[paramKey] else: args[paramKey] = PaletteMapping.evalCtrl(params[paramKey]) return args def __init__(self, inspector, model, compPal, actions = (), dclickActionIdx = -1, editorIsWindow = true): self.compPal = compPal EditorViews.EditorView.__init__(self, model, actions, dclickActionIdx, editorIsWindow) self.selection = None self.senderMapper = sender.SenderMapper() self.inspector = inspector self.controllerView = None self.objects = {} self.objectOrder = [] self.collEditors = {} def destroy(self): del self.controllerView del self.inspector for objval in self.objects.values(): objval[0].destroy() for coll in self.collEditors.values(): coll.destroy() del self.collEditors del self.objects del self.senderMapper EditorViews.EditorView.destroy(self) def buildParentRelationship(self): """ Build a nested dictionary of key = name, value = dict pairs describing parental relationship. Assuming parents are created before children parRel : Nested relationship dictionary parRef : Flat reference dictionary """ parRel = {} parRef = {} for ctrl in self.objectOrder: ce = self.objects[ctrl] if ce[2] is None: parRel[ctrl] = {} parRef[ctrl] = parRel[ctrl] else: parRef[ce[2]][ctrl] = {} parRef[ctrl] = parRef[ce[2]][ctrl] return parRel, parRef def initObjectsAndCompanions(self, creators, objColl, dependents, depLinks): collDeps = {} for constr in creators: self.initObjCreator(constr) self.initObjProps(objColl.propertiesByName, constr.comp_name, constr, dependents, depLinks) self.initObjColls(objColl.collectionsByName, constr.comp_name, constr, collDeps) self.initObjEvts(objColl.eventsByName, constr.comp_name, constr) self.applyDepsForCtrl(constr.comp_name, depLinks) for ctrlName in collDeps.keys(): for collInit in collDeps[ctrlName]: self.addCollView(ctrlName, collInit.method, false) def initObjCreator(self, constrPrs): ctrlClass = PaletteMapping.evalCtrl(constrPrs.class_name) ctrlCompnClass = PaletteMapping.compInfo[ctrlClass][1] ctrlName = self.loadControl(ctrlClass, ctrlCompnClass, constrPrs.comp_name, constrPrs.params) ctrlCompn = self.objects[ctrlName][0] ctrlCompn.setConstr(constrPrs) def initObjProps(self, props, name, creator, dependents, depLinks): """ Initialise property list by evaluating 1st parameter and calling prop's setter with it. Also associate companion name with prop parse objs """ if props.has_key(name): comp, ctrl = self.objects[name][0:2] for prop in props[name]: prop.prop_name = comp.getPropNameFromSetter(prop.prop_setter) if prop.prop_name in comp.dependentProps(): self.addDepLink(prop, name, dependents, depLinks) elif prop.params[0][:11] == 'self._init_': collItem = methodparse.CollectionInitParse(prop.params[0]) self.addCollView(name, collItem.method, false) elif comp.customPropEvaluators.has_key(prop.prop_name): args = comp.customPropEvaluators[prop.prop_name](prop.params, self.getAllObjects()) apply(RTTI.getFunction(ctrl, prop.prop_setter), (ctrl, )+ args) else: try: value = PaletteMapping.evalCtrl(prop.params[0]) except AttributeError, name: if self.objects.has_key(name): value = self.objects[name][1] else: raise RTTI.getFunction(ctrl, prop.prop_setter)(ctrl, value) comp.setProps(props[name]) def initObjColls(self, collInits, name, creator, dependents = None): """ Initialise collection properties by creating a collection view for it and applying it. Also associate companion name with prop parse objs """ if collInits.has_key(name): if dependents is None: dependents = {} comp = self.objects[name][0] for collInit in collInits[name]: if collInit.getPropName() in comp.dependentProps(): if not dependents.has_key(name): dependents[name] = [] dependents[name].append(collInit) else: self.addCollView(name, collInit.method, false) comp.setCollInits(collInits[name]) def initObjEvts(self, events, name, creator): if events.has_key(name): self.objects[name][0].setEvents(events[name]) def addCollView(self, name, collInitMethod, create): import CollectionEdit comp, ctrl = self.objects[name][:2] collName = getCollName(collInitMethod, name) collCompClass = comp.subCompanions[collName] collComp = collCompClass(name, self, comp, ctrl) if create: collComp.persistCollInit(collInitMethod, name, collName) else: pass collInit = self.model.objectCollections[collInitMethod] collComp.setConstrs(collInit.creators, collInit.initialisers, collInit.finalisers) for crt in collComp.textConstrLst: collComp.applyDesignTimeDefaults(crt.params) collComp.initCollection() comp.collections[collName] = collComp collEditView = CollectionEdit.CollectionEditorView(self, self.inspector, self.model, collComp) collEditView.initialise() self.collEditors[(comp.name, collName)] = collEditView def getRefsFromProp(self, prop): refs = [] for param in prop.params: if len(param) >= 4 and param[:4] == 'self': refs.append(Utils.ctrlNameFromSrcRef(param)) return refs def checkAndAddDepLink(self, ctrlName, prop, dependentProps, deps, depLinks, definedCtrls): if prop.prop_name in dependentProps: refs = self.getRefsFromProp(prop) allCtrlsDefined = len(refs) > 0 for ref in refs: if ref not in definedCtrls: allCtrlsDefined = false if not allCtrlsDefined: self.addDepLink(prop, ctrlName, deps, depLinks) return true return false def applyDepsForCtrl(self, ctrlName, depLinks): if depLinks.has_key(ctrlName): for prop, otherRefs in depLinks[ctrlName]: for oRf in otherRefs: if not oRf in self.objectOrder: break else: ctrl = self.objects[prop.comp_name][1] if len(prop.params) == 1: if ctrlName == '': value = self else: ord, objs = self.model.allObjects() if objs.has_key(ctrlName): value = objs[ctrlName][1] else: continue RTTI.getFunction(ctrl, prop.prop_setter)(ctrl, value) else: refs = [] for param in prop.params: if len(param) >= 4 and param[:4] == 'self': refs.append(self.objects[Utils.ctrlNameFromSrcRef(param)][1]) else: refs.append(eval(param)) apply(RTTI.getFunction(ctrl, prop.prop_setter), [ctrl,]+refs) del depLinks[ctrlName] def addDepLink(self, prop, name, dependents, depLinks): refs = self.getRefsFromProp(prop) for link in refs: if not depLinks.has_key(link): depLinks[link] = [] otherRefs = refs[:] otherRefs.remove(link) depLinks[link].append( (prop, otherRefs) ) def finaliseDepLinks(self, depLinks): for ctrlName in depLinks.keys()[:]: self.applyDepsForCtrl(ctrlName, depLinks) def renameCtrl(self, oldName, newName): """ Rename a control and update all its properties and events.""" ctrl = self.objects[oldName] del self.objects[oldName] self.objects[newName] = ctrl idx = self.objectOrder.index(oldName) del self.objectOrder[idx] self.objectOrder.insert(idx, newName) companion = self.objects[newName][0] companion.renameCtrl(oldName, newName) companion.renameCtrlRefs(oldName, newName) for name, prop in self.collEditors.keys(): if name == oldName: collEditor = self.collEditors[(name, prop)] collEditor.renameCtrl(oldName, newName) del self.collEditors[(name, prop)] self.collEditors[(newName, prop)] = collEditor def saveCtrls(self, definedCtrls): """ Replace current source of method in collectionMethod with values from constructors, properties and events. """ newBody = [] deps = {} depLinks = {} collDeps = [] imports = [] for collView in self.collEditors.values(): collView.saveCtrls() for ctrlName in self.objectOrder: definedCtrls.append(ctrlName) compn = self.objects[ctrlName][0] compn.writeConstructor(newBody, self.collectionMethod) compn.writeProperties(newBody, ctrlName, definedCtrls, deps, depLinks) compn.writeCollections(newBody, collDeps) compn.writeEvents(newBody, addModuleMethod = true) compn.writeDependencies(newBody, ctrlName, depLinks, definedCtrls) imp = compn.writeImports() if imp and imp not in imports: imports.append(imp) newBody.append('') if collDeps: newBody.extend(collDeps + ['']) module = self.model.getModule() for imp in imports: module.addImportStatement(imp) if module.classes[self.model.main].methods.has_key(\ self.collectionMethod): docs = module.getClassMethDoc(self.model.main, self.collectionMethod) if (len(docs) > 0) and docs[0]: newBody.insert(0, '%s""" %s """'%(bodyIndent, docs)) if len(newBody): module.replaceMethodBody(self.model.main, self.collectionMethod, newBody) else: module.replaceMethodBody(self.model.main, self.collectionMethod, [bodyIndent+'pass', '']) else: if len(newBody): module.addMethod(self.model.main, self.collectionMethod, self.collectionParams, newBody, 0) self.model.refreshFromModule() def copyCtrls(self, selCtrls, definedCtrls, output): """ Replace current source of method in collectionMethod with values from constructors, properties and events. """ ctrlsAndContainedCtrls = self.expandNamesToContainers(selCtrls) deps = {} depLinks = {} collDeps = [] collMeths = [] for compName, collProp in self.collEditors.keys(): if compName in ctrlsAndContainedCtrls: collView = self.collEditors[(compName, collProp)] collMeth = [] collView.copyCtrls(collMeth) collMeths.append(collMeth) output.insert(0, ' def %s(%s):'% (self.collectionMethod, self.collectionParams)) for ctrlName in ctrlsAndContainedCtrls: definedCtrls.append(ctrlName) compn = self.objects[ctrlName][0] compn.updatePosAndSize() compn.writeConstructor(output, self.collectionMethod) compn.writeProperties(output, ctrlName, definedCtrls, deps, depLinks) compn.writeCollections(output, collDeps) compn.writeEvents(output, addModuleMethod = false) compn.writeDependencies(output, ctrlName, depLinks, definedCtrls) output.append('') if collDeps: output.extend(collDeps + ['']) collMeths.reverse() for methBody in collMeths: output[0:0] = methBody + [''] def cutCtrls(self, selCtrls, definedCtrls, output): self.copyCtrls(selCtrls, definedCtrls, output) self.selectNone() for ctrl in selCtrls: self.deleteCtrl(ctrl) def pasteCtrls(self, destCtrlName, input): methList = [] for line in input: if line[:8] == ' def ': meth = line[8:string.find(line, '(', 9)] currMeth = [meth] methList.append(currMeth) else: try: currMeth.append(line) except NameError: print 'PASTE ERROR', input collObjColls = [] pastedCtrls = [] idx = -1 for meth in methList[:]: idx = idx + 1 if meth[0] == self.collectionMethod: collMethod = meth[0] methBody = meth[1:] else: ctrlName = string.join(string.split(meth[0], '_')[3:-1], '_') newObjColl = self.model.readDesignerMethod(meth[0], meth[1:]) methodparse.decorateCollItemInitsWithCtrl(newObjColl.creators, ctrlName) collObjColls.append( (meth[0], ctrlName, newObjColl) ) objCol = self.model.readDesignerMethod(collMethod, methBody) if not len(objCol.creators): return [] objCol.indexOnCtrlName() pasteNameClasses = objCol.getCtrlNames() newNames = [] oldNames = [] for name, clss in pasteNameClasses: if name in self.objectOrder: newName = self.newObjName(clss, newNames) newNames.append(newName) oldNames.append(name) else: newNames.append(name) oldNames.append(name) for oldName, newName in map(None, oldNames, newNames): if newName != oldName: objCol.renameCtrl(oldName, newName) pastedCtrls.append(newName) for idx in range(len(collObjColls)): meth, collCtrlName, collObjColl = collObjColls[idx] collObjColl.renameCtrl(oldName, newName) if collCtrlName == oldName: itms = string.split(meth, '_') itms[3:-1] = [newName] collObjColls[idx] = (string.join(itms, '_'), newName, collObjColl) else: pastedCtrls.append(oldName) for meth, collCtrlName, collObjColl in collObjColls: self.model.objectCollections[meth] = collObjColl if objCol.creators[0].params.has_key('parent'): copySource = objCol.creators[0].params['parent'] objCol.reparent(copySource, Utils.srcRefFromCtrlName(destCtrlName)) deps = {} depLnks = {} self.inspector.vetoSelect = true try: self.initObjectsAndCompanions(objCol.creators, objCol, deps, depLnks) finally: self.inspector.vetoSelect = false self.model.objectCollections[collMethod].merge(objCol) return pastedCtrls def addObject(self, ctrlName, companion, designTimeCtrl, parentName = None): self.objects[ctrlName] = [companion, designTimeCtrl] if parentName is not None: self.objects[ctrlName].append(parentName) self.objectOrder.append(ctrlName) def newObjName(self, className, additionalNames = None): """ Return a name for a control unique in the scope of the model. """ if additionalNames is None: additionalNames = [] num = 1 if className[:2] == 'wx': newName = '%s%s'%(string.lower(className[2:3]), className[3:]) else: newName = '%s%s'%(string.lower(className[0]), className[1:]) return Utils.getValidName(self.objects.keys() + additionalNames, newName) def newObject(self, objClass, objCompanionClass): """ At design time, when adding a new ctrl from the palette, create and register given control and companion. """ objName = self.newObjName(objClass.__name__) self.checkHost(objCompanionClass) companion = objCompanionClass(objName, self, objClass) params = companion.designTimeSource() self.addObject(objName, companion, companion.designTimeObject(), '') companion.persistConstr(objClass.__name__, params) return objName def addCtrlToObjectCollection(self, textConstr): colMeth = self.collectionMethod if not self.model.objectCollections.has_key(colMeth): self.model.objectCollections[colMeth] = ObjectCollection() self.model.objectCollections[colMeth].creators.append(textConstr) def addCollToObjectCollection(self, collInitParse): colMeth = self.collectionMethod self.model.objectCollections[colMeth].collections.append(collInitParse) newObjColl = ObjectCollection() self.model.objectCollections[collInitParse.method] = newObjColl return newObjColl def selectObject(self): pass def selectNone(self): pass def deleteCtrl(self, name, parentRef = None): self.model.objectCollections[self.collectionMethod].deleteCtrl(name) del self.objectOrder[self.objectOrder.index(name)] del self.objects[name] for ctrlName, propName in self.collEditors.keys()[:]: if ctrlName == name: del self.collEditors[(ctrlName, propName)] def cleanup(self): if self == self.inspector.prevDesigner: self.inspector.prevDesigner = None def close(self): if self.controllerView != self: self.controllerView.close() def refreshContainment(self, selectName = None): """ Rebuild parent tree and optionally select given control """ parRelations, parReference = self.buildParentRelationship() self.inspector.containment.refreshCtrl(self.model.main, parRelations, self) if selectName is not None: self.inspector.containment.selectName(selectName) return parRelations, parReference def getObjectsOfClass(self, theClass): results = {} for objName in self.objects.keys(): if issubclass(self.objects[objName][1].__class__, theClass): if objName: results['self.'+objName] = self.objects[objName][1] else: results['self'] = self.objects[objName][1] return results def getObjectsOfClassWithParent(self, theClass, theParentName): results = {} for objName in self.objects.keys(): if self.objects[objName][2] == theParentName and \ issubclass(self.objects[objName][1].__class__, theClass): if objName: results['self.'+objName] = self.objects[objName][1] else: results['self'] = self.objects[objName][1] return results def getAllObjects(self): results = {} for objName in self.objects.keys(): if objName: results['self.'+objName] = self.objects[objName][1] else: results['self'] = self.objects[objName][1] return results def getObjectsOfClassOwnedBy(self, theClass, theOwner): results = {} for objName in self.objects.keys(): if self.objects[objName][1].__class__ is theClass: results['self.'+objName] = self.objects[objName][1] return results def showCollectionEditor(self, ctrlName, propName): """ Show the Collection Editor frame for given name and prop """ if ctrlName == self.GetName(): ctrlName = '' if not self.collEditors.has_key((ctrlName, propName)): self.addCollView(ctrlName, '_init_coll_%s_%s'%(ctrlName, propName), true) self.collEditors[(ctrlName, propName)].show() def checkHost(self, ctrlCompanion): """ Checks that the companion may be hosted in this designer """ if ctrlCompanion.host == 'Not Implemented': dlg = wxMessageDialog(self, 'This component is not yet implemented', 'Not Implemented', wxOK | wxICON_ERROR) try: dlg.ShowModal() finally: dlg.Destroy() raise 'Not Implemented' if ctrlCompanion.host != self.viewName: dlg = wxMessageDialog(self, 'This component must be created in '+ctrlCompanion.host, 'Wrong Designer', wxOK | wxICON_ERROR) try: dlg.ShowModal() finally: dlg.Destroy() raise 'Wrong Designer' def expandNamesToContainers(self, ctrlNames): """ Expand set of names to include the names of all their children """ return ctrlNames def collapseNamesToContainers(self, ctrlNames): """ Collapse set of names to exclude the names of all their children """ return ctrlNames def notifyAction(self, compn, action): for otherCompn, otherCtrl, otherPrnt in self.objects.values(): otherCompn.notification(compn, action) for collView in self.collEditors.values(): collView.companion.notification(compn, action) class DesignerView(wxFrame, InspectableObjectCollectionView):
|
class DesignerView(wxFrame, InspectableObjectView):
|
def OnControlResize(self, event): """ Control is resized, emulate native wxWindows layout behaviour """ dsgn = self.designer try: if event.GetId() == dsgn.GetId(): if dsgn.selection: dsgn.selection.selectCtrl(dsgn, dsgn.companion) elif dsgn.multiSelection: dsgn.clearMultiSelection() dsgn.assureSingleSelection() dsgn.selection.selectCtrl(dsgn, dsgn.companion) return
|
collectionMethod = init_ctrls
|
collectionMethod = sourceconst.init_ctrls
|
def notifyAction(self, compn, action): # notify components for otherCompn, otherCtrl, otherPrnt in self.objects.values(): otherCompn.notification(compn, action) # notify collections for collView in self.collEditors.values(): collView.companion.notification(compn, action)
|
args = InspectableObjectCollectionView.setupArgs(self, ctrlName, params, dontEval)
|
args = InspectableObjectView.setupArgs(self, ctrlName, params, dontEval)
|
def setupArgs(self, ctrlName, params, dontEval, parent = None, compClass = None): """ Create a dictionary of parameters for the constructor of the control from a dictionary of string/source parameters. """
|
InspectableObjectCollectionView.__init__(self, inspector, model, compPal)
|
InspectableObjectView.__init__(self, inspector, model, compPal)
|
def __init__(self, parent, inspector, model, compPal, companionClass, dataView): args = self.setupArgs(model.main, model.mainConstr.params, ['parent', 'id'], parent, companionClass) wxFrame.__init__(self, parent, -1, args['title'], args['pos'], args['size'])#, args['style'], args['name']) InspectableObjectCollectionView.__init__(self, inspector, model, compPal)
|
if Preferences.drawDesignerGrid: EVT_PAINT(self, self.OnPaint) self.drawGridMethods = {'lines' : self.drawGrid_intersectingLines, 'dots' : self.drawGrid_dots, 'bitmap': self.drawGrid_bitmap, 'grid' : self.drawGrid_grid}
|
def __init__(self, parent, inspector, model, compPal, companionClass, dataView): args = self.setupArgs(model.main, model.mainConstr.params, ['parent', 'id'], parent, companionClass) wxFrame.__init__(self, parent, -1, args['title'], args['pos'], args['size'])#, args['style'], args['name']) InspectableObjectCollectionView.__init__(self, inspector, model, compPal)
|
|
InspectableObjectCollectionView.saveCtrls(self, definedCtrls)
|
InspectableObjectView.saveCtrls(self, definedCtrls)
|
def saveCtrls(self, definedCtrls): """ Generate source code for Designer """ # Remove all collection methods for oc in self.model.identifyCollectionMethods(): if len(oc) > len('_init_coll_') and oc[:11] == '_init_coll_': module = self.model.getModule() module.removeMethod(self.model.main, oc)
|
InspectableObjectCollectionView.renameCtrl(self, oldName, newName)
|
InspectableObjectView.renameCtrl(self, oldName, newName)
|
def renameCtrl(self, oldName, newName): """ Rename control, references to control and update parent tree """ prel, pref = self.buildParentRelationship() # rename other ctrl references like parent
|
if params[ctrlCompanion.windowParentName] == 'self': parent = '' else: parent = string.split(params[ctrlCompanion.windowParentName], '.')[1]
|
parent = Utils.ctrlNameFromSrcRef(params[ctrlCompanion.windowParentName])
|
def loadControl(self, ctrlClass, ctrlCompanion, ctrlName, params): """ Create and register given control and companion. See also: newControl """ dontEval = [ctrlCompanion.windowParentName, ctrlCompanion.windowIdName] args = self.setupArgs(ctrlName, params, dontEval, compClass = ctrlCompanion) if params[ctrlCompanion.windowParentName] == 'self': parent = '' else: parent = string.split(params[ctrlCompanion.windowParentName], '.')[1] # Create control and companion companion = ctrlCompanion(ctrlName, self, None, ctrlClass)
|
results = InspectableObjectCollectionView.getObjectsOfClass(self, theClass)
|
results = InspectableObjectView.getObjectsOfClass(self, theClass)
|
def getObjectsOfClass(self, theClass): """ Overridden to also add objects from the DataView """ results = InspectableObjectCollectionView.getObjectsOfClass(self, theClass) dataResults = {} for objName in self.dataView.objects.keys(): if self.dataView.objects[objName][1].__class__ is theClass: dataResults['self.'+objName] = self.dataView.objects[objName][1] results.update(dataResults) return results
|
results = InspectableObjectCollectionView.getAllObjects(self)
|
results = InspectableObjectView.getAllObjects(self)
|
def getAllObjects(self): """ Overridden to also add objects from the DataView """ results = InspectableObjectCollectionView.getAllObjects(self) for objName in self.dataView.objects.keys(): if objName: results['self.'+objName] = self.dataView.objects[objName][1] else: results['self'] = self.dataView.objects[objName][1] return results
|
if objName: results['self.'+objName] = self.dataView.objects[objName][1] else: results['self'] = self.dataView.objects[objName][1]
|
results[Utils.srcRefFromCtrlName(objName)] = \ self.dataView.objects[objName][1]
|
def getAllObjects(self): """ Overridden to also add objects from the DataView """ results = InspectableObjectCollectionView.getAllObjects(self) for objName in self.dataView.objects.keys(): if objName: results['self.'+objName] = self.dataView.objects[objName][1] else: results['self'] = self.dataView.objects[objName][1] return results
|
InspectableObjectCollectionView.deleteCtrl(self, name)
|
InspectableObjectView.deleteCtrl(self, name)
|
def deleteCtrl(self, name, parentRef = None): """ Delete a control, update selection and parent tree """ ctrlInfo = self.objects[name] if ctrlInfo[1] == self: wxMessageBox("Can't delete frame") return parRel = None # build relationship, this will only happen for the first call if not parentRef: # select parent so long, pretty soon won't be able to ask who # the parent is parentName = ctrlInfo[1].GetParent().GetName() if parentName == self.GetName(): parentName = ''
|
self.selection = None
|
def selectNone(self): if self.selection: self.selection.selectNone() self.selection = None elif self.multiSelection: for sel in self.multiSelection: sel.selectNone() sel.destroy() self.multiSelection = []
|
|
tbOffset = 0
|
offset = [0, 0]
|
def checkChildCtrlClick(self, ctrlName, ctrl, companion, clickPos): """ Check whether the click on the control actually falls within a region occupied by one of it's children. The click is then transfered to the child. """ selCtrl, selCompn, selPos = ctrl, companion, clickPos if companion.container: parent = ctrl else: parent = ctrl.GetParent() # Workaround toolbar offset bug tbOffset = 0 if parent == self: tb = self.GetToolBar() if tb: tbOffset = tb.GetSize().y * -1
|
tbOffset = tb.GetSize().y * -1
|
offset[1] = tb.GetSize().y * -1
|
def checkChildCtrlClick(self, ctrlName, ctrl, companion, clickPos): """ Check whether the click on the control actually falls within a region occupied by one of it's children. The click is then transfered to the child. """ selCtrl, selCompn, selPos = ctrl, companion, clickPos if companion.container: parent = ctrl else: parent = ctrl.GetParent() # Workaround toolbar offset bug tbOffset = 0 if parent == self: tb = self.GetToolBar() if tb: tbOffset = tb.GetSize().y * -1
|
if childCtrl.IsShown() and wxIntersectRect((clickPos.x, clickPos.y + tbOffset, 1, 1), (pos.x, pos.y, sze.x, sze.y)) is not None:
|
realParent = childCtrl.GetParent() if realParent.this[:8] != \ self.objects[officialParent][1].this[:8]: offset[0] = offset[0] + realParent.GetPosition().x offset[1] = offset[1] + realParent.GetPosition().y if childCtrl.IsShown() and realParent.IsShown() and \ wxIntersectRect((clickPos.x - offset[0], clickPos.y - offset[1], 1, 1), (pos.x, pos.y, sze.x, sze.y)) is not None:
|
def checkChildCtrlClick(self, ctrlName, ctrl, companion, clickPos): """ Check whether the click on the control actually falls within a region occupied by one of it's children. The click is then transfered to the child. """ selCtrl, selCompn, selPos = ctrl, companion, clickPos if companion.container: parent = ctrl else: parent = ctrl.GetParent() # Workaround toolbar offset bug tbOffset = 0 if parent == self: tb = self.GetToolBar() if tb: tbOffset = tb.GetSize().y * -1
|
selPos = wxPoint(clickPos.x - pos.x, clickPos.y + tbOffset - pos.y)
|
selPos = wxPoint(clickPos.x - offset[0] - pos.x, clickPos.y - offset[1] - pos.y)
|
def checkChildCtrlClick(self, ctrlName, ctrl, companion, clickPos): """ Check whether the click on the control actually falls within a region occupied by one of it's children. The click is then transfered to the child. """ selCtrl, selCompn, selPos = ctrl, companion, clickPos if companion.container: parent = ctrl else: parent = ctrl.GetParent() # Workaround toolbar offset bug tbOffset = 0 if parent == self: tb = self.GetToolBar() if tb: tbOffset = tb.GetSize().y * -1
|
Returns true if the ctrl also wants the click event
|
def selectControlByPos(self, ctrl, pos, multiSelect): """ Handle selection of a control from a users click of creation of a new one if a component was selected on the palette. Some ctrls do not register clicks, the click is then picked up from the parent which checks if a click intersects any child regions. For efficiency this is only applied for 2 levels. Also handles single and multiple selection logic. Returns true if the ctrl also wants the click event """ if ctrl == self: companion = self.companion else: companion = self.objects[ctrl.GetName()][0] ctrlName = companion.name
|
|
def _drawLines(self, dc, col, loglFunc, sze, sg): pen1 = wxPen(col) dc.SetPen(pen1) dc.SetLogicalFunction(loglFunc) for y in range(sze.y / sg): dc.DrawLine(0, y * sg, sze.x, y * sg) for x in range(sze.x / sg): dc.DrawLine(x * sg, 0, x * sg, sze.y) def drawGrid_intersectingLines(self, dc, sze, sg): bgCol = dc.GetBackground().GetColour() xorBgCol = wxColour(255^bgCol.Red(), 255^bgCol.Green(), 255^bgCol.Blue()) self._drawLines(dc, xorBgCol, wxCOPY, sze, sg) self._drawLines(dc, wxNamedColour('WHITE'), wxXOR, sze, sg) darken = 20 def drawGrid_grid(self, dc, sze, sg): bgCol = dc.GetBackground().GetColour() darkerBgCol = wxColour(max(bgCol.Red() -self.darken, 0), max(bgCol.Green() -self.darken, 0), max(bgCol.Blue() -self.darken, 0)) self._drawLines(dc, darkerBgCol, wxCOPY, sze, sg) def drawGrid_dots(self, dc, sze, sg): pen1 = wxPen(wxNamedColour('BLACK')) dc.SetPen(pen1) for y in range(sze.y / sg + 1): for x in range(sze.x / sg + 1): dc.DrawPoint(x * sg, y * sg) def drawGrid_bitmap(self, dc, sze, sg): pass def OnPaint(self, event): dc = wxPaintDC(self) sze = self.GetSize() sg = SelectionTags.screenGran drawGrid = self.drawGridMethods[Preferences.drawGridMethod] dc.BeginDrawing() try: drawGrid(dc, sze, sg) finally: dc.EndDrawing()
|
def _drawLines(self, dc, col, loglFunc, sze, sg): pen1 = wxPen(col) dc.SetPen(pen1) dc.SetLogicalFunction(loglFunc) for y in range(sze.y / sg): dc.DrawLine(0, y * sg, sze.x, y * sg) for x in range(sze.x / sg): dc.DrawLine(x * sg, 0, x * sg, sze.y)
|
|
sel.setSelection(true)
|
def moveUpdate(self, sel): sel.resizeCtrl() sel.setSelection(true) #sel.positionUpdate()
|
|
sel.startSize.x = sel.startSize.x + 1
|
def OnWidthInc(self, event): sel = self.selection if sel and sel.selection != self: sel.size.x = sel.size.x + 1 sel.startSize.x = sel.startSize.x + 1 self.sizeUpdate(sel)
|
|
sel.startSize.x = sel.startSize.x - 1
|
def OnWidthDec(self, event): sel = self.selection if sel and sel.selection != self and sel.size.x > 0: sel.size.x = sel.size.x - 1 sel.startSize.x = sel.startSize.x - 1 self.sizeUpdate(sel)
|
|
sel.startSize.y = sel.startSize.y + 1
|
def OnHeightInc(self, event): sel = self.selection if sel and sel.selection != self: sel.size.y = sel.size.y + 1 sel.startSize.y = sel.startSize.y + 1 self.sizeUpdate(sel)
|
|
sel.startSize.y = sel.startSize.y - 1
|
def OnHeightDec(self, event): sel = self.selection if sel and sel.selection != self and sel.size.y > 0: sel.size.y = sel.size.y - 1 sel.startSize.y = sel.startSize.y - 1 self.sizeUpdate(sel)
|
|
self.stTL, self.stTR, self.stBR, self.stBL, self.stT, self.stB, self.stR, self.stL]
|
self.stTL, self.stTR, self.stBR, self.stBL, self.stT, self.stB, self.stR, self.stL] self.anchorTags = [self.stL, self.stT, self.stR, self.stB]
|
def __init__(self, parent, senders, inspector, designer, colour, pnlStyle): self.designer = designer self.inspSel = None self.inspector = inspector self.parent = parent self.senders = senders self.selection = None self.selCompn = None self.dragTag = None self.dragging = false self.dragOffset = wxPoint() self.colour = colour self.name = ''
|
self.stT.destroy() self.stB.destroy() self.stR.destroy() self.stL.destroy() self.stTL.destroy() self.stTR.destroy() self.stBR.destroy() self.stBL.destroy() self.sfT.Destroy() self.sfR.Destroy() self.sfB.Destroy() self.sfL.Destroy()
|
self.stT.destroy();self.stB.destroy() self.stR.destroy();self.stL.destroy() self.stTL.destroy();self.stTR.destroy() self.stBR.destroy();self.stBL.destroy() self.sfT.Destroy();self.sfR.Destroy() self.sfB.Destroy();self.sfL.Destroy()
|
def destroy(self):
|
def __del__(self): print '__del__ selection group'
|
def __del__(self): print '__del__ selection group'
|
|
self.stTL.Show(true) self.stTR.Show(true) self.stBR.Show(true) self.stBL.Show(true) self.stT.Show(true) self.stB.Show(true) self.stL.Show(true) self.stR.Show(true) self.sfL.Show(false) self.sfR.Show(false) self.sfB.Show(false) self.sfT.Show(false)
|
self.stTL.Show(true); self.stTR.Show(true) self.stBR.Show(true); self.stBL.Show(true) self.stT.Show(true); self.stB.Show(true) self.stL.Show(true); self.stR.Show(true) self.sfL.Show(false); self.sfR.Show(false) self.sfB.Show(false); self.sfT.Show(false) map(lambda tag: tag.Refresh(), self.tags)
|
def showTags(self): self.stTL.Show(true) self.stTR.Show(true) self.stBR.Show(true) self.stBL.Show(true) self.stT.Show(true) self.stB.Show(true) self.stL.Show(true) self.stR.Show(true) self.sfL.Show(false) self.sfR.Show(false) self.sfB.Show(false) self.sfT.Show(false)
|
def moveRelease(self): if self.dragTag: self.OnSizeEnd(None) self.showTags() if self.dragging: self.selection.Show(false) self.hideTags() self.selection.SetDimensions( \ granularise(self.position.x), granularise(self.position.y), granularise(self.size.x -1), granularise(self.size.y -1)) self.selection.Show(true) self.dragging = false self.setSelection() self.showTags() self.positionUpdate()
|
def reparentTags(self, parent): map(lambda tag, newparent = parent: tag.Reparent(newparent), self.tags)
|
|
self.initStartVals() self.startPos = wxPoint(self.position.x, self.position.y) self.startSize = wxSize(self.size.x, self.size.y) self.updateAnchors()
|
def selectCtrl(self, ctrl, compn, selectInInspector = true): self.hideTags() if not ctrl: self.selection = None self.selCompn = None self.inspSel = None else: # XXX fix! if ctrl == self.designer: self.name = '' self.parent = ctrl cp = wxPoint(0, 0) screenPos = ctrl.ClientToScreen(cp) parentPos = self.parent.ScreenToClient(screenPos) else: self.name = ctrl.GetName() self.parent = ctrl.GetParent() cp = ctrl.GetPosition()
|
|
self.selection.SetDimensions( \ granularise(self.position.x), granularise(self.position.y), granularise(self.size.x - 1), granularise(self.size.y - 1))
|
self.selCompn.beforeResize() self.selection.SetDimensions(self.position.x, self.position.y, self.size.x, self.size.y) self.selCompn.afterResize()
|
def resizeCtrl(self): """ Set the selected control's dimensions by granulising the current selection group's size & pos """
|
trPos = wxPoint(granularise(position.x), granularise(position.y)) trSze = wxSize(granularise(size.x -1), granularise(size.y -1)) self.stTL.SetDimensions(trPos.x -4, trPos.y -4, tagSize, tagSize) self.stTR.SetDimensions(trPos.x -3 + trSze.x, trPos.y -4, tagSize, tagSize) self.stBR.SetDimensions(trPos.x -3 + trSze.x, trPos.y -3 + trSze.y, tagSize, tagSize) self.stBL.SetDimensions(trPos.x -4, trPos.y -3 + trSze.y, tagSize, tagSize) self.stT.SetDimensions(trPos.x -4 + trSze.x/2, trPos.y -4, tagSize, tagSize) self.stB.SetDimensions(trPos.x -4 + trSze.x/2, trPos.y -3 + trSze.y, tagSize, tagSize) self.stL.SetDimensions(trPos.x -4, trPos.y -4 + trSze.y/2, tagSize, tagSize) self.stR.SetDimensions(trPos.x -3 +trSze.x, trPos.y -4 + trSze.y/2, tagSize, tagSize)
|
sz = self.startSize ps = self.startPos if sz is None and ps is None: trPos = wxPoint(granularise(position.x), granularise(position.y)) trSze = wxSize(granularise(size.x), granularise(size.y)) else: trPos = wxPoint(granularise(position.x, ps.x), granularise(position.y, ps.y)) trSze = wxSize(granularise(size.x + position.x, sz.x + ps.x) - trPos.x, granularise(size.y + position.y, sz.y + ps.y) - trPos.y) if not self.dragging: self.stTL.SetDimensions(trPos.x -4, trPos.y -4, tagSize, tagSize) self.stTR.SetDimensions(trPos.x -3 + trSze.x, trPos.y -4, tagSize, tagSize) self.stBR.SetDimensions(trPos.x -3 + trSze.x, trPos.y -3 + trSze.y, tagSize, tagSize) self.stBL.SetDimensions(trPos.x -4, trPos.y -3 + trSze.y, tagSize, tagSize) self.stT.SetDimensions(trPos.x -4 + trSze.x/2, trPos.y -4, tagSize, tagSize) self.stB.SetDimensions(trPos.x -4 + trSze.x/2, trPos.y -3 + trSze.y, tagSize, tagSize) self.stL.SetDimensions(trPos.x -4, trPos.y -4 + trSze.y/2, tagSize, tagSize) self.stR.SetDimensions(trPos.x -3 +trSze.x, trPos.y -4 + trSze.y/2, tagSize, tagSize)
|
def setSelection(self): position = self.position size = self.size
|
self.sfR.SetDimensions(trPos.x + trSze.x, trPos.y -frmWid, frmWid, trSze.y+frmWid) self.sfB.SetDimensions(trPos.x -frmWid, trPos.y + trSze.y, trSze.x +frmWid, frmWid)
|
self.sfR.SetDimensions(trPos.x + trSze.x, trPos.y -frmWid, frmWid, trSze.y+frmWid*2) self.sfB.SetDimensions(trPos.x -frmWid, trPos.y + trSze.y, trSze.x +frmWid*2, frmWid)
|
def setSelection(self): position = self.position size = self.size
|
def updateAnchors(self): for idx in range(4): if self.selCompn.anchorSettings: self.anchorTags[idx].setAnchor(self.selCompn.anchorSettings[idx]) else: self.anchorTags[idx].setAnchor(None)
|
def setSelection(self): position = self.position size = self.size
|
|
def setSelection(self): position = self.position size = self.size trPos = wxPoint(granularise(position.x), granularise(position.y)) trSze = wxSize(granularise(size.x -1), granularise(size.y -1)) self.stTL.SetDimensions(trPos.x -4, trPos.y -4, tagSize, tagSize) self.stTR.SetDimensions(trPos.x -3 + trSze.x, trPos.y -4, tagSize, tagSize) self.stBR.SetDimensions(trPos.x -3 + trSze.x, trPos.y -3 + trSze.y, tagSize, tagSize) self.stBL.SetDimensions(trPos.x -4, trPos.y -3 + trSze.y, tagSize, tagSize) self.stT.SetDimensions(trPos.x -4 + trSze.x/2, trPos.y -4, tagSize, tagSize) self.stB.SetDimensions(trPos.x -4 + trSze.x/2, trPos.y -3 + trSze.y, tagSize, tagSize) self.stL.SetDimensions(trPos.x -4, trPos.y -4 + trSze.y/2, tagSize, tagSize) self.stR.SetDimensions(trPos.x -3 +trSze.x, trPos.y -4 + trSze.y/2, tagSize, tagSize) self.sfT.SetDimensions(trPos.x -frmWid, trPos.y -2, trSze.x +frmWid, frmWid) self.sfR.SetDimensions(trPos.x + trSze.x, trPos.y -frmWid, frmWid, trSze.y+frmWid*2) self.sfB.SetDimensions(trPos.x -frmWid, trPos.y + trSze.y, trSze.x +frmWid*2, frmWid) self.sfL.SetDimensions(trPos.x -2, trPos.y-frmWid, frmWid, trSze.y +frmWid) self.position = trPos self.size = trSze
|
def setSelection(self): position = self.position size = self.size
|
|
self.initStartVals()
|
def OnSizeBegin(self, event): self.dragTag = self.senders.getObject(event) self.showFramedTags(self.dragTag)
|
|
print 'MultiSelectionGroup.selectCtrl'
|
def selectCtrl(self, ctrl, compn): print 'MultiSelectionGroup.selectCtrl' SelectionGroup.selectCtrl(self, ctrl, compn) self.inspSel = None self.inspector.cleanup() self.inspector.multiSelectObject(None, self.designer)
|
|
def setSelection(self): position = self.position size = self.size trPos = wxPoint(granularise(position.x), granularise(position.y)) trSze = wxSize(granularise(size.x -1), granularise(size.y -1)) if not self.dragging: self.stTL.SetDimensions(trPos.x -4, trPos.y -4, tagSize, tagSize) self.stTR.SetDimensions(trPos.x -3 + trSze.x, trPos.y -4, tagSize, tagSize) self.stBR.SetDimensions(trPos.x -3 + trSze.x, trPos.y -3 + trSze.y, tagSize, tagSize) self.stBL.SetDimensions(trPos.x -4, trPos.y -3 + trSze.y, tagSize, tagSize) self.stT.SetDimensions(trPos.x -4 + trSze.x/2, trPos.y -4, tagSize, tagSize) self.stB.SetDimensions(trPos.x -4 + trSze.x/2, trPos.y -3 + trSze.y, tagSize, tagSize) self.stL.SetDimensions(trPos.x -4, trPos.y -4 + trSze.y/2, tagSize, tagSize) self.stR.SetDimensions(trPos.x -3 +trSze.x, trPos.y -4 + trSze.y/2, tagSize, tagSize) self.sfT.SetDimensions(trPos.x -frmWid, trPos.y -2, trSze.x +frmWid, frmWid) self.sfR.SetDimensions(trPos.x + trSze.x, trPos.y -frmWid, frmWid, trSze.y+frmWid*2) self.sfB.SetDimensions(trPos.x -frmWid, trPos.y + trSze.y, trSze.x +frmWid*2, frmWid) self.sfL.SetDimensions(trPos.x -2, trPos.y-frmWid, frmWid, trSze.y +frmWid) self.position = trPos self.size = trSze
|
def setSelection(self): position = self.position size = self.size
|
|
self.SetBackgroundColour(group.colour) self.SetForegroundColour(wxBLACK)
|
def __init__(self, parent, cursor, tagSize, group, pnlStyle):# = wxSIMPLE_BORDER): wxPanel.__init__(self, parent, -1, size = wxSize(tagSize, tagSize), style = pnlStyle) self.Show(false) self.group = group self.SetBackgroundColour(group.colour) self.SetForegroundColour(wxBLACK) self.SetCursor(wxStockCursor(cursor)) self.selection = None self.position = wxSize(0, 0)
|
|
grp.size.x, grp.size.y = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x grp.position.y = oldPos.y + oldSize.y
|
grp.size.x = screenGran - grp.size.x % screenGran grp.size.y = screenGran - grp.size.y % screenGran if oldPos and oldSize: if oldPos.x != grp.position.x: grp.position.x = oldPos.x + oldSize.x if oldPos.y != grp.position.y: grp.position.y = oldPos.y + oldSize.y grp.startPos = wxPoint(grp.position.x, grp.position.y) grp.startSize = wxSize(grp.size.x, grp.size.y)
|
def setPos(self, position, mirrorX, mirrorY, mirrorXY, oldPos = None, oldSize = None): grp = self.group if grp.size.x < 0 and grp.size.y < 0: grp.size.x, grp.size.y = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x grp.position.y = oldPos.y + oldSize.y grp.dragTag = mirrorXY elif grp.size.x < 0: grp.size.x = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x grp.dragTag = mirrorX elif self.group.size.y < 0: grp.size.y = 0 if oldPos and oldSize: grp.position.y = oldPos.y + oldSize.y grp.dragTag = mirrorY grp.setSelection()
|
grp.size.x = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x
|
grp.size.x = screenGran - grp.size.x % screenGran if oldPos and oldSize and not (oldPos.x == grp.position.x): grp.position.x = oldPos.x + oldSize.x grp.startPos = wxPoint(grp.position.x, grp.position.y) grp.startSize = wxSize(grp.size.x, grp.size.y)
|
def setPos(self, position, mirrorX, mirrorY, mirrorXY, oldPos = None, oldSize = None): grp = self.group if grp.size.x < 0 and grp.size.y < 0: grp.size.x, grp.size.y = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x grp.position.y = oldPos.y + oldSize.y grp.dragTag = mirrorXY elif grp.size.x < 0: grp.size.x = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x grp.dragTag = mirrorX elif self.group.size.y < 0: grp.size.y = 0 if oldPos and oldSize: grp.position.y = oldPos.y + oldSize.y grp.dragTag = mirrorY grp.setSelection()
|
grp.size.y = 0 if oldPos and oldSize: grp.position.y = oldPos.y + oldSize.y
|
grp.size.y = screenGran - grp.size.y % screenGran if oldPos and oldSize and not (oldPos.y == grp.position.y): grp.position.y = oldPos.y + oldSize.y
|
def setPos(self, position, mirrorX, mirrorY, mirrorXY, oldPos = None, oldSize = None): grp = self.group if grp.size.x < 0 and grp.size.y < 0: grp.size.x, grp.size.y = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x grp.position.y = oldPos.y + oldSize.y grp.dragTag = mirrorXY elif grp.size.x < 0: grp.size.x = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x grp.dragTag = mirrorX elif self.group.size.y < 0: grp.size.y = 0 if oldPos and oldSize: grp.position.y = oldPos.y + oldSize.y grp.dragTag = mirrorY grp.setSelection()
|
grp.startPos = wxPoint(grp.position.x, grp.position.y) grp.startSize = wxSize(grp.size.x, grp.size.y)
|
def setPos(self, position, mirrorX, mirrorY, mirrorXY, oldPos = None, oldSize = None): grp = self.group if grp.size.x < 0 and grp.size.y < 0: grp.size.x, grp.size.y = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x grp.position.y = oldPos.y + oldSize.y grp.dragTag = mirrorXY elif grp.size.x < 0: grp.size.x = 0 if oldPos and oldSize: grp.position.x = oldPos.x + oldSize.x grp.dragTag = mirrorX elif self.group.size.y < 0: grp.size.y = 0 if oldPos and oldSize: grp.position.y = oldPos.y + oldSize.y grp.dragTag = mirrorY grp.setSelection()
|
|
class TLSelTag(SelectionTag): def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size
|
def setAnchor(self, anchor): self.anchored = anchor is not None and anchor if anchor is None: col = self.group.colour elif anchor: col = anchorEnabledCol else: col = anchorDisabledCol self.SetBackgroundColour(col) self.Refresh() def updateCtrlAnchors(self, anchor): self.group.selCompn.updateAnchors(self.toggleAnchors, anchor) self.group.selCompn.applyConstraints() self.group.updateAnchors() self.group.inspector.propertyUpdate('Anchors') def OnRightClick(self, event): pass def OnAnchorToggle(self, event): pass class CornerSelTag(SelectionTag): pass class SideSelTag(SelectionTag): def OnRightClick(self, event): self.menu.Check(self.wxID_ANCHORED, self.anchored) self.PopupMenu(self.menu, event.GetPosition()) def OnAnchorToggle(self, event): self.updateCtrlAnchors(not self.menu.IsChecked(self.wxID_ANCHORED)) class TLSelTag(CornerSelTag): name = 'top left' toggleAnchors = (1, 1, 0, 0) def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size
|
def destroy(self): del self.group self.Destroy()
|
class TRSelTag(SelectionTag): def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size
|
class TRSelTag(CornerSelTag): name = 'top right' toggleAnchors = (0, 1, 1, 0) def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size
|
def setPos(self, position): grp = self.group
|
class BRSelTag(SelectionTag): def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size
|
class BRSelTag(CornerSelTag): name = 'bottom right' toggleAnchors = (0, 0, 1, 1) def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size
|
def setPos(self, position): grp = self.group
|
class BLSelTag(SelectionTag): def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size
|
class BLSelTag(CornerSelTag): name = 'bottom left' toggleAnchors = (1, 0, 0, 1) def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size
|
def setPos(self, position): grp = self.group
|
class TSelTag(SelectionTag): def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size
|
class LSelTag(SideSelTag): name = 'left' toggleAnchors = (1, 0, 0, 0) def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size grp.size = wxSize((oldPos.x - position.x) + grp.size.x, grp.size.y) grp.position = wxPoint(position.x, grp.position.y) SelectionTag.setPos(self, position, grp.stR, None, None, oldPos, oldSize) class TSelTag(SideSelTag): name = 'top' toggleAnchors = (0, 1, 0, 0) def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size
|
def setPos(self, position): grp = self.group
|
class BSelTag(SelectionTag): def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size
|
class RSelTag(SideSelTag): name = 'right' toggleAnchors = (0, 0, 1, 0) def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size grp.size = wxSize((position.x - oldPos.x), grp.size.y) grp.position = wxPoint(grp.position.x, grp.position.y) SelectionTag.setPos(self, position, grp.stL, None, None) class BSelTag(SideSelTag): name = 'bottom' toggleAnchors = (0, 0, 0, 1) def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size
|
def setPos(self, position): grp = self.group
|
class LSelTag(SelectionTag): def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size grp.size = wxSize((oldPos.x - position.x) + grp.size.x, grp.size.y) grp.position = wxPoint(position.x, grp.position.y) SelectionTag.setPos(self, position, grp.stR, None, None, oldPos, oldSize) class RSelTag(SelectionTag): def setPos(self, position): grp = self.group oldPos = grp.position oldSize = grp.size grp.size = wxSize((position.x - oldPos.x), grp.size.y) grp.position = wxPoint(grp.position.x, grp.position.y) SelectionTag.setPos(self, position, grp.stL, None, None)
|
def test(): global screenGran screenGran = 8 oldVal = 14 tstData = [0, 3, 7, 8, 15, 20, 30] answers = [0, 0, 8, 8, 14, 24, 32] results = [] for tstVal, answ in zip(tstData, answers): gv = granularise(tstVal, oldVal) if gv != answ: print 'failed for', tstVal, oldVal, 'got', gv, 'should be', answ results.append(gv) print 'results:', results if __name__ == '__main__': test()
|
def setPos(self, position): grp = self.group
|
self.execCmd("rm '%s'" % string.join(absNames, ' '))
|
self.execCmd("rm -rf '%s'" % string.join(absNames, ' '))
|
def deleteItems(self, names): absNames = [] for name in names: absNames.append(self.resourcepath + '/' +name) self.execCmd("rm '%s'" % string.join(absNames, ' '))
|
def pasteFileSysFolder(self, folderpath, nodepath, zopeConn): zopeConn.add_folder(os.path.basename(folderpath), nodepath)
|
def pasteFileSysFolder(self, folderpath, nodepath, node): node.zopeConn.add_folder(os.path.basename(folderpath), nodepath)
|
def pasteFileSysFolder(self, folderpath, nodepath, zopeConn): zopeConn.add_folder(os.path.basename(folderpath), nodepath) files = os.listdir(folderpath) folder = os.path.basename(folderpath) newNodepath = nodepath+'/'+folder for file in files: file = os.path.join(folderpath, file) if os.path.isdir(file): self.pasteFileSysFolder(file, newNodepath, zopeConn) else: zopeConn.upload(file, newNodepath)
|
self.pasteFileSysFolder(file, newNodepath, zopeConn)
|
self.pasteFileSysFolder(file, newNodepath, node)
|
def pasteFileSysFolder(self, folderpath, nodepath, zopeConn): zopeConn.add_folder(os.path.basename(folderpath), nodepath) files = os.listdir(folderpath) folder = os.path.basename(folderpath) newNodepath = nodepath+'/'+folder for file in files: file = os.path.join(folderpath, file) if os.path.isdir(file): self.pasteFileSysFolder(file, newNodepath, zopeConn) else: zopeConn.upload(file, newNodepath)
|
zopeConn.upload(file, newNodepath)
|
node.zopeConn.upload(file, newNodepath)
|
def pasteFileSysFolder(self, folderpath, nodepath, zopeConn): zopeConn.add_folder(os.path.basename(folderpath), nodepath) files = os.listdir(folderpath) folder = os.path.basename(folderpath) newNodepath = nodepath+'/'+folder for file in files: file = os.path.join(folderpath, file) if os.path.isdir(file): self.pasteFileSysFolder(file, newNodepath, zopeConn) else: zopeConn.upload(file, newNodepath)
|
node.zopeConn)
|
node)
|
def clipPaste_FileSysExpClipboard(self, node, nodes, mode): nodepath = node.resourcepath+'/'+node.name for file in nodes: if file.isDir(): self.pasteFileSysFolder(file.resourcepath, nodepath, node.zopeConn) else: node.zopeConn.upload(file.resourcepath, nodepath)
|
Utils.ShowMessage(None, 'Zope Error', resp)
|
Utils.ShowMessage(None, 'Zope Error', `resp`)
|
def openList(self, root = None): try: wxBeginBusyCursor() try: items = self.zopeConn.dir(self.zopeObj.whole_name()) finally: wxEndBusyCursor() except ftplib.error_perm, resp: Utils.ShowMessage(None, 'Zope Error', resp) raise
|
def newItem(self, name, Compn):
|
def newItem(self, name, Compn, getNewValidName = true):
|
def newItem(self, name, Compn): props = self.root.properties cmp = Compn(Utils.getValidName(self.cache.keys(), name), self.zopeObj.whole_name(), props.get('localpath', '')) cmp.connect(props['host'], props['httpport'], props['username'], props['passwd']) cmp.create() return cmp.name
|
cmp = Compn(Utils.getValidName(self.cache.keys(), name), self.zopeObj.whole_name(), props.get('localpath', ''))
|
if getNewValidName: name = Utils.getValidName(self.cache.keys(), name) cmp = Compn(name, self.zopeObj.whole_name(), props.get('localpath', ''))
|
def newItem(self, name, Compn): props = self.root.properties cmp = Compn(Utils.getValidName(self.cache.keys(), name), self.zopeObj.whole_name(), props.get('localpath', '')) cmp.connect(props['host'], props['httpport'], props['username'], props['passwd']) cmp.create() return cmp.name
|
print doToggle
|
def AddToolButtonBmpObject(frame, toolbar, thebitmap, hint, triggermeth, theToggleBitmap = wxNullBitmap): nId = wxNewId() doToggle = theToggleBitmap != wxNullBitmap print doToggle
|
|
class ShellEditor(StyledTextCtrls.wxStyledTextCtrl,
|
class ShellEditor(wx.stc.StyledTextCtrl,
|
def getShellLocals(self): return {}
|
StyledTextCtrls.wxStyledTextCtrl.__init__(self, parent, wId,
|
wx.stc.StyledTextCtrl.__init__(self, parent, wId,
|
def __init__(self, parent, wId): StyledTextCtrls.wxStyledTextCtrl.__init__(self, parent, wId, style = wx.CLIP_CHILDREN | wx.SUNKEN_BORDER) StyledTextCtrls.CallTipCodeHelpSTCMix.__init__(self) StyledTextCtrls.AutoCompleteCodeHelpSTCMix.__init__(self) StyledTextCtrls.PythonStyledTextCtrlMix.__init__(self, wId, ())
|
tip = tip.replace('(self, ', '(') tip = tip.replace('(self)', '()')
|
tip = tip.replace('(self, ', '(', 1).replace('(self)', '()', 1)
|
def getTipValue(self, word, lnNo): (name, argspec, tip) = wx.py.introspect.getCallTip(word, self.interp.locals)
|
def __init__(self, parent, message = 'Choose a file', defaultDir = '.', defaultFile = '', wildcard = '*.*', style = wxOPEN, wildcard = '*.py; *.txt', pos = wxDefaultPosition):
|
def __init__(self, parent, message = 'Choose a file', defaultDir = '.', defaultFile = '', style = wxOPEN, wildcard = '*.py; *.txt', pos = wxDefaultPosition):
|
def __init__(self, parent, message = 'Choose a file', defaultDir = '.', defaultFile = '', wildcard = '*.*', style = wxOPEN, wildcard = '*.py; *.txt', pos = wxDefaultPosition): self._init_ctrls(parent) self.SetStyle(style) self.SetWildcard(wildcard)
|
import Explorer
|
from Explorers import Explorer
|
def __init__(self, parent, message = 'Choose a file', defaultDir = '.', defaultFile = '', wildcard = '*.*', style = wxOPEN, wildcard = '*.py; *.txt', pos = wxDefaultPosition): self._init_ctrls(parent) self.SetStyle(style) self.SetWildcard(wildcard)
|
import Explorer
|
from Explorers import Explorer
|
def __init__(self, parent, dlg, filepath, pos = wxDefaultPosition, size = wxDefaultSize): import Explorer Explorer.PackageFolderList.__init__(self, parent, filepath, pos, size) self.dlg = dlg
|
import Explorer
|
from Explorers import Explorer
|
def OnItemSelect(self, event): import Explorer Explorer.PackageFolderList.OnItemSelect(self, event) item = self.getSelection() if item: self.dlg.SelectItem(item.name) elif self.selected == 0: self.dlg.SelectItem('..')
|
import Explorer
|
from Explorers import Explorer
|
def OnItemDeselect(self, event): import Explorer Explorer.PackageFolderList.OnItemDeselect(self, event) self.dlg.SelectItem(None)
|
import Explorer return Explorer.PyFileNode(path.basename(defaultDir), defaultDir, None, Explorer.FolderModel.imgIdx, None)
|
from Explorers import FileExplorer, Explorer return FileExplorer.PyFileNode(path.basename(defaultDir), defaultDir, None, Explorer.EditorModels.FolderModel.imgIdx, None, None)
|
def newFileNode(self, defaultDir): import Explorer return Explorer.PyFileNode(path.basename(defaultDir), defaultDir, None, Explorer.FolderModel.imgIdx, None)
|
import Preferences, Explorer
|
import Preferences from Explorers import FileExplorer
|
def ok(self): if self.lcFiles.selected == 0: node = self.lcFiles.node.createParentNode() if node: node.doCVS = false if node.resourcepath == self.lcFiles.node.resourcepath: from ExternalLib.ConfigParser import ConfigParser import Preferences, Explorer conf = ConfigParser() conf.read(Preferences.pyPath+'/Explorer.'+\ (wxPlatform == '__WXMSW__' and 'msw' or 'gtk')+'.cfg') fsn = Explorer.FileSysCatNode(None, conf, None) self.lcFiles.refreshItems(self.modImages, fsn) self.stPath.SetLabel(fsn.name) if self.style & wxSAVE: btn = saveStr else: btn = openStr self.btOK.SetLabel(btn) return else: node = self.lcFiles.getSelection() if node: node.doCVS = false
|
fsn = Explorer.FileSysCatNode(None, conf, None)
|
fsn = FileExplorer.FileSysCatNode(None, conf, None)
|
def ok(self): if self.lcFiles.selected == 0: node = self.lcFiles.node.createParentNode() if node: node.doCVS = false if node.resourcepath == self.lcFiles.node.resourcepath: from ExternalLib.ConfigParser import ConfigParser import Preferences, Explorer conf = ConfigParser() conf.read(Preferences.pyPath+'/Explorer.'+\ (wxPlatform == '__WXMSW__' and 'msw' or 'gtk')+'.cfg') fsn = Explorer.FileSysCatNode(None, conf, None) self.lcFiles.refreshItems(self.modImages, fsn) self.stPath.SetLabel(fsn.name) if self.style & wxSAVE: btn = saveStr else: btn = openStr self.btOK.SetLabel(btn) return else: node = self.lcFiles.getSelection() if node: node.doCVS = false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.