rem
stringlengths 0
322k
| add
stringlengths 0
2.05M
| context
stringlengths 8
228k
|
|---|---|---|
print 'loading python mod idx help', HelpCompanions.modRefDocs[word]
|
def showContextHelp(parent, toolbar, word): print 'looking up help for', word from Companions import HelpCompanions helpStr = word+'Docs' if HelpCompanions.__dict__.has_key(helpStr): print 'loading wxWin help', HelpCompanions.__dict__[helpStr] showHelp(parent, wxWinHelpFrame, HelpCompanions.__dict__[helpStr], toolbar) elif HelpCompanions.libRefDocs.has_key(word): print 'loading python lib ref help', HelpCompanions.libRefDocs[word] showHelp(parent, PythonHelpFrame, HelpCompanions.libRefDocs[word], toolbar) elif HelpCompanions.modRefDocs.has_key(word): print 'loading python mod idx help', HelpCompanions.modRefDocs[word] showHelp(parent, PythonHelpFrame, HelpCompanions.modRefDocs[word], toolbar) else: print 'No help found'
|
|
self.SetDimensions(120, 75, Preferences.wxDefaultFrameSize.x, Preferences.wxDefaultFrameSize.y)
|
self.SetSize(Preferences.wxDefaultFrameSize) self.CenterOnScreen(wxBOTH)
|
def __init__(self, parent, home, index, icon, paletteToolbar = None): self._init_ctrls(parent) self._init_utils() self.SetDimensions(120, 75, Preferences.wxDefaultFrameSize.x, Preferences.wxDefaultFrameSize.y)
|
except ImportError: pass
|
except (ImportError, AttributeError): pass
|
def designTimeSource(self, position = 'wx.DefaultPosition', size = 'wx.DefaultSize'): return {'text': `self.name`, 'start': 'False', 'direction': `'rtl'`, 'pos': position, 'size': size, 'style': '0', 'name': `self.name`}
|
if urlregex.match(url) >= 0: host,port,uri=urlregex.group(1,2,3)
|
mo = urlreg.match(url) if mo: host,port,uri=mo.group(1,2,3)
|
def __init__(self, url, username=None, password=None): self.username=username self.password=password self.url=url if urlregex.match(url) >= 0: host,port,uri=urlregex.group(1,2,3) self.host=host self.port=port and string.atoi(port[1:]) or 80 self.uri=uri or '/' else: raise ValueError, url
|
isbin=regex.compile('[\0-\6\177-\277]').search,
|
isbin=re.compile(r'[\000-\006\177-\277]').search,
|
def put(self, file='', content_type='', content_enc='', isbin=regex.compile('[\0-\6\177-\277]').search, **kw): headers=self.__get_headers(kw) filetype=type(file) if filetype is type('') and (isbin(file) < 0) and \ os.path.exists(file): ob=open(file, 'rb') body=ob.read() ob.close() c_type, c_enc=guess_type(file) elif filetype is FileType: body=file.read() c_type, c_enc=guess_type(file.name) elif filetype is type(''): body=file c_type, c_enc=guess_type(self.url) else: raise ValueError, 'File must be a filename, file or string.' content_type=content_type or c_type content_enc =content_enc or c_enc if content_type: headers['Content-Type']=content_type if content_enc: headers['Content-Encoding']=content_enc headers['Content-Length']=str(len(body)) return self.__snd_request('PUT', self.uri, headers, body)
|
if filetype is type('') and (isbin(file) < 0) and \
|
if filetype is type('') and (isbin(file) is None) and \
|
def put(self, file='', content_type='', content_enc='', isbin=regex.compile('[\0-\6\177-\277]').search, **kw): headers=self.__get_headers(kw) filetype=type(file) if filetype is type('') and (isbin(file) < 0) and \ os.path.exists(file): ob=open(file, 'rb') body=ob.read() ob.close() c_type, c_enc=guess_type(file) elif filetype is FileType: body=file.read() c_type, c_enc=guess_type(file.name) elif filetype is type(''): body=file c_type, c_enc=guess_type(self.url) else: raise ValueError, 'File must be a filename, file or string.' content_type=content_type or c_type content_enc =content_enc or c_enc if content_type: headers['Content-Type']=content_type if content_enc: headers['Content-Encoding']=content_enc headers['Content-Length']=str(len(body)) return self.__snd_request('PUT', self.uri, headers, body)
|
'</d:lockinfo>' % (scope, type, owner)
|
'</d:lockinfo>' % (scope, type, depth, owner)
|
def lock(self, scope='exclusive', type='write', owner='', depth='infinity', timeout='Infinite', **kw): """Create a lock with the specified scope, type, owner, depth and timeout on the resource. A locked resource prevents a principal without the lock from executing a PUT, POST, PROPPATCH, LOCK, UNLOCK, MOVE, DELETE, or MKCOL on the locked resource.""" if not scope in ('shared', 'exclusive'): raise ValueError, 'Invalid lock scope.' if not type in ('write',): raise ValueError, 'Invalid lock type.' if not depth in ('0', 'infinity'): raise ValueError, 'Invalid depth.' headers=self.__get_headers(kw) body='<?xml version="1.0" encoding="utf-8"?>\n' \ '<d:lockinfo xmlns:d="DAV:">\n' \ ' <d:lockscope><d:%s/></d:lockscope>\n' \ ' <d:locktype><d:%s/></d:locktype>\n' \ ' <d:owner>\n' \ ' <d:href>%s</d:href>\n' \ ' </d:owner>\n' \ '</d:lockinfo>' % (scope, type, owner) headers['Content-Type']='text/xml; charset="utf-8"' headers['Content-Length']=str(len(body)) headers['Timeout']=timeout headers['Depth']=depth return self.__snd_request('LOCK', self.uri, headers, body)
|
urlregex=regex.compile('http://\([^:/]+\)\(:[0-9]+\)?\(/.+\)?', regex.casefold)
|
urlreg=re.compile(r'http://([^:/]+)(:[0-9]+)?(/.+)?', re.I)
|
def __str__(self): data=[] data.append('%s %s %s\r\n' % (self.version, self.code, self.msg)) map(data.append, self.headers.headers) data.append('\r\n') data.append(self.body) return string.join(data, '')
|
bri =Resource('http://tarzan.digicool.com/dev/brian3/', username='brian', password='123') abri=Resource('http://tarzan.digicool.com/dev/brian3/') dav =Resource('http://tarzan.digicool.com/dev/dav/', username='brian', password='123') adav=Resource('http://tarzan.digicool.com/dev/dav/')
|
def render(self): join=string.join h=self._headers s=[]
|
|
indent = string.strip(prevline, '\r\n')
|
try: indent = prevline.strip('\r\n', 1) except TypeError: indent = prevline while indent and indent[-1] in ('\r', '\n'): indent = indent[:-1]
|
def doAutoIndent(self, prevline, pos): stripprevline = prevline.strip() if stripprevline: indent = prevline[:prevline.find(stripprevline)] else: # python 2.2.1 does not support the strip parameter. indent = string.strip(prevline, '\r\n')
|
self.setStyles(faces) def setStyles(self, faces):
|
'and assert break class continue def del elif else except '
|
|
self.StyleSetSpec(wxSTC_STYLE_DEFAULT, "face:%(mono)s,size:%(size)d" % faces)
|
self.StyleSetSpec(wxSTC_STYLE_DEFAULT, "back:%(backcol)s,face:%(mono)s,size:%(size)d" % faces)
|
'and assert break class continue def del elif else except '
|
def idWord(line, piv, lineStart, delim = word_delim):
|
def idWord(line, piv, lineStart, leftDelim = word_delim, rightDelim = word_delim):
|
def idWord(line, piv, lineStart, delim = word_delim): if piv >= len(line): return 0, 0 pivL = pivR = piv for pivL in range(piv, -1, -1): if not line[pivL] in delim: pivL = pivL + 1 break for pivR in range(piv + 1, len(line)): if not line[pivR] in delim: break return pivL + lineStart, pivR - pivL
|
if not line[pivL] in delim:
|
if not line[pivL] in leftDelim:
|
def idWord(line, piv, lineStart, delim = word_delim): if piv >= len(line): return 0, 0 pivL = pivR = piv for pivL in range(piv, -1, -1): if not line[pivL] in delim: pivL = pivL + 1 break for pivR in range(piv + 1, len(line)): if not line[pivR] in delim: break return pivL + lineStart, pivR - pivL
|
if not line[pivR] in delim: break
|
if not line[pivR] in rightDelim: break
|
def idWord(line, piv, lineStart, delim = word_delim): if piv >= len(line): return 0, 0 pivL = pivR = piv for pivL in range(piv, -1, -1): if not line[pivL] in delim: pivL = pivL + 1 break for pivR in range(piv + 1, len(line)): if not line[pivR] in delim: break return pivL + lineStart, pivR - pivL
|
self.eol = wxSTC_EOL_LF
|
self.eol = '\n'
|
def __init__(self, wId): self.SetEOLMode(wxSTC_EOL_LF) self.eol = wxSTC_EOL_LF #endOfLines[self.GetEOLMode()]
|
self.eol = wxSTC_EOL_LF
|
self.eol = '\n'
|
def __init__(self, wId): self.SetEOLMode(wxSTC_EOL_LF) self.eol = wxSTC_EOL_LF #endOfLines[self.GetEOLMode()] keyWds = \ 'asm auto bool break case catch char class const const_cast continue '\ 'default delete do double dynamic_cast else enum explicit export '\ 'extern false float for friend goto if inline int long mutable '\ 'namespace new operator private protected public register '\ 'reinterpret_cast return short signed sizeof static static_cast '\ 'struct switch template this throw true try typedef typeid typename '\ 'union unsigned using virtual void volatile wchar_t while'
|
if ctrl.this == self.designer.this: tb = self.designer.GetToolBar() if tb: parentPos.y = parentPos.y - tb.GetSize().y
|
def moving(self, ctrl, pos, multiDragCtrl = None): # Calculate relative position if it is a multiple selection drag if multiDragCtrl: dragCtrlPos = multiDragCtrl.GetPosition() movingCtrlPos = self.selection.GetPosition() pos = wxPoint(pos.x - dragCtrlPos.x + movingCtrlPos.x, pos.y - dragCtrlPos.y + movingCtrlPos.y)
|
|
if ctrl == self.designer: tb = self.designer.GetToolBar() if tb: offsetY = offsetY + tb.GetSize().y
|
def moving(self, ctrl, pos, multiDragCtrl = None): # Calculate relative position if it is a multiple selection drag if multiDragCtrl: dragCtrlPos = multiDragCtrl.GetPosition() movingCtrlPos = self.selection.GetPosition() pos = wxPoint(pos.x - dragCtrlPos.x + movingCtrlPos.x, pos.y - dragCtrlPos.y + movingCtrlPos.y)
|
|
self.showTags()
|
showTags = true
|
def selectCtrl(self, ctrl, compn, selectInInspector = true): self.hideTags() if not ctrl: self.selection = None self.selCompn = None self.inspSel = None else: if ctrl.this == self.designer.this: self.name = '' self.parent = ctrl cp = (0, 0)
|
self.anchorTags[idx].setAnchor(None)
|
if not self.anchorTags[idx].setHasSizer(self.selCompn): self.anchorTags[idx].setAnchor(None)
|
def updateAnchors(self): if self.selCompn: for idx in range(4): if self.selCompn.anchorSettings: self.anchorTags[idx].setAnchor(self.selCompn.anchorSettings[idx]) else: self.anchorTags[idx].setAnchor(None)
|
menu.Append(self.wxID_ANCHORED, 'Anchored', '', true) menu.Check(self.wxID_ANCHORED, self.anchored)
|
if self.hasSizer or self.inSizer: menu.Append(self.wxID_SIZERED, 'Select sizer') else: menu.Append(self.wxID_ANCHORED, 'Anchored', '', true) menu.Check(self.wxID_ANCHORED, self.anchored)
|
def OnRightClick(self, event): menu = wxMenu() try: menu.Append(self.wxID_ANCHORED, 'Anchored', '', true) menu.Check(self.wxID_ANCHORED, self.anchored) self.PopupMenu(menu, event.GetPosition()) finally: menu.Destroy()
|
def __init__(self, name, parent, companion, rootCompanion, propWrapper, idx, width):
|
def __init__(self, name, parent, companion, rootCompanion, propWrapper, idx, width, _1=None , _2=None):
|
def __init__(self, name, parent, companion, rootCompanion, propWrapper, idx, width): self.name = name self.parent = parent self.idx = idx self.width = width self.editorCtrl = None self.propWrapper = propWrapper self.companion = companion self.obj = companion.control self.propWrapper.connect(self.obj, self.companion) self.rootCompanion = rootCompanion self.root = rootCompanion.control self.initFromComponent() self.style = []
|
self.propWrapper = propWrapper
|
def __init__(self, name, parent, companion, rootCompanion, propWrapper, idx, width): self.name = name self.parent = parent self.idx = idx self.width = width self.editorCtrl = None self.propWrapper = propWrapper self.companion = companion self.obj = companion.control self.propWrapper.connect(self.obj, self.companion) self.rootCompanion = rootCompanion self.root = rootCompanion.control self.initFromComponent() self.style = []
|
|
self.ownerPropEdit = None self.expanded = false
|
def __init__(self, name, parent, companion, rootCompanion, propWrapper, idx, width): self.name = name self.parent = parent self.idx = idx self.width = width self.editorCtrl = None self.propWrapper = propWrapper self.companion = companion self.obj = companion.control self.propWrapper.connect(self.obj, self.companion) self.rootCompanion = rootCompanion self.root = rootCompanion.control self.initFromComponent() self.style = []
|
|
if self.obj: try: self.value = self.propWrapper.getValue() except Exception, message: self.value = '' if self.editorCtrl: self.editorCtrl.setValue(self.valueToIECValue()) else: self.value = ''
|
try: self.value = self.propWrapper.getValue() except Exception, message: print 'initFromComponent error', message self.value = '' if self.editorCtrl: self.editorCtrl.setValue(self.valueToIECValue())
|
def initFromComponent(self): if self.obj: try: self.value = self.propWrapper.getValue() except Exception, message: self.value = '' if self.editorCtrl: self.editorCtrl.setValue(self.valueToIECValue()) else: self.value = ''
|
if self.root and hasattr(self.root, 'Refresh'): pass
|
if self.obj and hasattr(self.obj, 'Refresh'): self.obj.Refresh()
|
def refreshCompCtrl(self): if self.root and hasattr(self.root, 'Refresh'): # XXX This used to be neccesary pass #self.root.Refresh()
|
if v != cv:
|
if `v` != `cv`:
|
def inspectorPost(self, closeEditor = true): if self.editorCtrl: v = self.getValue() cv = self.getCtrlValue() if v != cv: self.validateProp(v, cv) self.setCtrlValue(cv, v) self.persistValue(self.valueAsExpr()) else: pass if closeEditor: self.editorCtrl.destroyControl() self.editorCtrl = None self.refreshCompCtrl()
|
else: pass if closeEditor:
|
if self.ownerPropEdit: self.companion.updateOwnerFromObj() self.ownerPropEdit.initFromComponent() if esRecreateProp in self.ownerPropEdit.getStyle(): v = eval(self.ownerPropEdit.valueAsExpr()) self.ownerPropEdit.setCtrlValue(v, v) self.ownerPropEdit.persistValue(self.ownerPropEdit.valueAsExpr()) self.ownerPropEdit.refreshCompCtrl() if closeEditor and self.editorCtrl:
|
def inspectorPost(self, closeEditor = true): if self.editorCtrl: v = self.getValue() cv = self.getCtrlValue() if v != cv: self.validateProp(v, cv) self.setCtrlValue(cv, v) self.persistValue(self.valueAsExpr()) else: pass if closeEditor: self.editorCtrl.destroyControl() self.editorCtrl = None self.refreshCompCtrl()
|
self.refreshCompCtrl()
|
def inspectorPost(self, closeEditor = true): if self.editorCtrl: v = self.getValue() cv = self.getCtrlValue() if v != cv: self.validateProp(v, cv) self.setCtrlValue(cv, v) self.persistValue(self.valueAsExpr()) else: pass if closeEditor: self.editorCtrl.destroyControl() self.editorCtrl = None self.refreshCompCtrl()
|
|
'property editor: set value', value
|
def setValue(self, value): 'property editor: set value', value self.value = value if self.editorCtrl: self.editorCtrl.SetValue(self.value)
|
|
def setCtrlValue(self, oldValue, value): self.companion.checkTriggers(self.name, oldValue, value)
|
def setCtrlValue(self, oldValue, value): self.companion.checkTriggers(self.name, oldValue, value)
|
|
self.value = 'wxBitmap(%s, wxBITMAP_TYPE_BMP)'%(`dlg.GetPath()`) v = self.getValue() cv = self.getCtrlValue() self.setCtrlValue(cv, v) self.persistValue(self.value) self.propWrapper.setValue(eval(self.value), self.companion.index) self.refreshCompCtrl()
|
try: self.value = 'wxBitmap(%s, wxBITMAP_TYPE_BMP)'%(`dlg.GetPath()`) v = self.getValue() cv = self.getCtrlValue() self.setCtrlValue(cv, v) self.persistValue(self.value) self.propWrapper.setValue(eval(self.value), self.companion.index) self.refreshCompCtrl() except Exception, err: print 'Edit except', str(err)
|
def edit(self, event): dlg = wxFileDialog(self.parent, 'Choose an image', '.', '', 'Bitmaps (*.bmp)|*.bmp', wxOPEN) try: if dlg.ShowModal() == wxID_OK: self.value = 'wxBitmap(%s, wxBITMAP_TYPE_BMP)'%(`dlg.GetPath()`) v = self.getValue() cv = self.getCtrlValue() self.setCtrlValue(cv, v) self.persistValue(self.value) self.propWrapper.setValue(eval(self.value), self.companion.index) self.refreshCompCtrl() finally: dlg.Destroy() return ''
|
pass
|
def getStyle(self): return [esExpandable] def getSubCompanion(self): from Companions.Companions import WindowStyleDTC return WindowStyleDTC def getValue(self): """ For efficiency override the entire getValue""" if self.editorCtrl: try: anInt = eval(self.editorCtrl.getValue()) if type(anInt) is IntType: self.value = string.join(map(string.strip, string.split(self.editorCtrl.getValue(), '|')), ' | ') else: self.value = self.getCtrlValue() except Exception, message: self.value = self.getCtrlValue() print 'invalid constr prop value', message else: self.value = self.getCtrlValue() return self.value
|
## def getCtrlValue(self):
|
return [esDialog]
|
return [esExpandable] def getSubCompanion(self): from Companions.Companions import ColourDTC return ColourDTC
|
def getStyle(self): return [esDialog]
|
if dlg.ShowModal() == wxID_OK: self.value = dlg.GetColourData().GetColour() self.propWrapper.setValue(self.value) self.obj.Refresh() dlg.Destroy() def getValue(self): return self.value
|
try: if dlg.ShowModal() == wxID_OK: self.value = dlg.GetColourData().GetColour() print 'ColPropEdit.edit', self.value self.inspectorPost(false) finally: dlg.Destroy() def getValue(self): return self.value
|
def edit(self, event): data = wxColourData() data.SetColour(self.value) dlg = wxColourDialog(self.parent, data)
|
return ClassPropEdit.getStyle(self) + [esDialog, esReadOnly]
|
return ClassPropEdit.getStyle(self) + [esDialog, esReadOnly, esRecreateProp] def getSubCompanion(self): from Companions.Companions import FontDTC return FontDTC
|
def getStyle(self): return ClassPropEdit.getStyle(self) + [esDialog, esReadOnly]
|
if dlg.ShowModal() == wxID_OK: self.value = dlg.GetFontData().GetChosenFont() self.propWrapper.setValue(self.value) self.obj.Refresh() dlg.Destroy()
|
try: if dlg.ShowModal() == wxID_OK: self.value = dlg.GetFontData().GetChosenFont() self.inspectorPost(false) finally: dlg.Destroy()
|
def edit(self, event): data = wxFontData() dlg = wxFontDialog(self.parent, data) dlg.GetFontData().SetInitialFont(self.value) if dlg.ShowModal() == wxID_OK: self.value = dlg.GetFontData().GetChosenFont() self.propWrapper.setValue(self.value) self.obj.Refresh() dlg.Destroy()
|
return 'wxFont(%d, %d, %d, %d, %d, %s)'%(fnt.GetPointSize(), fnt.GetFamily(), fnt.GetStyle(), fnt.GetWeight(), fnt.GetUnderlined(), `fnt.GetFaceName()`)
|
return 'wxFont(%d, %s, %s, %s, %s, %s)'%(\ fnt.GetPointSize(), self.fontFamily[fnt.GetFamily()], self.fontStyle[fnt.GetStyle()], self.fontWeight[fnt.GetWeight()], fnt.GetUnderlined() and 'true' or 'false', `fnt.GetFaceName()`) class AnchorPropEdit(OptionedPropEdit): def getStyle(self): return [esExpandable] def getSubCompanion(self): from Companions.Companions import AnchorsDTC return AnchorsDTC def inspectorEdit(self): self.editorCtrl = ButtonIEC(self, self.value) self.editorCtrl.createControl(self.parent, self.idx, self.width, self.edit) def edit(self, event): if self.expanded: wxMessageBox('Anchors can not be reset while the property is expanded', 'Anchors') else: if self.companion.anchorSettings: message = 'Remove anchors?' else: message = 'Define default Anchors?' dlg = wxMessageDialog(self.parent, message, 'Anchors', wxYES_NO | wxICON_QUESTION) try: if dlg.ShowModal() == wxID_YES: if self.companion.anchorSettings: self.companion.removeAnchors() self.propWrapper.setValue(self.getValue()) else: self.companion.defaultAnchors() self.inspectorPost(false) finally: dlg.Destroy() def getValue(self): return self.companion.GetAnchors(self.companion) def getDisplayValue(self): if self.companion.anchorSettings: l, t, r, b = self.companion.anchorSettings set = [] if l: set.append('left') if t: set.append('top') if r: set.append('right') if b: set.append('bottom') return '('+string.join(set, ', ')+')' else: return 'None' def valueAsExpr(self): if self.companion.anchorSettings: l, t, r, b = self.companion.anchorSettings return 'LayoutAnchors(self.%s, %s, %s, %s, %s)'%(self.companion.name, l and 'true' or 'false', t and 'true' or 'false', r and 'true' or 'false', b and 'true' or 'false')
|
def valueAsExpr(self): fnt = self.value return 'wxFont(%d, %d, %d, %d, %d, %s)'%(fnt.GetPointSize(), fnt.GetFamily(), fnt.GetStyle(), fnt.GetWeight(), fnt.GetUnderlined(), `fnt.GetFaceName()`)
|
self.setCtrlValue(self.value, self.value) self.refreshCompCtrl()
|
self.inspectorPost(false)
|
def edit(self, event): dlg = wxFileDialog(self.parent, 'Choose an image', '.', '', 'Bitmaps (*.bmp)|*.bmp', wxOPEN) try: if dlg.ShowModal() == wxID_OK: self.bmpPath = dlg.GetPath() self.value = wxBitmap(self.bmpPath, wxBITMAP_TYPE_BMP) self.setCtrlValue(self.value, self.value)
|
print 'executing', cmd, args
|
def run(self, args = ''): """ Excecute the current saved image of the application. """ if self.savedAs: cwd = os.path.abspath(os.getcwd()) os.chdir(os.path.dirname(self.filename)) oldErr = sys.stderr oldSysPath = sys.path[:] try: sys.path.append(Preferences.pyPath) cmd = '"%s" %s %s'%(sys.executable, os.path.basename(self.filename), args) print 'executing', cmd, args
|
|
import ErrorStackFrm esf = ErrorStackFrm.ErrorStackMF(self.editor, self.app, self.editor) esf.updateCtrls(err) esf.Show(true) return esf
|
frm = self.editor.erroutFrm if frm: frm.updateCtrls(err) if not frm.IsShown(): frm.Show(true) return frm
|
def crashLog(self): err = ErrorStack.crashError(os.path.splitext(self.filename)[0]+'.trace') if err: import ErrorStackFrm esf = ErrorStackFrm.ErrorStackMF(self.editor, self.app, self.editor) esf.updateCtrls(err) esf.Show(true) return esf else: wx.wxLogError('Trace file not found. Run with command line param -T') return None
|
self.evtToSend = []
|
def __init__(self, parent, ID, label, pos = wxDefaultPosition, size = wxDefaultSize, style = 0, validator = wxDefaultValidator, name = "genbutton"): if style == 0: style = wxNO_BORDER wxControl.__init__(self, parent, ID, pos, size, style, validator, name)
|
|
EVT_IDLE(self, self.OnIdle)
|
def __init__(self, parent, ID, label, pos = wxDefaultPosition, size = wxDefaultSize, style = 0, validator = wxDefaultValidator, name = "genbutton"): if style == 0: style = wxNO_BORDER wxControl.__init__(self, parent, ID, pos, size, style, validator, name)
|
|
faceClr = wxSystemSettings_GetSystemColour(wxSYS_COLOUR_BTNFACE) textClr = wxSystemSettings_GetSystemColour(wxSYS_COLOUR_BTNTEXT)
|
if no_sys_col: faceClr = wxColour(192, 192, 192) textClr = wxColour(0, 0, 0) else: faceClr = wxSystemSettings_GetSystemColour(wxSYS_COLOUR_BTNFACE) textClr = wxSystemSettings_GetSystemColour(wxSYS_COLOUR_BTNTEXT)
|
def InitColours(self): faceClr = wxSystemSettings_GetSystemColour(wxSYS_COLOUR_BTNFACE) textClr = wxSystemSettings_GetSystemColour(wxSYS_COLOUR_BTNTEXT) self.faceDnClr = faceClr self.SetBackgroundColour(faceClr) self.SetForegroundColour(textClr)
|
shadowClr = wxSystemSettings_GetSystemColour(wxSYS_COLOUR_BTNSHADOW) highlightClr = wxSystemSettings_GetSystemColour(wxSYS_COLOUR_BTNHIGHLIGHT)
|
if no_sys_col: shadowClr = wxColour(128, 128, 128) highlightClr = wxColour(228, 228, 228) else: shadowClr = wxSystemSettings_GetSystemColour(wxSYS_COLOUR_BTNSHADOW) highlightClr = wxSystemSettings_GetSystemColour(wxSYS_COLOUR_BTNHIGHLIGHT)
|
def InitColours(self): faceClr = wxSystemSettings_GetSystemColour(wxSYS_COLOUR_BTNFACE) textClr = wxSystemSettings_GetSystemColour(wxSYS_COLOUR_BTNTEXT) self.faceDnClr = faceClr self.SetBackgroundColour(faceClr) self.SetForegroundColour(textClr)
|
self.evtToSend.append(evt) def OnIdle(self, evt): while self.evtToSend: evt = self.evtToSend[0] del self.evtToSend[0] self.GetEventHandler().ProcessEvent(evt)
|
self.GetEventHandler().ProcessEvent(evt)
|
def Notify(self): evt = wxGenButtonEvent(wxEVT_COMMAND_BUTTON_CLICKED, self.GetId()) evt.SetIsDown(not self.up) evt.SetButtonObj(self) self.evtToSend.append(evt)
|
if not curdir:
|
if not curdir or curdir == 'none:':
|
def openFileDlg(self, filter='*.py', curdir='.', curfile=''): if filter == '*.py': filter = Preferences.exDefaultFilter
|
for c in value: if c not in string.letters+string.digits+'_':
|
if not value[1:-1]: message = 'Invalid name for Python object' wxLogError(message) return self.value for c in value[1:-1]: if c not in string.letters+string.digits+'_':
|
def getValue(self): if self.editorCtrl: value = self.editorCtrl.getValue() if type(value) is StringType: value = `self.editorCtrl.getValue()` else: value = self.getCtrlValue()
|
if not value: message = 'Invalid name for Python object' wxLogError(message) return self.value
|
def getValue(self): # XXX Currently returning the old value in case of error because # XXX an exception here cannot be gracefully handled yet. # XXX Specifically closing the frame with the focus on the if self.editorCtrl: value = self.editorCtrl.getValue() if value != self.value: if self.companion.designer.objects.has_key(value): wxLogError('Name already used by another control.') return self.value
|
|
if not frame.f_locals.get('__traced'): frame.f_locals['__traced'] = 1
|
if frame.f_lineno == frame.f_code.co_firstlineno:
|
def isTraceable(self, frame): """Indicates whether the debugger should step into the given frame.
|
newNode = self.createChildNode(self.resourcepath+fn, 0, self.properties)
|
newNode = self.createChildNode(self.resourcepath+fn, self.properties)
|
def copyFromFS(self, fsNode, fn=''): if fsNode.isFolderish(): if not fn: fn = os.path.basename(fsNode.resourcepath[:-1]) self.newFolder(fn) else: if not fn: fn = os.path.basename(fsNode.resourcepath) newNode = self.createChildNode(self.resourcepath+fn, 0, self.properties) self.checkResp(newNode.resource.put(fsNode.load()))
|
if Preferences.useDebugger == 'new': filename = self.model.filename self.breaks = bplist.getFileBreakpoints(filename)
|
def __init__(self, parent, model): a1 = (('-', None, '', ()), ('Comment', self.OnComment, '-', keyDefs['Comment']), ('Uncomment', self.OnUnComment, '-', keyDefs['Uncomment']), ('Indent', self.OnIndent, '-', keyDefs['Indent']), ('Dedent', self.OnDedent, '-', keyDefs['Dedent']), ('-', None, '-', ()), ('Run to cursor', self.OnRunToCursor, self.runCrsBmp, ()), ('Toggle breakpoint', self.OnSetBreakPoint, self.breakBmp, keyDefs['ToggleBrk']), ('Load breakpoints', self.OnLoadBreakPoints, '-', ()), ('Save breakpoints', self.OnSaveBreakPoints, '-', ()), ('-', None, '', ()), ('+View whitespace', self.OnViewWhitespace, '-', ()), ('+View EOL characters', self.OnViewEOL, '-', ()), ('-', None, '-', ()), ('Add module info', self.OnAddModuleInfo, self.modInfoBmp, ()), ('Add comment line', self.OnAddCommentLine, '-', keyDefs['DashLine']), ('Add simple app', self.OnAddSimpleApp, '-', ()), ('Code transformation', self.OnAddClassAtCursor, '-', keyDefs['CodeXform']), ('Code completion', self.OnCompleteCode, '-', keyDefs['CodeComplete']), ('Call tips', self.OnParamTips, '-', keyDefs['CallTips']), ('-', None, '-', ()), ('Context help', self.OnContextHelp, '-', keyDefs['ContextHelp']))
|
|
filename = string.lower(self.model.filename) for file, lineno in bdb.Breakpoint.bplist.keys(): if file == filename: for bp in bdb.Breakpoint.bplist[(file, lineno)]: self.breaks[lineno] = bp
|
if Preferences.useDebugger == 'old': filename = string.lower(self.model.filename) for file, lineno in bdb.Breakpoint.bplist.keys(): if file == filename: for bp in bdb.Breakpoint.bplist[(file, lineno)]: self.breaks[lineno] = bp
|
def __init__(self, parent, model): a1 = (('-', None, '', ()), ('Comment', self.OnComment, '-', keyDefs['Comment']), ('Uncomment', self.OnUnComment, '-', keyDefs['Uncomment']), ('Indent', self.OnIndent, '-', keyDefs['Indent']), ('Dedent', self.OnDedent, '-', keyDefs['Dedent']), ('-', None, '-', ()), ('Run to cursor', self.OnRunToCursor, self.runCrsBmp, ()), ('Toggle breakpoint', self.OnSetBreakPoint, self.breakBmp, keyDefs['ToggleBrk']), ('Load breakpoints', self.OnLoadBreakPoints, '-', ()), ('Save breakpoints', self.OnSaveBreakPoints, '-', ()), ('-', None, '', ()), ('+View whitespace', self.OnViewWhitespace, '-', ()), ('+View EOL characters', self.OnViewEOL, '-', ()), ('-', None, '-', ()), ('Add module info', self.OnAddModuleInfo, self.modInfoBmp, ()), ('Add comment line', self.OnAddCommentLine, '-', keyDefs['DashLine']), ('Add simple app', self.OnAddSimpleApp, '-', ()), ('Code transformation', self.OnAddClassAtCursor, '-', keyDefs['CodeXform']), ('Code completion', self.OnCompleteCode, '-', keyDefs['CodeComplete']), ('Call tips', self.OnParamTips, '-', keyDefs['CallTips']), ('-', None, '-', ()), ('Context help', self.OnContextHelp, '-', keyDefs['ContextHelp']))
|
if new_stc: self.AutoCompSetIgnoreCase(true)
|
self.AutoCompSetIgnoreCase(true)
|
def __init__(self, parent, model): a1 = (('-', None, '', ()), ('Comment', self.OnComment, '-', keyDefs['Comment']), ('Uncomment', self.OnUnComment, '-', keyDefs['Uncomment']), ('Indent', self.OnIndent, '-', keyDefs['Indent']), ('Dedent', self.OnDedent, '-', keyDefs['Dedent']), ('-', None, '-', ()), ('Run to cursor', self.OnRunToCursor, self.runCrsBmp, ()), ('Toggle breakpoint', self.OnSetBreakPoint, self.breakBmp, keyDefs['ToggleBrk']), ('Load breakpoints', self.OnLoadBreakPoints, '-', ()), ('Save breakpoints', self.OnSaveBreakPoints, '-', ()), ('-', None, '', ()), ('+View whitespace', self.OnViewWhitespace, '-', ()), ('+View EOL characters', self.OnViewEOL, '-', ()), ('-', None, '-', ()), ('Add module info', self.OnAddModuleInfo, self.modInfoBmp, ()), ('Add comment line', self.OnAddCommentLine, '-', keyDefs['DashLine']), ('Add simple app', self.OnAddSimpleApp, '-', ()), ('Code transformation', self.OnAddClassAtCursor, '-', keyDefs['CodeXform']), ('Code completion', self.OnCompleteCode, '-', keyDefs['CodeComplete']), ('Call tips', self.OnParamTips, '-', keyDefs['CallTips']), ('-', None, '-', ()), ('Context help', self.OnContextHelp, '-', keyDefs['ContextHelp']))
|
if wx.__dict__[name].__init__.__doc__: return wx.__dict__[name].__init__.__doc__
|
return wx.__dict__[name].__init__.__doc__ or ''
|
def checkWxPyTips(self, module, name): if module.imports.has_key('wxPython.wx'): if wx.__dict__.has_key(name): t = type(wx.__dict__[name]) if t is types.ClassType: if wx.__dict__[name].__init__.__doc__: return wx.__dict__[name].__init__.__doc__ return ''
|
if meth.__doc__: return meth.__doc__
|
return meth.__doc__ or ''
|
def checkWxPyMethodTips(self, module, cls, name): if module.imports.has_key('wxPython.wx'): if wx.__dict__.has_key(cls): Cls = wx.__dict__[cls] if hasattr(Cls, name): meth = getattr(Cls, name) if meth.__doc__: return meth.__doc__ return ''
|
return getattr(klass, meth).__doc__
|
return getattr(klass, meth).__doc__ or ''
|
def getAttribSig(self, module, cls, attrib, meth): if cls.attributes.has_key(attrib): objtype = cls.attributes[attrib][0].signature if module.classes.has_key(objtype) and \ module.classes[objtype].methods.has_key(meth): return module.classes[objtype].methods[meth].signature klass = wxNamespace.getWxClass(objtype) if klass: if hasattr(klass, meth): return getattr(klass, meth).__doc__ return ''
|
meth = cls.getMethodForLineNo(lnNo)
|
methName, meth = cls.getMethodForLineNo(lnNo)
|
def getCodeCompOptions(self, word, rootWord, matchWord, lnNo): """ Overwritten Mixin method, returns list of code completion names """ module = self.model.getModule() cls = module.getClassForLineNo(lnNo) if cls: objPth = string.split(rootWord, '.')
|
meth = cls.getMethodForLineNo(lineNo)
|
methName, meth = cls.getMethodForLineNo(lineNo)
|
def BrowseClick(self, word, line, lineNo, start, style): """ Overridden from BrowseStyledTextCtrlMix, jumps to declaration or opens module
|
if self.model.editor.debugger and self.model.editor.debugger.isDebugBrowsing(): word, line, lnNo, wordStart = self.getStyledWordElems(start, length) self.IndicatorSetColour(0, wxRED) try: val = self.model.editor.debugger.getVarValue(word) except Exception, message: val = str(message) if val: self.model.editor.statusBar.setHint(val) else: self.IndicatorSetColour(0, wxBLUE) return start, length
|
debugger = self.model.editor.debugger if Preferences.useDebugger == 'new': start, length = BrowseStyledTextCtrlMix.underlineWord( self, start, length) debugger = self.model.editor.debugger if debugger: word, line, lnNo, wordStart = self.getStyledWordElems( start, length) self.IndicatorSetForeground(0, wxRED) debugger.requestVarValue(word) else: self.IndicatorSetForeground(0, wxBLUE) return start, length elif Preferences.useDebugger == 'old': if debugger and debugger.isDebugBrowsing(): word, line, lnNo, wordStart = self.getStyledWordElems(start, length) self.IndicatorSetForeground(0, wxRED) try: val = debugger.getVarValue(word) except Exception, message: val = str(message) if val: self.model.editor.statusBar.setHint(val) else: self.IndicatorSetForeground(0, wxBLUE) return start, length
|
def underlineWord(self, start, length): start, length = BrowseStyledTextCtrlMix.underlineWord(self, start, length) if self.model.editor.debugger and self.model.editor.debugger.isDebugBrowsing(): word, line, lnNo, wordStart = self.getStyledWordElems(start, length) self.IndicatorSetColour(0, wxRED) try: val = self.model.editor.debugger.getVarValue(word) except Exception, message: val = str(message) if val: self.model.editor.statusBar.setHint(val) else: self.IndicatorSetColour(0, wxBLUE)
|
if self.model.editor.debugger and self.model.editor.debugger.isDebugBrowsing():
|
debugger = self.model.editor.debugger if debugger and debugger.isDebugBrowsing():
|
def getBrowsableText(self, line, piv, lnStPs): if self.model.editor.debugger and self.model.editor.debugger.isDebugBrowsing(): return idWord(line, piv, lnStPs, object_delim) else: return BrowseStyledTextCtrlMix.getBrowsableText(self, line, piv, lnStPs)
|
for bp in self.breaks.values(): self.MarkerAdd(bp.line -1, brkPtMrk) def setBdbBreakpoints(self): for bp in self.breaks.values(): self.MarkerAdd(bp.line -1, brkPtMrk)
|
if Preferences.useDebugger == 'new': for brk in self.breaks.listBreakpoints(): if brk['temporary']: mrk = tmpBrkPtMrk else: mrk = brkPtMrk self.MarkerAdd(brk['lineno'] - 1, mrk) elif Preferences.useDebugger == 'old': for bp in self.breaks.values(): self.MarkerAdd(bp.line -1, brkPtMrk)
|
def setInitialBreakpoints(self): for bp in self.breaks.values(): self.MarkerAdd(bp.line -1, brkPtMrk)
|
if not self.breaks.has_key(lineNo): return bp = self.breaks[lineNo] if bp.temporary:
|
if Preferences.useDebugger == 'new': self.breaks.deleteBreakpoints(lineNo) debugger = self.model.editor.debugger if debugger: filename = self.model.filename debugger.deleteBreakpoints(filename, lineNo) self.MarkerDelete(lineNo - 1, brkPtMrk)
|
def deleteBreakPoint(self, lineNo): if not self.breaks.has_key(lineNo): return
|
else: self.MarkerDelete(lineNo - 1, brkPtMrk) if self.model.editor.debugger:
|
elif Preferences.useDebugger == 'old': if not self.breaks.has_key(lineNo): return
|
def deleteBreakPoint(self, lineNo): if not self.breaks.has_key(lineNo): return
|
res = self.model.editor.debugger.clear_break(bp.file, bp.line) if res: print res self.model.editor.debugger.breakpts.refreshList() else: self.breaks[lineNo].deleteMe() del self.breaks[lineNo] def addBreakPoint(self, lineNo, temp = 0): if wxPlatform == '__WXMSW__': filename = string.lower(self.model.filename) else: filename = self.model.filename if self.model.editor.debugger: bp = self.model.editor.debugger.set_breakpoint_here(\ filename, lineNo, temp) else: bp = bdb.Breakpoint(filename, lineNo, temp) if type(bp) == type(''): wxLogError(bp) else: self.breaks[lineNo] = bp if temp: mrk = tmpBrkPtMrk else: mrk = brkPtMrk hnd = self.MarkerAdd(lineNo - 1, mrk)
|
if bp.temporary: self.MarkerDelete(lineNo - 1, tmpBrkPtMrk) else: self.MarkerDelete(lineNo - 1, brkPtMrk) if self.model.editor.debugger: bp = self.breaks[lineNo] res = self.model.editor.debugger.clear_break(bp.file, bp.line) if res: print res self.model.editor.debugger.breakpts.refreshList() else: self.breaks[lineNo].deleteMe() del self.breaks[lineNo] def addBreakPoint(self, lineNo, temp=0, notify_debugger=1): if Preferences.useDebugger == 'new': self.breaks.addBreakpoint(lineNo, temp) if notify_debugger: debugger = self.model.editor.debugger if debugger: filename = self.model.filename debugger.setBreakpoint(filename, lineNo, temp) if temp: mrk = tmpBrkPtMrk else: mrk = brkPtMrk self.MarkerAdd(lineNo - 1, mrk) elif Preferences.useDebugger == 'old': if wxPlatform == '__WXMSW__': filename = string.lower(self.model.filename) else: filename = self.model.filename if self.model.editor.debugger: bp = self.model.editor.debugger.set_breakpoint_here(\ filename, lineNo, temp) else: bp = bdb.Breakpoint(filename, lineNo, temp) if type(bp) == type(''): wxLogError(bp) else: self.breaks[lineNo] = bp if temp: mrk = tmpBrkPtMrk else: mrk = brkPtMrk hnd = self.MarkerAdd(lineNo - 1, mrk)
|
def deleteBreakPoint(self, lineNo): if not self.breaks.has_key(lineNo): return
|
update = false if os.path.exists(fn): self.breaks = pickle.load(open(fn)) self.setInitialBreakpoints() BrkPt = bdb.Breakpoint for lineNo, brk in self.breaks.items(): if self.model.editor.debugger: self.model.editor.debugger.set_break(brk.file, lineNo) update = true else: BrkPt.bpbynumber.append(brk) if BrkPt.bplist.has_key((brk.file, brk.line)): BrkPt.bplist[brk.file, brk.line].append(brk)
|
if Preferences.useDebugger == 'new': rval = self.breaks.loadBreakpoints(fn) if rval: self.setInitialBreakpoints() return rval elif Preferences.useDebugger == 'old': update = false if os.path.exists(fn): self.breaks = pickle.load(open(fn)) self.setInitialBreakpoints() BrkPt = bdb.Breakpoint for lineNo, brk in self.breaks.items(): if self.model.editor.debugger: self.model.editor.debugger.set_break(brk.file, lineNo) update = true
|
def tryLoadBreakpoints(self): import pickle fn = self.getBreakpointFilename() update = false if os.path.exists(fn): self.breaks = pickle.load(open(fn)) self.setInitialBreakpoints() BrkPt = bdb.Breakpoint for lineNo, brk in self.breaks.items(): if self.model.editor.debugger: self.model.editor.debugger.set_break(brk.file, lineNo) update = true else: BrkPt.bpbynumber.append(brk) if BrkPt.bplist.has_key((brk.file, brk.line)): BrkPt.bplist[brk.file, brk.line].append(brk) else: BrkPt.bplist[brk.file, brk.line] = [brk] if update: self.model.editor.debugger.breakpts.refreshList()
|
BrkPt.bplist[brk.file, brk.line] = [brk] if update: self.model.editor.debugger.breakpts.refreshList() return true else: self.breaks = {} return false
|
BrkPt.bpbynumber.append(brk) if BrkPt.bplist.has_key((brk.file, brk.line)): BrkPt.bplist[brk.file, brk.line].append(brk) else: BrkPt.bplist[brk.file, brk.line] = [brk] if update: self.model.editor.debugger.breakpts.refreshList() return true else: self.breaks = {} return false
|
def tryLoadBreakpoints(self): import pickle fn = self.getBreakpointFilename() update = false if os.path.exists(fn): self.breaks = pickle.load(open(fn)) self.setInitialBreakpoints() BrkPt = bdb.Breakpoint for lineNo, brk in self.breaks.items(): if self.model.editor.debugger: self.model.editor.debugger.set_break(brk.file, lineNo) update = true else: BrkPt.bpbynumber.append(brk) if BrkPt.bplist.has_key((brk.file, brk.line)): BrkPt.bplist[brk.file, brk.line].append(brk) else: BrkPt.bplist[brk.file, brk.line] = [brk] if update: self.model.editor.debugger.breakpts.refreshList()
|
import pickle
|
def saveBreakpoints(self): # XXX This is not yet called automatically on saving a module, should it be ? import pickle fn = self.getBreakpointFilename() if len(self.breaks): pickle.dump(self.breaks, open(fn, 'w')) elif os.path.exists(fn): os.remove(fn)
|
|
if len(self.breaks): pickle.dump(self.breaks, open(fn, 'w')) elif os.path.exists(fn): os.remove(fn)
|
if Preferences.useDebugger == 'new': self.breaks.saveBreakpoints(fn) elif Preferences.useDebugger == 'old': if len(self.breaks): pickle.dump(self.breaks, open(fn, 'w')) elif os.path.exists(fn): os.remove(fn) def clearStepPos(self, lineNo): if lineNo < 0: lineNo = 0 self.MarkerDelete(lineNo, stepPosMrk)
|
def saveBreakpoints(self): # XXX This is not yet called automatically on saving a module, should it be ? import pickle fn = self.getBreakpointFilename() if len(self.breaks): pickle.dump(self.breaks, open(fn, 'w')) elif os.path.exists(fn): os.remove(fn)
|
if self.stepPos != lineNo: if self.stepPos: self.MarkerDelete(self.stepPos, stepPosMrk) if lineNo: self.MarkerAdd(lineNo, stepPosMrk) self.stepPos = lineNo
|
if Preferences.useDebugger == 'new': if lineNo < 0: lineNo = 0 self.MarkerAdd(lineNo, stepPosMrk) self.MarkerDelete(lineNo, tmpBrkPtMrk) elif Preferences.useDebugger == 'old': if self.stepPos != lineNo: if self.stepPos: self.MarkerDelete(self.stepPos, stepPosMrk) if lineNo: self.MarkerAdd(lineNo, stepPosMrk) self.stepPos = lineNo
|
def setStepPos(self, lineNo): if self.stepPos != lineNo: if self.stepPos: self.MarkerDelete(self.stepPos, stepPosMrk) if lineNo: self.MarkerAdd(lineNo, stepPosMrk) self.stepPos = lineNo
|
lineClicked = self.GetLineFromPos(event.GetPosition()) + 1 if self.breaks.has_key(lineClicked): self.deleteBreakPoint(lineClicked) else: self.addBreakPoint(lineClicked)
|
lineClicked = self.LineFromPosition(event.GetPosition()) + 1 if Preferences.useDebugger == 'old': if self.breaks.has_key(lineClicked): self.deleteBreakPoint(lineClicked) else: self.addBreakPoint(lineClicked) elif Preferences.useDebugger == 'new': if self.breaks.hasBreakpoint(lineClicked): self.deleteBreakPoint(lineClicked) else: self.addBreakPoint(lineClicked)
|
def OnMarginClick(self, event): if event.GetMargin() == 1: lineClicked = self.GetLineFromPos(event.GetPosition()) + 1 if self.breaks.has_key(lineClicked): self.deleteBreakPoint(lineClicked) else: self.addBreakPoint(lineClicked) else: FoldingStyledTextCtrlMix.OnMarginClick(self, event)
|
line = self.GetLineFromPos(self.GetCurrentPos()) + 1 if self.breaks.has_key(line): self.deleteBreakPoint(line) else: self.addBreakPoint(line)
|
line = self.LineFromPosition(self.GetCurrentPos()) + 1 if Preferences.useDebugger == 'old': if self.breaks.has_key(line): self.deleteBreakPoint(line) else: self.addBreakPoint(line) elif Preferences.useDebugger == 'new': if self.breaks.hasBreakpoint(line): self.deleteBreakPoint(line) else: self.addBreakPoint(line)
|
def OnSetBreakPoint(self, event): line = self.GetLineFromPos(self.GetCurrentPos()) + 1 if self.breaks.has_key(line): self.deleteBreakPoint(line) else: self.addBreakPoint(line)
|
line = self.GetLineFromPos(self.GetCurrentPos()) + 1 if not self.breaks.has_key(line): self.addBreakPoint(line, 1) if self.model.defaultName == 'App': self.model.editor.debugger.debug_file(self.model.filename) elif self.model.app: self.model.editor.debugger.debug_file(self.model.app.filename)
|
if Preferences.useDebugger == 'new': line = self.LineFromPosition(self.GetCurrentPos()) + 1 self.addBreakPoint(line, temp=1, notify_debugger=0) temp_breakpoint = (path.normcase(path.abspath( self.model.filename)), line) self.model.debug(cont_if_running=1, cont_always=1, temp_breakpoint=temp_breakpoint) elif Preferences.useDebugger == 'old': line = self.LineFromPosition(self.GetCurrentPos()) + 1 if not self.breaks.has_key(line): self.addBreakPoint(line, 1) if self.model.defaultName == 'App': self.model.editor.debugger.debug_file(self.model.filename) elif self.model.app: self.model.editor.debugger.debug_file(self.model.app.filename)
|
def OnRunToCursor(self, event): line = self.GetLineFromPos(self.GetCurrentPos()) + 1 if not self.breaks.has_key(line): self.addBreakPoint(line, 1) if self.model.defaultName == 'App': self.model.editor.debugger.debug_file(self.model.filename) elif self.model.app: self.model.editor.debugger.debug_file(self.model.app.filename)
|
lnStPs = self.GetLineStartPos(lnNo) line = self.GetCurrentLineText()[0]
|
lnStPs = self.PositionFromLine(lnNo) line = self.GetCurLine()[0]
|
def OnContextHelp(self, event): pos = self.GetCurrentPos() lnNo = self.GetCurrentLine() lnStPs = self.GetLineStartPos(lnNo) line = self.GetCurrentLineText()[0] piv = pos - lnStPs start, length = idWord(line, piv, lnStPs) startLine = start-lnStPs word = line[startLine:startLine+length] Help.showContextHelp(self.model.editor, self.model.editor.palette.toolBar, word)
|
line = self.GetCurrentLineText()
|
line = self.GetCurLine()
|
def OnKeyDown(self, event): if self.CallTipActive(): self.callTipCheck()
|
self.damagedLine = self.GetLineFromPos(pos)
|
self.damagedLine = self.LineFromPosition(pos)
|
def OnKeyDown(self, event): if self.CallTipActive(): self.callTipCheck()
|
if self.GetLineStartPos(self.GetLineFromPos(pos)) != pos:
|
if self.PositionFromLine(self.LineFromPosition(pos)) != pos:
|
def OnKeyDown(self, event): if self.CallTipActive(): self.callTipCheck()
|
ln = self.GetLineFromPos(pos) ls = self.GetLineStartPos(ln)
|
ln = self.LineFromPosition(pos) ls = self.PositionFromLine(ln)
|
def OnKeyDown(self, event): if self.CallTipActive(): self.callTipCheck()
|
ln = self.GetLineFromPos(pos) ls = self.GetLineStartPos(ln)
|
ln = self.LineFromPosition(pos) ls = self.PositionFromLine(ln)
|
def OnAddCommentLine(self, event): pos = self.GetCurrentPos() ln = self.GetLineFromPos(pos) ls = self.GetLineStartPos(ln) self.InsertText(ls, '#-------------------------------------------' '------------------------------------'+'\n') self.SetCurrentPosition(ls+4)
|
self.SetCurrentPosition(ls+4)
|
self.SetCurrentPos(ls+4)
|
def OnAddCommentLine(self, event): pos = self.GetCurrentPos() ln = self.GetLineFromPos(pos) ls = self.GetLineStartPos(ln) self.InsertText(ls, '#-------------------------------------------' '------------------------------------'+'\n') self.SetCurrentPosition(ls+4)
|
lnStPs = self.GetLineStartPos(lnNo) line = self.GetLine(lnNo)
|
lnStPs = self.PositionFromLine(lnNo) line = self.GetLine(lnNo)
|
def OnAddClassAtCursor(self, event): pos = self.GetCurrentPos() lnNo = self.GetCurrentLine() lnStPs = self.GetLineStartPos(lnNo) line = self.GetLine(lnNo)#self.GetCurrentLineText()[0] piv = pos - lnStPs start, length = idWord(line, piv, lnStPs, object_delim) startLine = start-lnStPs word = line[startLine:startLine+length] # 1st Xform; Add method at cursor to the class if Utils.startswith(word, 'self.'): methName = word[5:] # Apply if there are changes to views self.model.refreshFromViews() module = self.model.getModule() cls = module.getClassForLineNo(lnNo) if not cls.methods.has_key(methName): # Check if it looks like an event if len(methName) > 2 and methName[:2] == 'On' and (methName[2] in string.uppercase+'_'): parms = 'self, event' else: parms = 'self, '
|
meth = cls.getMethodForLineNo(lnNo+1)
|
methName, meth = cls.getMethodForLineNo(lnNo+1)
|
def OnAddClassAtCursor(self, event): pos = self.GetCurrentPos() lnNo = self.GetCurrentLine() lnStPs = self.GetLineStartPos(lnNo) line = self.GetLine(lnNo)#self.GetCurrentLineText()[0] piv = pos - lnStPs start, length = idWord(line, piv, lnStPs, object_delim) startLine = start-lnStPs word = line[startLine:startLine+length] # 1st Xform; Add method at cursor to the class if Utils.startswith(word, 'self.'): methName = word[5:] # Apply if there are changes to views self.model.refreshFromViews() module = self.model.getModule() cls = module.getClassForLineNo(lnNo) if not cls.methods.has_key(methName): # Check if it looks like an event if len(methName) > 2 and methName[:2] == 'On' and (methName[2] in string.uppercase+'_'): parms = 'self, event' else: parms = 'self, '
|
if linesAdded > 0: lines = string.split(textAdded, '\r\n') totAdded = linesAdded if len(lines) > 1 and len(lines) == linesAdded + 1: wxPostEvent(self, wxFixPasteEvent(self, string.join(lines, '\n'))) if self._blockUpdate: return
|
def OnModified(self, event): modType = event.GetModificationType() if modType == (wxSTC_MOD_CHANGEMARKER): pass linesAdded = event.GetLinesAdded()
|
|
update = false if linesAdded: line = self.LineFromPosition(event.GetPosition()) if Preferences.useDebugger == 'old': for breakLine, breakPt in self.breaks.items()[:]: if breakLine >= line: self.moveBreakpoint(breakPt, linesAdded) update = true elif Preferences.useDebugger == 'new': self.breaks.moveBreakpoint(line, line + linesAdded) if update and self.model.editor.debugger: self.model.editor.debugger.breakpts.refreshList()
|
def OnModified(self, event): modType = event.GetModificationType() if modType == (wxSTC_MOD_CHANGEMARKER): pass linesAdded = event.GetLinesAdded()
|
|
if linesAdded and self.model._module: lineNo = self.LineFromPosition(event.GetPosition()) module = self.model.getModule() module.renumber(linesAdded, lineNo)
|
def OnModified(self, event): modType = event.GetModificationType() if modType == (wxSTC_MOD_CHANGEMARKER): pass linesAdded = event.GetLinesAdded()
|
|
'Cancel Designer session?', 'Cancel', wxYES_NO | wxICON_WARNING) == wxID_YES: return
|
'Cancel Designer session?', 'Cancel', wxYES_NO | wxICON_WARNING, parent=self) == wxNO: self.saveOnClose = true self.confirmCancel = false return
|
def OnCloseWindow(self, event): """ When the Designer closes, the code generation process is started. General Inspector and Designer clean-up """ if not self.saveOnClose and self.confirmCancel and wxMessageBox( 'Cancel Designer session?', 'Cancel', wxYES_NO | wxICON_WARNING) == wxID_YES: return if self.IsIconized(): self.Iconize(false) self.destroying = true self.vetoResize = true try: if self.selection: self.selection.destroy() self.selection = None if self.multiSelection: for sel in self.multiSelection: sel.destroy() self.multiSelection = None self.inspector.cleanup() self.inspector.containment.cleanup() # generate source self.refreshModel() except: self.destroying = false self.vetoResize = false raise self.menu.Destroy() self.cleanup() self.Show(false) self.Destroy()
|
return self.isDir() or filter(lambda se, rp=self.resourcepath: se[1](rp), self.subExplorerReg['file'])
|
return self.isDir() or filter(lambda se, rp=self.resourcepath, ap=self.allowedProtocols : (ap == ['*'] or se[0].protocol in ap) and se[1](rp), self.subExplorerReg['file'])
|
def isFolderish(self): return self.isDir() or filter(lambda se, rp=self.resourcepath: se[1](rp), self.subExplorerReg['file'])
|
return
|
newNameBase = os.path.join(self.resourcepath, 'copy%s_of_'+node.name) num = '' while 1: newName = newNameBase%num if os.path.exists(newName): try: num = str(int(num) + 1) except: num = '2' else: shutil.copy(node.resourcepath, newName) break else: shutil.copy(node.resourcepath, self.resourcepath)
|
def copyFileFrom(self, node): """ Copy node into self (only called for folders)""" import shutil if not node.isDir(): if node.resourcepath == os.path.join(self.resourcepath, node.name): return
|
return open(self.resourcepath).read()
|
return open(self.resourcepath, 'rb').read()
|
def load(self): return open(self.resourcepath).read()
|
f = open(self.resourcepath, 'w')
|
f = open(self.resourcepath, 'wb')
|
def save(self, filename, data): # XXX move dialog to gui layer if self.resourcepath != filename: self.resourcepath = filename self.name = os.path.basename(self.resourcepath) try: f = open(self.resourcepath, 'w') except IOError, message: dlg = wx.wxMessageDialog(self.editor, 'Could not save\n'+message.strerror, 'Error', wx.wxOK | wx.wxICON_ERROR) try: dlg.ShowModal() finally: dlg.Destroy() else: f.write(data) f.close()
|
import urllib url = 'http://%s:%d/%s/source.html'%(self.model.zopeObj.properties['host'], self.model.zopeObj.properties['httpport'],
|
props = self.model.zopeObj.properties url = 'http://%s:%d/%s/source.html'%(props['host'], props['httpport'],
|
def generatePage(self): import urllib url = 'http://%s:%d/%s/source.html'%(self.model.zopeObj.properties['host'], self.model.zopeObj.properties['httpport'], self.model.zopeObj.whole_name()) f = urllib.urlopen(url) return f.read()
|
f = urllib.urlopen(url) return f.read()
|
urllib._urlopener = gfurlo = GUIFancyURLopener() gfurlo._user_prompt = props['name'] gfurlo._passwd_prompt = props['passwd'] try: f = urllib.urlopen(url) return f.read() finally: urllib._urlopener = None
|
def generatePage(self): import urllib url = 'http://%s:%d/%s/source.html'%(self.model.zopeObj.properties['host'], self.model.zopeObj.properties['httpport'], self.model.zopeObj.whole_name()) f = urllib.urlopen(url) return f.read()
|
from Models import HTMLSupport
|
def generatePage(self): import urllib url = 'http://%s:%d/%s/source.html'%(self.model.zopeObj.properties['host'], self.model.zopeObj.properties['httpport'], self.model.zopeObj.whole_name()) f = urllib.urlopen(url) return f.read()
|
|
defaultViews = (HTMLSupport.HTMLSourceView,)
|
defaultViews = (ZopeViews.ZopeDebugHTMLSourceView,)
|
def generatePage(self): import urllib url = 'http://%s:%d/%s/source.html'%(self.model.zopeObj.properties['host'], self.model.zopeObj.properties['httpport'], self.model.zopeObj.whole_name()) f = urllib.urlopen(url) return f.read()
|
raise 'Unauthorized', ( 'Authentication header missing or incorrect')
|
raise Exception, 'Unauthorized: Authentication header missing or incorrect'
|
def _authenticate(self): h = self.headers if auth_str: s = h.get('authentication') if not s or s.split()[-1] != auth_str: raise 'Unauthorized', ( 'Authentication header missing or incorrect')
|
confFile = '%s/%s%s.cfg' % (Preferences.rcPath, name,
|
confFile = os.path.join(Preferences.rcPath, '%s%s.cfg' % (name,
|
def createAndReadConfig(name, forPlatform = 1): """ Return an initialised ConfigFile object """ confFile = '%s/%s%s.cfg' % (Preferences.rcPath, name, forPlatform and wx.wxPlatform == '__WXMSW__' and '.msw' \ or forPlatform and '.gtk' or '') if not _sharedConfs.has_key(confFile): conf = ConfigParser() conf.read(confFile) conf.confFile = confFile _sharedConfs[confFile] = conf return _sharedConfs[confFile]
|
or forPlatform and '.gtk' or '')
|
or forPlatform and '.gtk' or ''))
|
def createAndReadConfig(name, forPlatform = 1): """ Return an initialised ConfigFile object """ confFile = '%s/%s%s.cfg' % (Preferences.rcPath, name, forPlatform and wx.wxPlatform == '__WXMSW__' and '.msw' \ or forPlatform and '.gtk' or '') if not _sharedConfs.has_key(confFile): conf = ConfigParser() conf.read(confFile) conf.confFile = confFile _sharedConfs[confFile] = conf return _sharedConfs[confFile]
|
for i in range(ctrl.GetItemCount()): ctrl.SetItemState(i, 0, SEL_FOC)
|
if not (ctrl.GetWindowStyleFlag() & wxLC_SINGLE_SEL): for i in range(ctrl.GetItemCount()): ctrl.SetItemState(i, 0, SEL_FOC)
|
def selectBeforePopup(event): """Ensures the item the mouse is pointing at is selected before a popup. Works with both single-select and multi-select lists.""" ctrl = event.GetEventObject() if isinstance(ctrl, wxListCtrl): n, flags = ctrl.HitTest(event.GetPosition()) if n >= 0: if not ctrl.GetItemState(n, wxLIST_STATE_SELECTED): for i in range(ctrl.GetItemCount()): ctrl.SetItemState(i, 0, SEL_FOC) #for i in getListCtrlSelection(ctrl, SEL_FOC): # ctrl.SetItemState(i, 0, SEL_FOC) ctrl.SetItemState(n, SEL_FOC, SEL_FOC)
|
if ext == '.jpg': return wx.wxImage(filename, wx.wxBITMAP_TYPE_JPG).ConvertToBitmap()
|
elif ext == '.jpg': return wx.wxImage(filename, wx.wxBITMAP_TYPE_JPEG).ConvertToBitmap() elif ext == '.gif': return wx.wxImage(filename, wx.wxBITMAP_TYPE_GIF).ConvertToBitmap()
|
def createImage(self, filename, ext): if ext == '.bmp':
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.