Tkinter - Image qui se balade sur le bureau

**gadgetroch** · 18/03/2013, 19h35

Bonjour,

j'aurais voulu savoir si il était possible de faire un programme tkinter qui affiche une image sur le bureau, tel mouton.exe, pour ceux qui connaissent.

En gros une image transparente, sans fenetre.

**PauseKawa** · 18/03/2013, 19h49

Bonjour,

Techniquement non : la transparence s'applique à tous les objets de la fenêtre.

@+

**wiztricks** · 19/03/2013, 11h06

Salut,

Envoyé par PauseKawa

Techniquement non : la transparence s'applique à tous les objets de la fenêtre.

Certes mais une image transparente qui se balade peut être construite avec un Toplevel (sans "bords"), Canvas, .create_image, ou autre widget qui permette de "remplir" la Toplevel. Puis on applique transparence et déplacements au Toplevel.

- W

**PauseKawa** · 19/03/2013, 21h40

Bonsoir wiztricks,

Un exemple ?
J'ai beau jouer avec alpha sur un toplevel mais rien n'y fait : La transparence reste égale. Ce qui est normal.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import Tkinter as tk  # import tkinter as tk > pour Python 3.x
 
 
root = tk.Tk()
root.withdraw()
top = tk.Toplevel(root)
can = tk.Canvas(top)
im = tk.PhotoImage(file="image.gif")  # image.gif a remplacer
can.create_image(0, 0, image=im)
can.pack()
top.bind('<Button-1>', lambda e: root.destroy())
top.overrideredirect(1)
top.attributes("-alpha", 0.5)
root.mainloop()

Elle est ou l'idée ?

Merci d'avance

**PauseKawa** · 20/03/2013, 07h49

Bonjour,

A vrais dire la seul moyen que je vois c'est de faire un grab de l'écran (Le sujet est déjà débattu plusieurs fois : faire une recherche sur le forum.) et d’insérer l'image dans un canvas.
Le but ensuite et de dimensionner la fenêtre, sans bordure, aux dimensions de l'animation et de se déplacer dans le Canvas (scroll) et même temps que l'on déplace la fenêtre.
Le tout est de faire un grab à intervalle régulier pour avoir quelque chose de proche de ce qui est à l'écran.
La difficulté est qu'un grab prend du temps : Il vas falloir en prendre compte et le traiter 'à part'.
C'est sans doute 'du bricolage' mais je ne vois pas comment appliquer un alpha de 1.0 sur un objet (d'un Canvas ou autre) alors que le reste de l'application a un alpha de 0.0.

@+

**wiztricks** · 20/03/2013, 14h26

Salut,

Envoyé par PauseKawa

J'ai beau jouer avec alpha sur un toplevel mais rien n'y fait : La transparence reste égale. Ce qui est normal.

Je viens de faire le test sous Windows.
Lorsque je modifie l'alpha du Toplevel, la transparence de l'image suit: "normal"?!?
La différence est que j'ai utilisé PIL.ImageTk.PhotoImage (pas de .GIF dans le coin).
Je n'ai pas le temps de tester plus cet am.
- W

**fred1599** · 22/03/2013, 13h11

Je viens de faire le test sous Windows

C'est peut-être là le problème

Envoyé par doc

alpha=
(Windows, Mac) Controls window transparency. 0.0 means fully transparent, 1.0 means fully opaque. This isn’t supported on all systems; where not supported, Tkinter always uses 1.0. Note that in this release, this attribute must be given as “-alpha”.

**PauseKawa** · 22/03/2013, 20h25

Envoyé par fred1599

C'est peut-être là le problème

Ce n'est pas ce que j'ai compris dans

Envoyé par wiztricks

Je viens de faire le test sous Windows.
Lorsque je modifie l'alpha du Toplevel, la transparence de l'image suit: "normal"?!?
La différence est que j'ai utilisé PIL.ImageTk.PhotoImage (pas de .GIF dans le coin).

