--- /dev/null
+# A CallTip window class for Tkinter/IDLE.
+# After ToolTip.py, which uses ideas gleaned from PySol
+
+# Used by the CallTips IDLE extension.
+import os
+from Tkinter import *
+
+class CallTip:
+
+ def __init__(self, widget):
+ self.widget = widget
+ self.tipwindow = None
+ self.id = None
+ self.x = self.y = 0
+
+ def showtip(self, text):
+ self.text = text
+ if self.tipwindow or not self.text:
+ return
+ self.widget.see("insert")
+ x, y, cx, cy = self.widget.bbox("insert")
+ x = x + self.widget.winfo_rootx() + 2
+ y = y + cy + self.widget.winfo_rooty()
+ self.tipwindow = tw = Toplevel(self.widget)
+ tw.wm_overrideredirect(1)
+ tw.wm_geometry("+%d+%d" % (x, y))
+ label = Label(tw, text=self.text, justify=LEFT,
+ background="#ffffe0", relief=SOLID, borderwidth=1)
+ label.pack()
+
+ def hidetip(self):
+ tw = self.tipwindow
+ self.tipwindow = None
+ if tw:
+ tw.destroy()
+
+
+###############################
+#
+# Test Code
+#
+class container: # Conceptually an editor_window
+ def __init__(self):
+ root = Tk()
+ text = self.text = Text(root)
+ text.pack(side=LEFT, fill=BOTH, expand=1)
+ text.insert("insert", "string.split")
+ root.update()
+ self.calltip = CallTip(text)
+
+ text.event_add("<<calltip-show>>", "(")
+ text.event_add("<<calltip-hide>>", ")")
+ text.bind("<<calltip-show>>", self.calltip_show)
+ text.bind("<<calltip-hide>>", self.calltip_hide)
+
+ text.focus_set()
+ # root.mainloop() # not in idle
+
+ def calltip_show(self, event):
+ self.calltip.showtip("Hello world")
+
+ def calltip_hide(self, event):
+ self.calltip.hidetip()
+
+def main():
+ # Test code
+ c=container()
+
+if __name__=='__main__':
+ main()
--- /dev/null
+import string
+import sys
+import types
+
+class CallTips:
+
+ menudefs = [
+ ]
+
+ keydefs = {
+ '<<paren-open>>': ['<Key-parenleft>'],
+ '<<paren-close>>': ['<Key-parenright>'],
+ '<<check-calltip-cancel>>': ['<KeyRelease>', '<ButtonRelease>']
+ }
+ windows_keydefs = {
+ }
+
+ unix_keydefs = {
+ }
+
+ def __init__(self, editwin):
+ self.editwin = editwin
+ self.text = editwin.text
+ self.calltip = None
+ if hasattr(self.text, "make_calltip_window"):
+ self._make_calltip_window = self.text.make_calltip_window
+ else:
+ self._make_calltip_window = self._make_tk_calltip_window
+
+ def _make_tk_calltip_window(self):
+ import CallTipWindow
+ return CallTipWindow.CallTip(self.text)
+
+ def _remove_calltip_window(self):
+ if self.calltip:
+ self.calltip.hidetip()
+ self.calltip = None
+
+ def paren_open_event(self, event):
+ self._remove_calltip_window()
+ arg_text = get_arg_text(self.get_object_at_cursor())
+ if arg_text:
+ self.calltip_start = self.text.index("insert")
+ self.calltip = self._make_calltip_window()
+ self.calltip.showtip(arg_text)
+ # dont return "break" so the key is inserted.
+
+ def paren_close_event(self, event):
+ # Now just hides, but later we should check if other
+ # paren'd expressions remain open.
+ # dont return "break" so the key is inserted.
+ self._remove_calltip_window()
+
+ def check_calltip_cancel_event(self, event):
+ # This doesnt quite work correctly as it is processed
+ # _before_ the key is handled. Thus, when the "Up" key
+ # is pressed, this test happens before the cursor is moved.
+ # This will do for now.
+ if self.calltip:
+ # If we have moved before the start of the calltip,
+ # or off the calltip line, then cancel the tip.
+ # (Later need to be smarter about multi-line, etc)
+ if self.text.compare("insert", "<=", self.calltip_start) or \
+ self.text.compare("insert", ">", self.calltip_start + " lineend"):
+ self._remove_calltip_window()
+
+ # dont return "break" so the event is handled normally.
+
+ def get_object_at_cursor(self,
+ wordchars="._" + string.uppercase + string.lowercase + string.digits):
+ # XXX - This need to be moved to a better place
+ # as the "." attribute lookup code can also use it.
+ text = self.text
+ index = 0
+ while 1:
+ index = index + 1
+ indexspec = "insert-%dc" % index
+ ch = text.get(indexspec)
+ if ch not in wordchars:
+ break
+ if text.compare(indexspec, "<=", "1.0"):
+ break
+ # Now attempt to locate the object.
+ # How is this for a hack!
+ word = text.get("insert-%dc" % (index-1,), "insert")
+ if word:
+ import sys, __main__
+ namespace = sys.modules.copy()
+ namespace.update(__main__.__dict__)
+ try:
+ return eval(word, namespace)
+ except:
+ pass
+ return None # Can't find an object.
+
+def get_arg_text(ob):
+ # Get a string describing the arguments for the given object.
+ argText = ""
+ if ob is not None:
+ argOffset = 0
+ # bit of a hack for methods - turn it into a function
+ # but we drop the "self" param.
+ if type(ob)==types.MethodType:
+ ob = ob.im_func
+ argOffset = 1
+ # Try and build one for Python defined functions
+ if type(ob) in [types.FunctionType, types.LambdaType]:
+ try:
+ realArgs = ob.func_code.co_varnames[argOffset:ob.func_code.co_argcount]
+ defaults = ob.func_defaults or []
+ defaults = list(map(lambda name: "=%s" % name, defaults))
+ defaults = [""] * (len(realArgs)-len(defaults)) + defaults
+ argText = string.join( map(lambda arg, dflt: arg+dflt, realArgs, defaults), ", ")
+ if len(realArgs)+argOffset < (len(ob.func_code.co_varnames) - len(ob.func_code.co_names) ):
+ if argText: argText = argText + ", "
+ argText = argText + "..."
+ argText = "(%s)" % argText
+ except:
+ pass
+ # Can't build an argument list - see if we can use a docstring.
+ if not argText and hasattr(ob, "__doc__") and ob.__doc__:
+ pos = string.find(ob.__doc__, "\n")
+ if pos<0 or pos>70: pos=70
+ argText = ob.__doc__[:pos]
+
+ return argText
+
+#################################################
+#
+# Test code
+#
+if __name__=='__main__':
+
+ def t1(): "()"
+ def t2(a, b=None): "(a, b=None)"
+ def t3(a, *args): "(a, ...)"
+ def t4(*args): "(...)"
+ def t5(a, *args): "(a, ...)"
+ def t6(a, b=None, *args, **kw): "(a, b=None, ...)"
+
+ class TC:
+ def t1(self): "()"
+ def t2(self, a, b=None): "(a, b=None)"
+ def t3(self, a, *args): "(a, ...)"
+ def t4(self, *args): "(...)"
+ def t5(self, a, *args): "(a, ...)"
+ def t6(self, a, b=None, *args, **kw): "(a, b=None, ...)"
+
+
+ def test( tests ):
+ failed=[]
+ for t in tests:
+ if get_arg_text(t) != t.__doc__:
+ failed.append(t)
+ print "%s - expected %s, but got %s" % (t, `t.__doc__`, `get_arg_text(t)`)
+ print "%d of %d tests failed" % (len(failed), len(tests))
+
+ tc = TC()
+ tests = t1, t2, t3, t4, t5, t6, \
+ tc.t1, tc.t2, tc.t3, tc.t4, tc.t5, tc.t6
+
+ test(tests)
projects / python / commitdiff