Discussion :

[StabiloHB]

Bonjour à tous,

J'ai déjà fait un petit algo qui permet de détecter le passage du curseur de la souris sur une zone grpahique de Tkinter. Plus précisément un Label point d'interrogation "?".
Je voudrai faire appaitre à l'issu de ce test une sorte de petite page blanche où je pourrais y marquer de l'aide en texte.
Un peu à l'image de ça (c'est sur Excel mais peu importe):



je ne veux cependant pas ouvrir une nouvelle fenetre, ou inserer quelque chose dans mon root. Simplement une sorte de surcouche.
si vous avez des idées n'hésitez pas.
Merci d'avance.

[VinsS]

Salut,

On appelle ça couramment un toolTip.

D'après la doc, il faut un module supplémentaire wckToolTips

http://effbot.org/zone/wcklib-tooltips.htm

[StabiloHB]

Ah super merci, je ne me souvenais plus du nom.
Bon petit autre probleme, je sais il n'est pas en rapport avec la discussion, mais mon pip install dans CMD ne trouve pas de module: wckToolTips, wcklib.
Avez vous une idée ?

RE_EDIT: je viens de voir que c'est le module wck que je dois prendre, mais il n'est valide quand python 2...

Avez vous une autre solution ?

Merci d'avance.

Valentin.

[Julien N]

Salut!

J'ai essayé de faire la même chose il y a quelque temps. J'avais ouvert un fil sur ce forum que je ne retrouve plus. Mais j'ai conservé un bout de code permettant de faire exactement cela. C'est basé sur ToolTipBase comme indiqué par VinsS mais sans dépendances. Le code est pompé du Github d'Evandrix ayant développé un iddle python en tkinter. Attention, le code ci-dessous fonctionne sur python 2, mais il y a trois fois rien pour le convertir en 3.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
 
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import Tkinter as tk
import ttk
import textwrap
 
class HoverInfo():
    """Allow to display an info window near a Tkinter widget. Based on
    ToolTipBase object from evandrix (idlelib)
 
    Parameters
    ----------
        master : Tkinter widget
            Tkinter widget on which the info box will be displayed.
        text : str, opt
            Text to display in the info window.
        width : int, opt
            Max width of the info window in character length. Default 40.
        duration : int, opt
            Time in ms to wait before seing the info window to popup.
            Default is 500ms (0.5s)
    """
    def __init__(self, master, text='', width=40, duration=500):
 
        self.master = master
 
        if not isinstance(text, str):
            raise ValueError('"text" parameter must be a string')
        if not isinstance(duration, int):
            raise ValueError('"duration" parameter must be an integer')
        if not isinstance(width, int):
            raise ValueError('"width" parameter must be an integer')
 
        self.text_info = text
        self.width = width
        self.duration = duration
        self.infowindow = None
        self.id = None
        self.x = self.y = 0
        self._id1 = self.master.bind('<Enter>', self.enter)
        self._id2 = self.master.bind('<Leave>', self.leave)
        self._id3 = self.master.bind('<ButtonPress>', self.leave)
 
    def enter(self, event=None):
        self.schedule()
 
    def leave(self, event=None):
        self.unschedule()
        self.hideinfo()
 
    def schedule(self):
        self.unschedule()
        self.id = self.master.after(self.duration, self.showinfo)
 
    def unschedule(self):
        id = self.id
        self.id = None
        if id:
            self.master.after_cancel(id)
 
    def showinfo(self):
 
        if self.infowindow:
            return
 
        # Place the infowindow outside the master
        x = self.master.winfo_rootx() + 20
        y = self.master.winfo_rooty() + self.master.winfo_height() + 1
        self.infowindow = tw = tk.Toplevel(self.master)
        tw.wm_overrideredirect(1)
        tw.wm_geometry('+%d+%d' % (x, y))
 
        # Wrap text_info to avoid too large infowindow
        _text = '\n'.join(textwrap.wrap(self.text_info, width=self.width))
        label = tk.Label(self.infowindow, text=_text, justify='left',
                         background="#E5E5E5", borderwidth=0.5)
        label.pack()
 
    def hideinfo(self):
 
        tw = self.infowindow
        self.infowindow = None
        if tw:
            tw.destroy()
 
class MyApp(tk.Frame):
    """
    """
    def __init__(self, parent, *args, **kwargs):
        tk.Frame.__init__(self, parent, *args, **kwargs)
        label = tk.Label(self, text='Hover me!', width=15, height=3)
        label.pack()
        hover = HoverInfo(label, "This is a message displayed when \
        mouse's cursor is let more than 0.5s over this widget")
 
if __name__ == '__main__':
    root = tk.Tk()
    app = MyApp(root)
    app.pack()
    root.mainloop()