La méthode wm_attributes/attributes des toplevels (Toplevel/Instance Tk et exclusivement eux puisque l'on touche au WM) s'applique à la totalité des objets de celui-ci. En passant par PIL.ImageTk l'image en deviens un.
La transparence (alpha) est aussi dépendante du matériel: Cela m'étonnerais que sur une station de travail Xéon à propulsion turbonucléaire mais sur une carte mère chipset serveur et donc une 'matrox 32 Mo' en carte graphique cela tourne... De même si la carte n'est pas bien reconnue.
alpha est dans ce cas ignoré.
A noter que

alpha=
(Windows, Mac)

Cela fonctionne sous Tux avec compiz/beryl.

Ma proposition est elle si 'bricolage' que personne ne la commente ?

@+

**wiztricks** · 23/03/2013, 20h14

Salut,

Envoyé par PauseKawa

Ma proposition est elle si 'bricolage' que personne ne la commente ?

Ca doit être très bien mais je n'ai toujours pas compris pourquoi faire un grab de l'écran dans ce cas là.

- W

**PauseKawa** · 23/03/2013, 21h53

Ben en fait l'idée (rapidement) est celle ci:

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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#
#
import sys
import os
import Tkinter as tk
import Image, ImageTk
 
 
IMDATA = """R0lGODlhIAAgAOfVAAoKCgsLCwwMDA8PDxAQEBERERISEhcXFxgYGBkZGRoaGhwcHB0dHR8fHyEh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"""
SENSE = "DOWN"
 
 
class ScreenCap(object):
    def __init__(self):
        """Screenshot class"""
        if sys.platform == 'linux2':
            self.grab = self._GarbLinux
        elif sys.platform == 'win32':
            import Image, ImageGrab
            self.grab = self._GrabWin
        elif sys.platform == 'darwin':
            self.grab = self._GrabMac
        else:
            sys.exit(1)
        self._currentf = None
 
    def _FicNormalyze(self, name):
        """Internal Function for generate temp file.
           Use home user directory for rights.
        """
        if name:
            if os.path.basename(name) == name:
                _grabfile = os.path.join(os.path.expanduser('~'), name)
            else:
                _grabfile = name
        else:
            # default name
            _grabfile = os.path.join(os.path.expanduser('~'), 'scrcap.jpg')
        self._currentf = _grabfile
        return _grabfile
 
    def _GarbLinux(self, name=None):
        """Internal function for screen capture under Linux
           Use ImageMagick import utility
        """
        _grabfile = self._FicNormalyze(name)
        _grabcommand = "import -silent -window root " + _grabfile
        os.system(_grabcommand)
        return _grabfile
 
    def _GrabWin(self, name=None):
        """Internal function for screen capture under Windows.
           Use PIL ImageGrab.
        """
        try:
            import ImageGrab
        except:
            # Experimental import for PIL under Python 3.
            from PIL import ImageGrab
        _grabfile = self._FicNormalyze(name)
        ImageGrab.grab().save(_grabfile, "JPEG")
        return _grabfile
 
    def _GrabMac(self, name=None):
        """Internal function for screen capture under Mac.
           Use screencapture command.
        """
        _grabfile = self._FicNormalyze(name)
        _grabcommand = "screencapture -m -x -t jpg " + _grabfile
        os.system(_grabcommand)
        return _grabfile
 
    def delete(self):
        """Internal function. Delete temp file."""
        if os.path.isfile(self._currentf):
            os.remove(self._currentf)
 
 
def anime():
    global SENSE
    for i in range(top.winfo_screenwidth()-H):
        imcoords = canvas.coords(ball)
        if not i % 3:
            canvas.xview("scroll", 1, "units")
        if SENSE == "DOWN":
            canvas.coords(ball, (imcoords[0]+1, imcoords[1]+1))  #  canvas.move() ?
            if int(canvas.coords(ball)[1]) >= H*4:
                SENSE = "UP"
        else:
            canvas.coords(ball, (imcoords[0]+1, imcoords[1]-1))
            if int(canvas.coords(ball)[1]) <= 0:
                SENSE = "DOWN"
        top.geometry("%dx%d+%d+0" % (W, H*5, i))
        top.update()
        top.after(5)
    top.destroy()
    sys.exit()
 
 
root = tk.Tk()
root.title('Ball')
tk.Button(root, text='Done', command=root.destroy).pack()
root.iconify()
root.update()
top = tk.Toplevel(master=root)
top.withdraw()
Sccap = ScreenCap()
canvas = tk.Canvas(top, width=top.winfo_screenwidth(),
              height=top.winfo_screenheight(), bd=0,
              highlightthickness=0)
screencapture = Image.open(Sccap.grab(name='scrcap.jpg'))
photo = ImageTk.PhotoImage(screencapture)
fond = canvas.create_image(0, 0, image=photo, anchor='nw')
Sccap.delete()
canvas.config(scrollregion=canvas.bbox('all'), yscrollincrement='1')
anim = tk.PhotoImage(data=IMDATA)
W = anim.width()
H = anim.height()
ball = canvas.create_image(0, 0, image=anim, anchor='nw')
canvas.pack(fill='both')
top.geometry("%dx%d+0+0" % (W, H*5))
top.update()
top.overrideredirect(1)
top.deiconify()
top.attributes("-topmost", 1)
root.after(1, anime)
root.mainloop()

La code de capture est un copier/coller du forum.
A noter que sous Windows/Linux il est possible d'utiliser bbox/des coordonnées pour limiter la capture à une zone. Je ne pense pas, dans la limite de mes connaissances, que cela soit possible avec screencapture sous mac.
Les difficultés ici sont :
Synchroniser le scroll du Canvas avec la position sur l'écran. Soit remplacer if not i % 3 dans le code par la correspondance des coordonnées écran/Canvas.
Déplacer le Toplevel sans .update() ou réduire les effets de bordure produits dans le cadre d'un overrideredirect.
Faire une mise à jour de l'image 'fond' (l'item 1 du Canvas) en arrière plan sans ralentir l'animation. Et ce avec un canvas.tag_lower(ball)/canvas.tag_raise(ball) lors de la 'capture' pour ne pas avoir une 'persistance'/'traînée' de l'image gif.

