Bonjour,

Je travaille actuellement sur un petit projet sur python-3.x incluant des ressources tkinter. Mon programme est fait pour afficher sur un écran une liste d'images incluses dans un répertoire, chaque image est mise sur un bouton qui est 1/6 de l'image originale, et si on clique dessus, il affiche l'image sur sa taille originale sur une nouvelle fenêtre. La fenêtre d'origine est définie par le nombre d'images que je mets dans les colonnes (je peux choisir dans le code) et j'ai fait une barre de défilement car je dois travailler avec beaucoup d'images.

Mais voici mon problème, ça marche bien sauf que si je change la taille de la fenêtre, comme la réduire par exemple, les boutons ne suivent pas, ils disparaissent derrière la fenêtre, et avec la barre de défilement.

J'ai déjà réussi à récupérer la taille de l'image en direct à l'aide de callback .. je pense que c'est début mais après je ne sais pas comment faire pour que mes labels (les boutons)se déplacent en fonction de la taille de la fenetre et ne disparaissent pas. (que ce soit dynamique quoi ..)

Donc, j'aimerais faire en sorte que ce programme fonctionne comme un affichage de répertoire classique, avec les colonnes qui changent automatiquement quand on redimensionne la fenêtre et avec la barre de défilement qui la suit.
Si vous avez des solutions, cela m'aidera vraiment.
Vous pouvez l'essayer, il vous suffit de mettre quelques images jpeg dans un répertoire et de changer la variable dossier avec le lien de votre répertoire.

Merci d'avance pour votre aide, si vous avez des questions pour mieux comprendre ce que j'ai dit/codé, n'hésitez pas.

Voici mon code :

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
 
from tkinter import *
from tkinter.filedialog import *
from tkinter.messagebox import *
from PIL import Image, ImageTk
import tkinter as tk
import glob
import os
import cv2
import copy
import _thread
import time
 
folder = 'X:/users/Robin/data/dataset-valid/visu/*.jpg'
 
a=glob.glob(folder)
 
fic = "../data/list.txt"
 
fichObj=open(fic,"w")
 
p = []
 
for f in a:
    fichObj.write(f+"\n")
fichObj.close()
 
 
 
 
 
 
class SuperPhoto(object):
        def __init__(self, photo , image):
 
                self.photo = photo
                temp = cv2.resize(image, (int((self.photo.width())/6) , int((self.photo.height())/6))) 
                red = temp[:,:,2].copy()
                blue = temp[:,:,0].copy()
                temp[:,:,0] = red
                temp[:,:,2] = blue
                temp = Image.fromarray(temp)
                self.miniature = ImageTk.PhotoImage(temp)
 
        def agrandir(self):
                dataWin = open("../data/dataWin.txt", "r") 
                for line in dataWin:    
                        fields=line.split("+") 
                        coordX = fields[1]
                        coordY = fields[2]
 
                Newfen=Toplevel() 
                Newfen.geometry(f"+{coordX}+{coordY}")
 
                #self.photo.resize((500,500))
 
                def resize2(event):
                        Newfen.update_idletasks()
 
                        print(Newfen.winfo_width())
                        print(Newfen.winfo_height())
                        print(Newfen.geometry())
 
                        dataWin = open('../data/dataWin.txt','w')
                        dataWin.write(Newfen.geometry())
 
                print(type(self.photo))
                label = Label(Newfen, image=self.photo, width=self.photo.width(), height=self.photo.height())
                label.image = self.photo # keep a reference!
                label.pack()
                Newfen.bind('<Configure>', resize2)
 
if os.path.exists (fic):     #os.path utile 
        count = len(open(fic).readlines())    
        print(count)
        #lin = open(fic).readlines()
        #print(lin)
 
 
class ScrollableCanvas(Frame):
     def __init__(self, parent, *args, **kw):
        Frame.__init__(self, parent, *args, **kw)
 
        canvas=Canvas(self,bg='#FFFFFF',width=300,height=300,scrollregion=(0,0,500,500))
 
        canvas.update_idletasks() 
 
        vbar=Scrollbar(self,orient=VERTICAL)
        vbar.pack(side=RIGHT, fill=Y)
        vbar.config(command=canvas.yview)
 
        canvas.config(width=1200,height=700)
        canvas.config(yscrollcommand=vbar.set)
        canvas.pack(side=LEFT,expand=True,fill=BOTH)
 
        # create a frame inside the canvas which will be scrolled with it
        self.interior = interior = Frame(canvas)
        interior_id = canvas.create_window(0, 0, window=interior, anchor=NW )
 
        # track changes to the canvas and frame width and sync them,
        # also updating the scrollbar
        def _configure_interior(event):
            # update the scrollbars to match the size of the inner frame
            size = (interior.winfo_reqwidth(), interior.winfo_reqheight())
            canvas.config(scrollregion="0 0 %s %s" % size)
            if interior.winfo_reqwidth() != canvas.winfo_width():
                # update the canvas's width to fit the inner frame
                canvas.config(width=interior.winfo_reqwidth())
        interior.bind('<Configure>', _configure_interior)
 
        def _configure_canvas(event):
            if interior.winfo_reqwidth() != canvas.winfo_width():
                # update the inner frame's width to fill the canvas
                canvas.itemconfigure(interior_id, width=canvas.winfo_width())
        canvas.bind('<Configure>', _configure_canvas)
 
class Main_frame(Frame):
    # Init
    def __init__(self, fenetre_principale=None):
        Frame.__init__(self, fenetre_principale)
        self.grid()
        self.scrollable_canvas = ScrollableCanvas(self)
        self.scrollable_canvas.grid(row=1,column=1)         
 
        nbCol = 4
 
        for file in a:
                image = Image.open(file)
                photo = ImageTk.PhotoImage(image)
                w = photo.width()
                L.append(int(w/6))
                #print(L)
                sumL = int(sum(L)/nbCol)
 
                print(sumL)
 
                p.append(SuperPhoto(photo, cv2.imread(file)))
 
        for ligne in range(int(count/nbCol)):
                for colonne in range(nbCol):
                        photo = p[ligne * nbCol + colonne]    
                        button = Button(self.scrollable_canvas.interior, image=photo.miniature, command=photo.agrandir)
                        button.grid(row=ligne, column=colonne)
 
 
def resize(event):
    root.update_idletasks()
 
    print(root.winfo_width())
    print(root.winfo_height())
    print(root.geometry())
 
 
 
if __name__ == "__main__":
    root = Tk()
    root.title("VISU")
    root.geometry("+0+0")
    L= []
    root.bind('<Configure>', resize)
 
    interface = Main_frame(fenetre_principale=root)
    root.update_idletasks() 
    print(root.winfo_width())
    print(root.geometry())
    interface.mainloop()