Ju

[StabiloHB]

Salut,
Merci, j'ai aussi trouvé un code sur internet qui ne dépend que de tkinter sous Python 3
Le probleme c'est que j'ai du mal a la comprendre.
Une classe c'est une sorte de sous programme que l'on définie ?
Et tout ces self, à quoi ils servent ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
import tkinter as tk
 
class ToolTipManager:
 
    label = None
    window = None
    active = 0
 
    def __init__(self):
        self.tag = None
 
    def getcontroller(self, widget):
        if self.tag is None:
 
            self.tag = "ui_tooltip_%d" % id(self)
            widget.bind_class(self.tag, "<Enter>", self.enter)
            widget.bind_class(self.tag, "<Leave>", self.leave)
 
            # pick suitable colors for tooltips
            try:
                self.bg = "systeminfobackground"
                self.fg = "systeminfotext"
                widget.winfo_rgb(self.fg) # make sure system colors exist
                widget.winfo_rgb(self.bg)
            except:
                self.bg = "#ffffe0"
                self.fg = "black"
 
        return self.tag
 
    def register(self, widget, text):
        widget.ui_tooltip_text = text
        tags = list(widget.bindtags())
        tags.append(self.getcontroller(widget))
        widget.bindtags(tuple(tags))
 
    def unregister(self, widget):
        tags = list(widget.bindtags())
        tags.remove(self.getcontroller(widget))
        widget.bindtags(tuple(tags))
 
    # event handlers
 
    def enter(self, event):
        widget = event.widget
        if not self.label:
            # create and hide balloon help window
            self.popup = tk.Toplevel(bg=self.fg, bd=1)
            self.popup.overrideredirect(1)
            self.popup.withdraw()
            self.label = tk.Label(self.popup, fg=self.fg, bg=self.bg, bd=0, padx=2)
            self.label.pack()
            self.active = 0
        self.xy = event.x_root + 16, event.y_root + 10
        self.event_xy = event.x, event.y
        self.after_id = widget.after(200, self.display, widget)
 
    def display(self, widget):
        if not self.active:
            # display balloon help window
            text = widget.ui_tooltip_text
            if callable(text):
                text = text(widget, self.event_xy)
            self.label.config(text=text)
            self.popup.deiconify()
            self.popup.lift()
            self.popup.geometry("+%d+%d" % self.xy)
            self.active = 1
            self.after_id = None
 
    def leave(self, event):
        widget = event.widget
        if self.active:
            self.popup.withdraw()
            self.active = 0
        if self.after_id:
            widget.after_cancel(self.after_id)
            self.after_id = None
 
_manager = ToolTipManager()
 
##
# Registers a tooltip for a given widget.
#
# @param widget The widget object.
# @param text The tooltip text.  This can be either a string, or a callable
#     object. If callable, it is called as text(widget) when the tooltip is
#     about to be displayed, and the returned text is displayed instead.
 
def register(widget, text):
    _manager.register(widget, text)
 
##
# Unregisters a tooltip.  Note that the tooltip information is automatically
# destroyed when the widget is destroyed.
 
#def unregister(widget):
 #   _manager.unregister(widget)
 
#if __name__ == "__main__":
 
root = tk.Tk()
 
root.title("ToolTips")
 
b1 = tk.Label(root,font=40, text="?")
b1.pack()
 
register(b1, "A red button\nA red buttonA red buttonA red buttonA red button")
 
root.mainloop()

Merci d'avance.

Valentin.

[Julien N]

Et tout ces self, à quoi ils servent ?

Hmm. Là ça va poser quelques problèmes :-)
Je ne peux que te conseiller de passer quelques temps sur un bon tuto Python. La notion de self étant une base de ce que l'on appel la POO (pour Programmation Orientée Objet), je suppose que tu n'as pas encore pris le temps de te familiariser avec ce concept. Faire un programme Python avec interface graphique sans faire de la POO c'est possible, mais honnêtement je ne conseille pas du tout. Il y a sur ce site d'excellents tutos de répertoriés, en français (traduits ou rédigés directement par des membres) ou en Anglais.

J

[StabiloHB]

Bonjour,
Merci pour votre réponse.
Je suis désormais trop avancé dans mon programme pour changer la méthode d'écrire, il fonctionne plutot bien a par quelque bug que je regle au fur et à mesure avec vous sur developpez.net. Mais Je suis pleinement conscient que ma méthode n'est pas la plus optimisé, je me pencherai sur le sujet lors de mon prochain programme. Je vais utiliser le programme trouvé car je connais l'input et l'output après ce qu'il se passe entre ...

Merci pour votre temps en tout cas !
Bonne continuation.

Valentin