Ici j'ai choisi un gif mais dans ce cas n'importe quelle animation dans le Canvas fonctionne.

@+

**PauseKawa** · 24/03/2013, 10h28

Une autre application (sans animation) de la 'chose' au passage.

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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#
#
import sys
import os
import Tkinter as tk
import Image, ImageTk
 
IMDATA = """R0lGODlhrwNqA6ECAAAAAPb3+P///////yH5BAEAAAMALAAAAACvA2oDAAL+nI+py+0Po5y02ouz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"""
 
 
class ScreenCap(object):
    def __init__(self):
        if sys.platform == 'linux2':
            self.grab = self._GarbLinux
        elif sys.platform == 'win32':
            import Image, ImageGrab
            self.grab = self._GrabWin
        elif sys.platform == 'darwin':
            self.grab = self._GrabMac
        else:
            sys.exit(1)
        self._currentf = None
 
    def _FicNormalyze(self, name):
        if name:
            if os.path.basename(name) == name:
                _grabfile = os.path.join(os.path.expanduser('~'), name)
            else:
                _grabfile = name
        else:
            # default name
            _grabfile = os.path.join(os.path.expanduser('~'), 'scrcap.jpg')
        self._currentf = _grabfile
        return _grabfile
 
    def _GarbLinux(self, name=None, bbox=None):
        _grabfile = self._FicNormalyze(name)
        _crop = ""
        if bbox:
            _crop = "-crop %dx%d+%d+%d " % (bbox[2]-bbox[0],
                                            bbox[3]-bbox[1],
                                            bbox[0], bbox[1])
        _grabcommand = "import -silent -window root %s%s" % (_crop, _grabfile)
        os.system(_grabcommand)
        return _grabfile
 
    def _GrabWin(self, name=None, bbox=None):
        try:
            import ImageGrab
        except:
            from PIL import ImageGrab
        _grabfile = self._FicNormalyze(name)
        ImageGrab.grab(bbox).save(_grabfile, "JPEG")
        return _grabfile
 
    def _GrabMac(self, name=None, bbox=None):
        _crop = ""
        if bbox:
            pass  # :/
        _grabfile = self._FicNormalyze(name)
        _grabcommand = "screencapture -m -x %s-t jpg %s" % (_crop, _grabfile)
        os.system(_grabcommand)
        return _grabfile
 
    def delete(self):
        if os.path.isfile(self._currentf):
            os.remove(self._currentf)
 
 
