from Carbon import Evt, Events, Fm, Fonts from Carbon import Qd, Res, Scrap from Carbon import TE, TextEdit, Win from Carbon import App from Carbon.Appearance import kThemeStateActive, kThemeStateInactive import waste import WASTEconst import Wbase import Wkeys import Wcontrols import PyFontify import string from types import TupleType, StringType class TextBox(Wbase.Widget): """A static text widget""" def __init__(self, possize, text="", align=TextEdit.teJustLeft, fontsettings=None, backgroundcolor=(0xffff, 0xffff, 0xffff) ): if fontsettings is None: import W fontsettings = W.getdefaultfont() Wbase.Widget.__init__(self, possize) self.fontsettings = fontsettings self.text = text self.align = align self._backgroundcolor = backgroundcolor def draw(self, visRgn = None): if self._visible: (font, style, size, color) = self.fontsettings fontid = GetFNum(font) savestate = Qd.GetPenState() Qd.TextFont(fontid) Qd.TextFace(style) Qd.TextSize(size) Qd.RGBForeColor(color) Qd.RGBBackColor(self._backgroundcolor) TE.TETextBox(self.text, self._bounds, self.align) Qd.RGBBackColor((0xffff, 0xffff, 0xffff)) Qd.SetPenState(savestate) def get(self): return self.text def set(self, text): self.text = text if self._parentwindow and self._parentwindow.wid: self.SetPort() self.draw() class _ScrollWidget: # to be overridden def getscrollrects(self): """Return (destrect, viewrect).""" return None, None # internal method def updatescrollbars(self): (dl, dt, dr, db), (vl, vt, vr, vb) = self.getscrollrects() if self._parent._barx: viewwidth = vr - vl destwidth = dr - dl bar = self._parent._barx bar.setmax(destwidth - viewwidth) # MacOS 8.1 doesn't automatically disable # scrollbars whose max <= min bar.enable(destwidth > viewwidth) bar.setviewsize(viewwidth) bar.set(vl - dl) if self._parent._bary: viewheight = vb - vt destheight = db - dt bar = self._parent._bary bar.setmax(destheight - viewheight) # MacOS 8.1 doesn't automatically disable # scrollbars whose max <= min bar.enable(destheight > viewheight) bar.setviewsize(viewheight) bar.set(vt - dt) UNDOLABELS = [ # Indexed by WEGetUndoInfo() value None, "", "typing", "Cut", "Paste", "Clear", "Drag", "Style", "Ruler", "backspace", "delete", "transform", "resize"] class EditText(Wbase.SelectableWidget, _ScrollWidget): """A text edit widget, mainly for simple entry fields.""" def __init__(self, possize, text="", callback=None, inset=(3, 3), fontsettings=None, tabsettings = (32, 0), readonly = 0): if fontsettings is None: import W fontsettings = W.getdefaultfont() Wbase.SelectableWidget.__init__(self, possize) self.temptext = text self.ted = None self.selection = None self.oldselection = None self._callback = callback self.changed = 0 self.selchanged = 0 self._selected = 0 self._enabled = 1 self.wrap = 1 self.readonly = readonly self.fontsettings = fontsettings self.tabsettings = tabsettings if type(inset) <> TupleType: self.inset = (inset, inset) else: self.inset = inset def open(self): if not hasattr(self._parent, "_barx"): self._parent._barx = None if not hasattr(self._parent, "_bary"): self._parent._bary = None self._calcbounds() self.SetPort() viewrect, destrect = self._calctextbounds() flags = self._getflags() self.ted = waste.WENew(destrect, viewrect, flags) self.ted.WEInstallTabHooks() self.ted.WESetAlignment(WASTEconst.weFlushLeft) self.setfontsettings(self.fontsettings) self.settabsettings(self.tabsettings) self.ted.WEUseText(Res.Resource(self.temptext)) self.ted.WECalText() if self.selection: self.setselection(self.selection[0], self.selection[1]) self.selection = None else: self.selview() self.temptext = None self.updatescrollbars() self.bind("pageup", self.scrollpageup) self.bind("pagedown", self.scrollpagedown) self.bind("top", self.scrolltop) self.bind("bottom", self.scrollbottom) self.selchanged = 0 def close(self): self._parent._barx = None self._parent._bary = None self.ted = None self.temptext = None Wbase.SelectableWidget.close(self) def textchanged(self, all=0): self.changed = 1 def selectionchanged(self): self.selchanged = 1 self.oldselection = self.getselection() def gettabsettings(self): return self.tabsettings def settabsettings(self, (tabsize, tabmode)): self.tabsettings = (tabsize, tabmode) if hasattr(self.ted, "WESetTabSize"): port = self._parentwindow.wid.GetWindowPort() if tabmode: (font, style, size, color) = self.getfontsettings() savesettings = GetPortFontSettings(port) SetPortFontSettings(port, (font, style, size)) tabsize = Qd.StringWidth(' ' * tabsize) SetPortFontSettings(port, savesettings) tabsize = max(tabsize, 1) self.ted.WESetTabSize(tabsize) self.SetPort() Qd.EraseRect(self.ted.WEGetViewRect()) self.ted.WEUpdate(port.visRgn) def getfontsettings(self): from Carbon import Res (font, style, size, color) = self.ted.WEGetRunInfo(0)[4] font = Fm.GetFontName(font) return (font, style, size, color) def setfontsettings(self, (font, style, size, color)): self.SetPort() if type(font) <> StringType: font = Fm.GetFontName(font) self.fontsettings = (font, style, size, color) fontid = GetFNum(font) readonly = self.ted.WEFeatureFlag(WASTEconst.weFReadOnly, -1) if readonly: self.ted.WEFeatureFlag(WASTEconst.weFReadOnly, 0) try: self.ted.WEFeatureFlag(WASTEconst.weFInhibitRecal, 1) selstart, selend = self.ted.WEGetSelection() self.ted.WESetSelection(0, self.ted.WEGetTextLength()) self.ted.WESetStyle(WASTEconst.weDoFace, (0, 0, 0, (0, 0, 0))) self.ted.WESetStyle(WASTEconst.weDoFace | WASTEconst.weDoColor | WASTEconst.weDoFont | WASTEconst.weDoSize, (fontid, style, size, color)) self.ted.WEFeatureFlag(WASTEconst.weFInhibitRecal, 0) self.ted.WECalText() self.ted.WESetSelection(selstart, selend) finally: if readonly: self.ted.WEFeatureFlag(WASTEconst.weFReadOnly, 1) viewrect = self.ted.WEGetViewRect() Qd.EraseRect(viewrect) self.ted.WEUpdate(self._parentwindow.wid.GetWindowPort().visRgn) self.selectionchanged() self.updatescrollbars() def adjust(self, oldbounds): self.SetPort() # Note: if App.DrawThemeEditTextFrame is ever used, it will be necessary # to unconditionally outset the invalidated rectangles, since Appearance # frames are drawn outside the bounds. if self._selected and self._parentwindow._hasselframes: self.GetWindow().InvalWindowRect(Qd.InsetRect(oldbounds, -3, -3)) self.GetWindow().InvalWindowRect(Qd.InsetRect(self._bounds, -3, -3)) else: self.GetWindow().InvalWindowRect(oldbounds) self.GetWindow().InvalWindowRect(self._bounds) viewrect, destrect = self._calctextbounds() self.ted.WESetViewRect(viewrect) self.ted.WESetDestRect(destrect) if self.wrap: self.ted.WECalText() if self.ted.WEGetDestRect()[3] < viewrect[1]: self.selview() self.updatescrollbars() # interface ----------------------- # selection stuff def selview(self): self.ted.WESelView() def selectall(self): self.ted.WESetSelection(0, self.ted.WEGetTextLength()) self.selectionchanged() self.updatescrollbars() def selectline(self, lineno, charoffset = 0): newselstart, newselend = self.ted.WEGetLineRange(lineno) # Autoscroll makes the *end* of the selection visible, which, # in the case of a whole line, is the beginning of the *next* line. # So sometimes it leaves our line just above the view rect. # Let's fool Waste by initially selecting one char less: self.ted.WESetSelection(newselstart + charoffset, newselend-1) self.ted.WESetSelection(newselstart + charoffset, newselend) self.selectionchanged() self.updatescrollbars() def getselection(self): if self.ted: return self.ted.WEGetSelection() else: return self.selection def setselection(self, selstart, selend): self.selectionchanged() if self.ted: self.ted.WESetSelection(selstart, selend) self.ted.WESelView() self.updatescrollbars() else: self.selection = selstart, selend def offsettoline(self, offset): return self.ted.WEOffsetToLine(offset) def countlines(self): return self.ted.WECountLines() def getselectedtext(self): selstart, selend = self.ted.WEGetSelection() return self.ted.WEGetText().data[selstart:selend] def expandselection(self): oldselstart, oldselend = self.ted.WEGetSelection() selstart, selend = min(oldselstart, oldselend), max(oldselstart, oldselend) if selstart <> selend and chr(self.ted.WEGetChar(selend-1)) == '\r': selend = selend - 1 newselstart, dummy = self.ted.WEFindLine(selstart, 1) dummy, newselend = self.ted.WEFindLine(selend, 1) if oldselstart <> newselstart or oldselend <> newselend: self.ted.WESetSelection(newselstart, newselend) self.updatescrollbars() self.selectionchanged() def insert(self, text): self.ted.WEInsert(text, None, None) self.textchanged() self.selectionchanged() # text def set(self, text): if not self.ted: self.temptext = text else: self.ted.WEUseText(Res.Resource(text)) self.ted.WECalText() self.SetPort() viewrect, destrect = self._calctextbounds() self.ted.WESetViewRect(viewrect) self.ted.WESetDestRect(destrect) rgn = Qd.NewRgn() Qd.RectRgn(rgn, viewrect) Qd.EraseRect(viewrect) self.draw(rgn) self.updatescrollbars() self.textchanged(1) def get(self): if not self._parent: return self.temptext else: return self.ted.WEGetText().data # events def key(self, char, event): (what, message, when, where, modifiers) = event if self._enabled and not modifiers & Events.cmdKey or char in Wkeys.arrowkeys: self.ted.WEKey(ord(char), modifiers) if char not in Wkeys.navigationkeys: self.textchanged() if char not in Wkeys.scrollkeys: self.selectionchanged() self.updatescrollbars() if self._callback: Wbase.CallbackCall(self._callback, 0, char, modifiers) def click(self, point, modifiers): if not self._enabled: return self.ted.WEClick(point, modifiers, Evt.TickCount()) self.selectionchanged() self.updatescrollbars() return 1 def idle(self): self.SetPort() self.ted.WEIdle() def rollover(self, point, onoff): if onoff: Wbase.SetCursor("iBeam") def activate(self, onoff): self._activated = onoff if self._visible: self.SetPort() # DISABLED! There are too many places where it is assumed that # the frame of an EditText item is 1 pixel, inside the bounds. #state = [kThemeStateActive, kThemeStateInactive][not onoff] #App.DrawThemeEditTextFrame(Qd.InsetRect(self._bounds, 1, 1), state) if self._selected: if onoff: self.ted.WEActivate() else: self.ted.WEDeactivate() self.drawselframe(onoff) def select(self, onoff, isclick = 0): if Wbase.SelectableWidget.select(self, onoff): return self.SetPort() if onoff: self.ted.WEActivate() if self._parentwindow._tabbable and not isclick: self.selectall() else: self.ted.WEDeactivate() self.drawselframe(onoff) def draw(self, visRgn = None): if self._visible: if not visRgn: visRgn = self._parentwindow.wid.GetWindowPort().visRgn self.ted.WEUpdate(visRgn) # DISABLED! There are too many places where it is assumed that # the frame of an EditText item is 1 pixel, inside the bounds. #state = [kThemeStateActive, kThemeStateInactive][not self._activated] #App.DrawThemeEditTextFrame(Qd.InsetRect(self._bounds, 1, 1), state) Qd.FrameRect(self._bounds) if self._selected and self._activated: self.drawselframe(1) # scrolling def scrollpageup(self): if self._parent._bary and self._parent._bary._enabled: self.vscroll("++") def scrollpagedown(self): if self._parent._bary and self._parent._bary._enabled: self.vscroll("--") def scrolltop(self): if self._parent._bary and self._parent._bary._enabled: self.vscroll(self._parent._bary.getmin()) if self._parent._barx and self._parent._barx._enabled: self.hscroll(self._parent._barx.getmin()) def scrollbottom(self): if self._parent._bary and self._parent._bary._enabled: self.vscroll(self._parent._bary.getmax()) # menu handlers def domenu_copy(self, *args): selbegin, selend = self.ted.WEGetSelection() if selbegin == selend: return if hasattr(Scrap, 'ZeroScrap'): Scrap.ZeroScrap() else: Scrap.ClearCurrentScrap() self.ted.WECopy() self.updatescrollbars() def domenu_cut(self, *args): selbegin, selend = self.ted.WEGetSelection() if selbegin == selend: return if hasattr(Scrap, 'ZeroScrap'): Scrap.ZeroScrap() else: Scrap.ClearCurrentScrap() self.ted.WECut() self.updatescrollbars() self.selview() self.textchanged() self.selectionchanged() if self._callback: Wbase.CallbackCall(self._callback, 0, "", None) def domenu_paste(self, *args): if not self.ted.WECanPaste(): return self.selview() self.ted.WEPaste() self.updatescrollbars() self.textchanged() self.selectionchanged() if self._callback: Wbase.CallbackCall(self._callback, 0, "", None) def domenu_clear(self, *args): self.ted.WEDelete() self.selview() self.updatescrollbars() self.textchanged() self.selectionchanged() if self._callback: Wbase.CallbackCall(self._callback, 0, "", None) def domenu_undo(self, *args): which, redo = self.ted.WEGetUndoInfo() if not which: return self.ted.WEUndo() self.updatescrollbars() self.textchanged() self.selectionchanged() if self._callback: Wbase.CallbackCall(self._callback, 0, "", None) def can_undo(self, menuitem): #doundo = self.ted.WEFeatureFlag(WASTEconst.weFUndo, -1) #print doundo #if not doundo: # return 0 which, redo = self.ted.WEGetUndoInfo() if which < len(UNDOLABELS): which = UNDOLABELS[which] else: which = "" if which == None: return None if redo: which = "Redo "+which else: which = "Undo "+which menuitem.settext(which) return 1 def domenu_selectall(self, *args): self.selectall() # private def getscrollrects(self): return self.ted.WEGetDestRect(), self.ted.WEGetViewRect() def vscroll(self, value): lineheight = self.ted.WEGetHeight(0, 1) dr = self.ted.WEGetDestRect() vr = self.ted.WEGetViewRect() viewheight = vr[3] - vr[1] maxdelta = vr[1] - dr[1] mindelta = vr[3] - dr[3] if value == "+": delta = lineheight elif value == "-": delta = - lineheight elif value == "++": delta = viewheight - lineheight elif value == "--": delta = lineheight - viewheight else: # in thumb delta = vr[1] - dr[1] - value delta = min(maxdelta, delta) delta = max(mindelta, delta) self.ted.WEScroll(0, delta) self.updatescrollbars() def hscroll(self, value): dr = self.ted.WEGetDestRect() vr = self.ted.WEGetViewRect() destwidth = dr[2] - dr[0] viewwidth = vr[2] - vr[0] viewoffset = maxdelta = vr[0] - dr[0] mindelta = vr[2] - dr[2] if value == "+": delta = 32 elif value == "-": delta = - 32 elif value == "++": delta = 0.5 * (vr[2] - vr[0]) elif value == "--": delta = 0.5 * (vr[0] - vr[2]) else: # in thumb delta = vr[0] - dr[0] - value #cur = (32767 * viewoffset) / (destwidth - viewwidth) #delta = (cur-value)*(destwidth - viewwidth)/32767 #if abs(delta - viewoffset) <=2: # # compensate for irritating rounding error # delta = viewoffset delta = min(maxdelta, delta) delta = max(mindelta, delta) self.ted.WEScroll(delta, 0) self.updatescrollbars() # some internals def _getflags(self): flags = WASTEconst.weDoAutoScroll | WASTEconst.weDoMonoStyled if self.readonly: flags = flags | WASTEconst.weDoReadOnly else: flags = flags | WASTEconst.weDoUndo return flags def _getviewrect(self): return Qd.InsetRect(self._bounds, self.inset[0], self.inset[1]) def _calctextbounds(self): viewrect = l, t, r, b = self._getviewrect() if self.ted: dl, dt, dr, db = self.ted.WEGetDestRect() vl, vt, vr, vb = self.ted.WEGetViewRect() yshift = t - vt if (db - dt) < (b - t): destrect = viewrect else: destrect = l, dt + yshift, r, db + yshift else: destrect = viewrect return viewrect, destrect class TextEditor(EditText): """A text edit widget.""" def __init__(self, possize, text="", callback=None, wrap=1, inset=(4, 4), fontsettings=None, tabsettings=(32, 0), readonly=0): EditText.__init__(self, possize, text, callback, inset, fontsettings, tabsettings, readonly) self.wrap = wrap def _getflags(self): flags = WASTEconst.weDoAutoScroll | WASTEconst.weDoMonoStyled | \ WASTEconst.weDoOutlineHilite if self.readonly: flags = flags | WASTEconst.weDoReadOnly else: flags = flags | WASTEconst.weDoUndo return flags def _getviewrect(self): l, t, r, b = self._bounds return (l + 5, t + 2, r, b - 2) def _calctextbounds(self): if self.wrap: return EditText._calctextbounds(self) else: viewrect = l, t, r, b = self._getviewrect() if self.ted: dl, dt, dr, db = self.ted.WEGetDestRect() vl, vt, vr, vb = self.ted.WEGetViewRect() xshift = l - vl yshift = t - vt if (db - dt) < (b - t): yshift = t - dt destrect = (dl + xshift, dt + yshift, dr + xshift, db + yshift) else: destrect = (l, t, r + 5000, b) return viewrect, destrect def draw(self, visRgn = None): if self._visible: if not visRgn: visRgn = self._parentwindow.wid.GetWindowPort().visRgn self.ted.WEUpdate(visRgn) if self._selected and self._activated: self.drawselframe(1) def activate(self, onoff): self._activated = onoff if self._visible: self.SetPort() # doesn't draw frame, as EditText.activate does if self._selected: if onoff: self.ted.WEActivate() else: self.ted.WEDeactivate() self.drawselframe(onoff) import re commentPat = re.compile("[ \t]*(#)") indentPat = re.compile("[ \t]*") kStringColor = (0, 0x7fff, 0) kCommentColor = (0, 0, 0xb000) class PyEditor(TextEditor): """A specialized Python source edit widget""" def __init__(self, possize, text="", callback=None, inset=(4, 4), fontsettings=None, tabsettings=(32, 0), readonly=0, debugger=None, file=''): TextEditor.__init__(self, possize, text, callback, 0, inset, fontsettings, tabsettings, readonly) self.bind("cmd[", self.domenu_shiftleft) self.bind("cmd]", self.domenu_shiftright) self.bind("cmdshift[", self.domenu_uncomment) self.bind("cmdshift]", self.domenu_comment) self.bind("cmdshiftd", self.alldirty) self.file = file # only for debugger reference self._debugger = debugger if debugger: debugger.register_editor(self, self.file) self._dirty = (0, None) self.do_fontify = 0 #def open(self): # TextEditor.open(self) # if self.do_fontify: # self.fontify() # self._dirty = (None, None) def _getflags(self): flags = (WASTEconst.weDoDrawOffscreen | WASTEconst.weDoUseTempMem | WASTEconst.weDoAutoScroll | WASTEconst.weDoOutlineHilite) if self.readonly: flags = flags | WASTEconst.weDoReadOnly else: flags = flags | WASTEconst.weDoUndo return flags def textchanged(self, all=0): self.changed = 1 if all: self._dirty = (0, None) return oldsel = self.oldselection sel = self.getselection() if not sel: # XXX what to do? return selstart, selend = sel selstart, selend = min(selstart, selend), max(selstart, selend) if oldsel: oldselstart, oldselend = min(oldsel), max(oldsel) selstart, selend = min(selstart, oldselstart), max(selend, oldselend) startline = self.offsettoline(selstart) endline = self.offsettoline(selend) selstart, _ = self.ted.WEGetLineRange(startline) _, selend = self.ted.WEGetLineRange(endline) if selstart > 0: selstart = selstart - 1 self._dirty = (selstart, selend) def idle(self): self.SetPort() self.ted.WEIdle() if not self.do_fontify: return start, end = self._dirty if start is None: return textLength = self.ted.WEGetTextLength() if end is None: end = textLength if start >= end: self._dirty = (None, None) else: self.fontify(start, end) self._dirty = (None, None) def alldirty(self, *args): self._dirty = (0, None) def fontify(self, start=0, end=None): #W.SetCursor('watch') if self.readonly: self.ted.WEFeatureFlag(WASTEconst.weFReadOnly, 0) self.ted.WEFeatureFlag(WASTEconst.weFOutlineHilite, 0) self.ted.WEDeactivate() self.ted.WEFeatureFlag(WASTEconst.weFAutoScroll, 0) self.ted.WEFeatureFlag(WASTEconst.weFUndo, 0) pytext = self.get().replace("\r", "\n") if end is None: end = len(pytext) else: end = min(end, len(pytext)) selstart, selend = self.ted.WEGetSelection() self.ted.WESetSelection(start, end) self.ted.WESetStyle(WASTEconst.weDoFace | WASTEconst.weDoColor, (0, 0, 12, (0, 0, 0))) tags = PyFontify.fontify(pytext, start, end) styles = { 'string': (WASTEconst.weDoColor, (0, 0, 0, kStringColor)), 'keyword': (WASTEconst.weDoFace, (0, 1, 0, (0, 0, 0))), 'comment': (WASTEconst.weDoFace | WASTEconst.weDoColor, (0, 0, 0, kCommentColor)), 'identifier': (WASTEconst.weDoColor, (0, 0, 0, (0xbfff, 0, 0))) } setselection = self.ted.WESetSelection setstyle = self.ted.WESetStyle for tag, start, end, sublist in tags: setselection(start, end) mode, style = styles[tag] setstyle(mode, style) self.ted.WESetSelection(selstart, selend) self.SetPort() self.ted.WEFeatureFlag(WASTEconst.weFAutoScroll, 1) self.ted.WEFeatureFlag(WASTEconst.weFUndo, 1) self.ted.WEActivate() self.ted.WEFeatureFlag(WASTEconst.weFOutlineHilite, 1) if self.readonly: self.ted.WEFeatureFlag(WASTEconst.weFReadOnly, 1) def domenu_shiftleft(self): self.expandselection() selstart, selend = self.ted.WEGetSelection() selstart, selend = min(selstart, selend), max(selstart, selend) snippet = self.getselectedtext() lines = string.split(snippet, '\r') for i in range(len(lines)): if lines[i][:1] == '\t': lines[i] = lines[i][1:] snippet = string.join(lines, '\r') self.insert(snippet) self.ted.WESetSelection(selstart, selstart + len(snippet)) def domenu_shiftright(self): self.expandselection() selstart, selend = self.ted.WEGetSelection() selstart, selend = min(selstart, selend), max(selstart, selend) snippet = self.getselectedtext() lines = string.split(snippet, '\r') for i in range(len(lines) - (not lines[-1])): lines[i] = '\t' + lines[i] snippet = string.join(lines, '\r') self.insert(snippet) self.ted.WESetSelection(selstart, selstart + len(snippet)) def domenu_uncomment(self): self.expandselection() selstart, selend = self.ted.WEGetSelection() selstart, selend = min(selstart, selend), max(selstart, selend) snippet = self.getselectedtext() lines = string.split(snippet, '\r') for i in range(len(lines)): m = commentPat.match(lines[i]) if m: pos = m.start(1) lines[i] = lines[i][:pos] + lines[i][pos+1:] snippet = string.join(lines, '\r') self.insert(snippet) self.ted.WESetSelection(selstart, selstart + len(snippet)) def domenu_comment(self): self.expandselection() selstart, selend = self.ted.WEGetSelection() selstart, selend = min(selstart, selend), max(selstart, selend) snippet = self.getselectedtext() lines = string.split(snippet, '\r') indent = 3000 # arbitrary large number... for line in lines: if string.strip(line): m = indentPat.match(line) if m: indent = min(indent, m.regs[0][1]) else: indent = 0 break for i in range(len(lines) - (not lines[-1])): lines[i] = lines[i][:indent] + "#" + lines[i][indent:] snippet = string.join(lines, '\r') self.insert(snippet) self.ted.WESetSelection(selstart, selstart + len(snippet)) def setfile(self, file): self.file = file def set(self, text, file = ''): oldfile = self.file self.file = file if self._debugger: self._debugger.unregister_editor(self, oldfile) self._debugger.register_editor(self, file) TextEditor.set(self, text) def close(self): if self._debugger: self._debugger.unregister_editor(self, self.file) self._debugger = None TextEditor.close(self) def click(self, point, modifiers): if not self._enabled: return if self._debugger and self.pt_in_breaks(point): self.breakhit(point, modifiers) elif self._debugger: bl, bt, br, bb = self._getbreakrect() Qd.EraseRect((bl, bt, br-1, bb)) TextEditor.click(self, point, modifiers) self.drawbreakpoints() else: TextEditor.click(self, point, modifiers) if self.ted.WEGetClickCount() >= 3: # select block with our indent lines = string.split(self.get(), '\r') selstart, selend = self.ted.WEGetSelection() lineno = self.ted.WEOffsetToLine(selstart) tabs = 0 line = lines[lineno] while line[tabs:] and line[tabs] == '\t': tabs = tabs + 1 tabstag = '\t' * tabs fromline = 0 toline = len(lines) if tabs: for i in range(lineno - 1, -1, -1): line = lines[i] if line[:tabs] <> tabstag: fromline = i + 1 break for i in range(lineno + 1, toline): line = lines[i] if line[:tabs] <> tabstag: toline = i - 1 break selstart, dummy = self.ted.WEGetLineRange(fromline) dummy, selend = self.ted.WEGetLineRange(toline) self.ted.WESetSelection(selstart, selend) def breakhit(self, point, modifiers): if not self.file: return destrect = self.ted.WEGetDestRect() offset, edge = self.ted.WEGetOffset(point) lineno = self.ted.WEOffsetToLine(offset) + 1 if point[1] <= destrect[3]: self._debugger.clear_breaks_above(self.file, self.countlines()) self._debugger.toggle_break(self.file, lineno) else: self._debugger.clear_breaks_above(self.file, lineno) def key(self, char, event): (what, message, when, where, modifiers) = event if modifiers & Events.cmdKey and not char in Wkeys.arrowkeys: return if char == '\r': selstart, selend = self.ted.WEGetSelection() selstart, selend = min(selstart, selend), max(selstart, selend) lastchar = chr(self.ted.WEGetChar(selstart-1)) if lastchar <> '\r' and selstart: pos, dummy = self.ted.WEFindLine(selstart, 0) lineres = Res.Resource('') self.ted.WECopyRange(pos, selstart, lineres, None, None) line = lineres.data + '\n' tabcount = self.extratabs(line) self.ted.WEKey(ord('\r'), 0) for i in range(tabcount): self.ted.WEKey(ord('\t'), 0) else: self.ted.WEKey(ord('\r'), 0) elif char in ')]}': self.ted.WEKey(ord(char), modifiers) self.balanceparens(char) else: self.ted.WEKey(ord(char), modifiers) if char not in Wkeys.navigationkeys: self.textchanged() self.selectionchanged() self.updatescrollbars() def balanceparens(self, char): if char == ')': target = '(' elif char == ']': target = '[' elif char == '}': target = '{' recursionlevel = 1 selstart, selend = self.ted.WEGetSelection() count = min(selstart, selend) - 2 mincount = max(0, count - 2048) lastquote = None while count > mincount: testchar = chr(self.ted.WEGetChar(count)) if testchar in "\"'" and chr(self.ted.WEGetChar(count - 1)) <> '\\': if lastquote == testchar: recursionlevel = recursionlevel - 1 lastquote = None elif not lastquote: recursionlevel = recursionlevel + 1 lastquote = testchar elif not lastquote and testchar == char: recursionlevel = recursionlevel + 1 elif not lastquote and testchar == target: recursionlevel = recursionlevel - 1 if recursionlevel == 0: import time autoscroll = self.ted.WEFeatureFlag(WASTEconst.weFAutoScroll, -1) if autoscroll: self.ted.WEFeatureFlag(WASTEconst.weFAutoScroll, 0) self.ted.WESetSelection(count, count + 1) self._parentwindow.wid.GetWindowPort().QDFlushPortBuffer(None) # needed under OSX time.sleep(0.2) self.ted.WESetSelection(selstart, selend) if autoscroll: self.ted.WEFeatureFlag(WASTEconst.weFAutoScroll, 1) break count = count - 1 def extratabs(self, line): tabcount = 0 for c in line: if c <> '\t': break tabcount = tabcount + 1 last = 0 cleanline = '' tags = PyFontify.fontify(line) # strip comments and strings for tag, start, end, sublist in tags: if tag in ('string', 'comment'): cleanline = cleanline + line[last:start] last = end cleanline = cleanline + line[last:] cleanline = string.strip(cleanline) if cleanline and cleanline[-1] == ':': tabcount = tabcount + 1 else: # extra indent after unbalanced (, [ or { for open, close in (('(', ')'), ('[', ']'), ('{', '}')): count = string.count(cleanline, open) if count and count > string.count(cleanline, close): tabcount = tabcount + 2 break return tabcount def rollover(self, point, onoff): if onoff: if self._debugger and self.pt_in_breaks(point): Wbase.SetCursor("arrow") else: Wbase.SetCursor("iBeam") def draw(self, visRgn = None): TextEditor.draw(self, visRgn) if self._debugger: self.drawbreakpoints() def showbreakpoints(self, onoff): if (not not self._debugger) <> onoff: if onoff: if not __debug__: import W raise W.AlertError, "Can't debug in \"Optimize bytecode\" mode.\r(see \"Default startup options\" in EditPythonPreferences)" import PyDebugger self._debugger = PyDebugger.getdebugger() self._debugger.register_editor(self, self.file) elif self._debugger: self._debugger.unregister_editor(self, self.file) self._debugger = None self.adjust(self._bounds) def togglebreakpoints(self): self.showbreakpoints(not self._debugger) def clearbreakpoints(self): if self.file: self._debugger.clear_all_file_breaks(self.file) def editbreakpoints(self): if self._debugger: self._debugger.edit_breaks() self._debugger.breaksviewer.selectfile(self.file) def drawbreakpoints(self, eraseall = 0): breakrect = bl, bt, br, bb = self._getbreakrect() br = br - 1 self.SetPort() Qd.PenPat(Qd.GetQDGlobalsGray()) Qd.PaintRect((br, bt, br + 1, bb)) Qd.PenNormal() self._parentwindow.tempcliprect(breakrect) Qd.RGBForeColor((0xffff, 0, 0)) try: lasttop = bt self_ted = self.ted Qd_PaintOval = Qd.PaintOval Qd_EraseRect = Qd.EraseRect for lineno in self._debugger.get_file_breaks(self.file): start, end = self_ted.WEGetLineRange(lineno - 1) if lineno <> self_ted.WEOffsetToLine(start) + 1: # breakpoints beyond our text: erase rest, and back out Qd_EraseRect((bl, lasttop, br, bb)) break (x, y), h = self_ted.WEGetPoint(start, 0) bottom = y + h #print y, (lasttop, bottom) if bottom > lasttop: Qd_EraseRect((bl, lasttop, br, y + h * eraseall)) lasttop = bottom redbullet = bl + 2, y + 3, bl + 8, y + 9 Qd_PaintOval(redbullet) else: Qd_EraseRect((bl, lasttop, br, bb)) Qd.RGBForeColor((0, 0, 0)) finally: self._parentwindow.restoreclip() def updatescrollbars(self): if self._debugger: self.drawbreakpoints(1) TextEditor.updatescrollbars(self) def pt_in_breaks(self, point): return Qd.PtInRect(point, self._getbreakrect()) def _getbreakrect(self): if self._debugger: l, t, r, b = self._bounds return (l+1, t+1, l + 12, b-1) else: return (0, 0, 0, 0) def _getviewrect(self): l, t, r, b = self._bounds if self._debugger: return (l + 17, t + 2, r, b - 2) else: return (l + 5, t + 2, r, b - 2) def _calctextbounds(self): viewrect = l, t, r, b = self._getviewrect() if self.ted: dl, dt, dr, db = self.ted.WEGetDestRect() vl, vt, vr, vb = self.ted.WEGetViewRect() xshift = l - vl yshift = t - vt if (db - dt) < (b - t): yshift = t - dt destrect = (dl + xshift, dt + yshift, dr + xshift, db + yshift) else: destrect = (l, t, r + 5000, b) return viewrect, destrect def GetFNum(fontname): """Same as Fm.GetFNum(), but maps a missing font to Monaco instead of the system font.""" if fontname <> Fm.GetFontName(0): fontid = Fm.GetFNum(fontname) if fontid == 0: fontid = Fonts.monaco else: fontid = 0 return fontid # b/w compat. Anyone using this? GetFName = Fm.GetFontName def GetPortFontSettings(port): return Fm.GetFontName(port.GetPortTextFont()), port.GetPortTextFace(), port.GetPortTextSize() def SetPortFontSettings(port, (font, face, size)): saveport = Qd.GetPort() Qd.SetPort(port) Qd.TextFont(GetFNum(font)) Qd.TextFace(face) Qd.TextSize(size) Qd.SetPort(saveport)