root = tk.Tk()
root.title('App')
im = tk.PhotoImage(data=IMDATA)
imw = im.width()
imh = im.height()
box = ((root.winfo_screenwidth()-imw)/2,
       (root.winfo_screenheight()-imh)/2,
       imw+(root.winfo_screenwidth()-imw)/2,
       imh+(root.winfo_screenheight()-imh)/2)
tk.Button(root, text='Done', command=root.destroy).pack()
root.iconify()
splash = tk.Toplevel(master=root)
splash.withdraw()
Sccap = ScreenCap()
canvas = tk.Canvas(splash, width=imw, height=imh, bd=0,
                   highlightthickness=0)
screencapture = Image.open(Sccap.grab(name='scrcap.jpg', bbox=box))
photo = ImageTk.PhotoImage(screencapture)
fond = canvas.create_image(0, 0, image=photo, anchor='nw')
Sccap.delete()
bhzd = canvas.create_image(0, 0, image=im, anchor='nw')
canvas.pack(fill='both')
splash.geometry("%dx%d+%d+%d" % (imw, imh, box[0], box[1]))
texte = canvas.create_text(imw/2, imh/2+50, anchor='center',
                           fill="yellow", text="ENTER", width=100,
                           activefill="red", font="Helvetica")
canvas.tag_bind(texte, "<Button-1>",
                lambda e: splash.destroy() or root.deiconify())
splash.update()
splash.overrideredirect(1)
splash.deiconify()
splash.attributes("-topmost", 1)
root.mainloop()

Il est bien sur possible de ne pas utiliser create_image mais un create_oval par exemple : Cela ouvre la perspective d'avoir des fenêtres non rectangle et ce quelque soit le système et ses possibilités.

**PauseKawa** · 24/03/2013, 22h45

Bonsoir,

Une animation pour le po quand même...

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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#
#
import sys
import os
import Tkinter as tk
import Image, ImageTk
import base64
 
 
ANIGIF = """R0lGODlhyABkAPMAAAAAAACAuff396GhoV1dXf+ZmallVvqZZmY0Mx0bGAAAAAAAAAAAAAAAAAAA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"""
 
 
class ScreenCap(object):
    def __init__(self):
        if sys.platform == 'linux2':
            self.grab = self._GarbLinux
        elif sys.platform == 'win32':
            import Image, ImageGrab
            self.grab = self._GrabWin
        elif sys.platform == 'darwin':
            self.grab = self._GrabMac
        else:
            sys.exit(1)
        self._currentf = None
 
    def _FicNormalyze(self, name):
        if name:
            if os.path.basename(name) == name:
                _grabfile = os.path.join(os.path.expanduser('~'), name)
            else:
                _grabfile = name
        else:
            # default name
            _grabfile = os.path.join(os.path.expanduser('~'), 'scrcap.jpg')
        self._currentf = _grabfile
        return _grabfile
 
    def _GarbLinux(self, name=None, bbox=None):
        _grabfile = self._FicNormalyze(name)
        _crop = ""
        if bbox:
            _crop = "-crop %dx%d+%d+%d " % (bbox[2]-bbox[0],
                                            bbox[3]-bbox[1],
                                            bbox[0],
                                            bbox[1])
        _grabcommand = "import -silent -window root %s%s" % (_crop, _grabfile)
        os.system(_grabcommand)
        return _grabfile
 
    def _GrabWin(self, name=None, bbox=None):
        try:
            import ImageGrab
        except:
            from PIL import ImageGrab
        _grabfile = self._FicNormalyze(name)
        ImageGrab.grab(bbox).save(_grabfile, "JPEG")
        return _grabfile
 
    def _GrabMac(self, name=None, bbox=None):
        _crop = ""
        if bbox:
            pass  # :/
        _grabfile = self._FicNormalyze(name)
        _grabcommand = "screencapture -m -x %s-t jpg %s" % (_crop, _grabfile)
        os.system(_grabcommand)
        return _grabfile
 
    def delete(self):
        if os.path.isfile(self._currentf):
            os.remove(self._currentf)
 
 
def anim():
    global index, afterevent
    imcoords = canvas.coords(cochon)
    imcoords[0] += 10
    canvas.coords(cochon, (imcoords[0], imcoords[1]))
    canvas.itemconfig(cochon, image=frames[index])
    index += 1
    if index == len(frames):
        index = 0
    afterevent = root.after(delay, anim)
    if imcoords[0] >= imw:
        onexit()
 
 
def onexit(e=None):
    root.after_cancel(afterevent)
    splash.destroy()
    if os.path.isfile('anim.gif'):
        os.remove('anim.gif')
    root.deiconify()
 
 
root = tk.Tk()
root.title('Demo')
with open('anim.gif', 'wb') as f:
    f.write(base64.decodestring(ANIGIF))
with open('anim.gif', 'rb') as f:
    im = Image.open(f)
    seq =  []
    try:
        while 1:
            seq.append(im.copy())
            im.seek(len(seq))
    except EOFError:
        pass
    try:
        delay = im.info['duration']
    except KeyError:
        delay = 100
    first = seq[0].convert('RGBA')
    frames = [ImageTk.PhotoImage(first)]
    imw = root.winfo_screenwidth()
    imh = frames[0].height()
    temp = seq[0]
    for image in seq[1:]:
        temp.paste(image)
        frame = temp.convert('RGBA')
        frames.append(ImageTk.PhotoImage(frame))
index = 0
box = (0, 0, imw, imh)
tk.Button(root, text='Done', command=root.destroy).pack(fill='both',
                                                        padx=10,
                                                        pady=10)
root.iconify()
splash = tk.Toplevel(master=root)
splash.withdraw()
Sccap = ScreenCap()
canvas = tk.Canvas(splash, width=imw, height=imh,
                   bd=0, highlightthickness=0)
screencapture = Image.open(Sccap.grab(name='scrcap.jpg', bbox=box))
photo = ImageTk.PhotoImage(screencapture)
fond = canvas.create_image(0, 0, image=photo, anchor='nw')
Sccap.delete()
cochon = canvas.create_image(0, 0, image=frames[0], anchor='nw')
canvas.pack(fill='both')
splash.geometry("%dx%d+%d+%d" % (imw, imh, box[0], box[1]))
splash.bind('<Button-1>', onexit)
splash.update()
splash.overrideredirect(1)
splash.deiconify()
splash.attributes("-topmost", 1)
root.protocol("WM_DELETE_WINDOW", onexit)
root.after(1, anim)
root.mainloop()

@+

Edit : Par contre si vous trouvez comment faire avec alpha je prend.

Tkinter - Image qui se balade sur le bureau

Tkinter Python

Discussions similaires

Partager

Partager