MENU
  1. Accueil
  2. Python
  3. Comment gérer la taille et le redimensionnement des widgets en Python : Guide et exemples

Comment gérer la taille et le redimensionnement des widgets en Python : Guide et exemples

Python

Lors du développement d’une application GUI en Python, la gestion de la taille des widgets et de leur redimensionnement est un élément clé pour améliorer l’expérience utilisateur. Dans cet article, nous expliquerons en détail comment définir la taille des widgets et gérer leur redimensionnement en utilisant les principaux frameworks GUI de Python, Tkinter et PyQt. Des exemples de code concrets, des meilleures pratiques, des défis courants et leurs solutions seront présentés pour vous aider à acquérir des compétences pratiques.

Sommaire

Méthode de définition de la taille initiale des widgets

La définition de la taille initiale des widgets joue un rôle crucial dans la première impression que l’utilisateur aura lors de l’ouverture de l’application. Nous expliquerons comment définir la taille initiale des widgets dans les deux principaux frameworks GUI de Python, Tkinter et PyQt.

Définir la taille initiale dans Tkinter

Dans Tkinter, pour définir la taille d’un widget, on utilise les propriétés width et height. Voici un exemple de définition de la taille initiale d’un bouton dans Tkinter.

import tkinter as tk

root = tk.Tk()
root.geometry("300x200")  # Définir la taille initiale de la fenêtre

button = tk.Button(root, text="Cliquez ici", width=20, height=3)
button.pack()

root.mainloop()

Dans cet exemple, la taille de la fenêtre est définie sur 300×200 pixels, et la largeur du bouton est de 20 caractères, sa hauteur de 3 lignes.

Définir la taille initiale dans PyQt

Dans PyQt, les méthodes setFixedSize ou resize sont utilisées pour définir la taille d’un widget. Voici un exemple de définition de la taille initiale d’un bouton dans PyQt.

from PyQt5.QtWidgets import QApplication, QWidget, QPushButton

app = QApplication([])

window = QWidget()
window.setFixedSize(300, 200)  # Définir la taille initiale de la fenêtre

button = QPushButton('Cliquez ici', window)
button.resize(100, 50)  # Définir la taille du bouton
button.move(100, 75)    # Définir la position du bouton

window.show()
app.exec_()

Dans cet exemple, la taille de la fenêtre est définie à 300×200 pixels et la taille du bouton à 100×50 pixels. La position du bouton est également spécifiée.

Méthodes de redimensionnement des widgets

Le redimensionnement dynamique des widgets en fonction des actions de l’utilisateur est essentiel pour la création d’applications interactives. Ici, nous présenterons les méthodes de redimensionnement dans Tkinter et PyQt.

Redimensionnement dans Tkinter

Dans Tkinter, la méthode config est utilisée pour redimensionner un widget. Vous pouvez également configurer un gestionnaire d’événements pour capter le redimensionnement de la fenêtre.

import tkinter as tk

def resize_button(event):
    button.config(width=event.width // 10, height=event.height // 50)

root = tk.Tk()
root.geometry("300x200")  # Définir la taille initiale de la fenêtre

button = tk.Button(root, text="Cliquez ici", width=20, height=3)
button.pack(expand=True)

root.bind('<Configure>', resize_button)

root.mainloop()

Dans cet exemple, chaque fois que la taille de la fenêtre est modifiée, la fonction resize_button est appelée et la taille du bouton est redimensionnée en fonction de celle de la fenêtre.

Redimensionnement dans PyQt

Dans PyQt, la méthode resize est utilisée pour redimensionner un widget. Il est également possible de surcharger la méthode resizeEvent pour capturer l’événement de redimensionnement de la fenêtre.

from PyQt5.QtWidgets import QApplication, QWidget, QPushButton

class ResizeableWindow(QWidget):
    def __init__(self):
        super().__init__()
        self.initUI()

    def initUI(self):
        self.setGeometry(100, 100, 300, 200)  # Définir la taille initiale de la fenêtre
        self.button = QPushButton('Cliquez ici', self)
        self.button.resize(100, 50)  # Définir la taille initiale du bouton
        self.button.move(100, 75)    # Définir la position du bouton

    def resizeEvent(self, event):
        new_width = self.width() // 3
        new_height = self.height() // 4
        self.button.resize(new_width, new_height)

app = QApplication([])

window = ResizeableWindow()
window.show()
app.exec_()

Dans cet exemple, chaque fois que la taille de la fenêtre est modifiée, la méthode resizeEvent est appelée et la taille du bouton est redimensionnée dynamiquement en fonction de celle de la fenêtre.

Redimensionnement automatique des widgets

Nous expliquerons ici comment configurer un widget pour qu’il se redimensionne automatiquement en fonction de la taille de la fenêtre parente. Le redimensionnement automatique est un élément clé du design réactif.

Redimensionnement automatique dans Tkinter

Dans Tkinter, vous pouvez utiliser les gestionnaires de mise en page pack ou grid pour configurer un widget afin qu’il se redimensionne automatiquement en fonction de la taille de la fenêtre parente.

import tkinter as tk

root = tk.Tk()
root.geometry("400x300")  # Définir la taille initiale de la fenêtre

frame = tk.Frame(root)
frame.pack(fill=tk.BOTH, expand=True)  # Configurer le cadre pour qu'il suive la taille de la fenêtre parente

button1 = tk.Button(frame, text="Bouton 1")
button1.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)  # Configurer le bouton pour qu'il suive la taille du cadre

button2 = tk.Button(frame, text="Bouton 2")
button2.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)  # Configurer le bouton pour qu'il suive la taille du cadre

root.mainloop()

Dans cet exemple, les boutons et le cadre sont configurés avec le gestionnaire pack pour se redimensionner automatiquement en fonction de la taille de la fenêtre.

Redimensionnement automatique dans PyQt

Dans PyQt, vous pouvez utiliser QVBoxLayout ou QHBoxLayout pour configurer un widget afin qu’il se redimensionne automatiquement en fonction de la taille de la fenêtre parente.

from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout

app = QApplication([])

window = QWidget()
window.setWindowTitle('Exemple de redimensionnement automatique')
window.setGeometry(100, 100, 400, 300)  # Définir la taille initiale de la fenêtre

layout = QVBoxLayout()  # Créer une mise en page verticale

button1 = QPushButton('Bouton 1')
button2 = QPushButton('Bouton 2')

layout.addWidget(button1)  # Ajouter le bouton à la mise en page
layout.addWidget(button2)  # Ajouter l'autre bouton à la mise en page

window.setLayout(layout)  # Définir la mise en page de la fenêtre

window.show()
app.exec_()

Dans cet exemple, une mise en page verticale est utilisée pour ajouter des boutons qui se redimensionneront automatiquement en fonction de la taille de la fenêtre.

Meilleures pratiques pour la gestion de la taille

Nous allons maintenant présenter quelques meilleures pratiques pour gérer efficacement la taille des widgets. En suivant ces lignes directrices, vous pourrez créer des applications conviviales et réactives.

Adopter le design réactif

Concevez les widgets de manière à ce qu’ils s’adaptent à différentes tailles d’écran et résolutions. Utilisez des gestionnaires de mise en page et des propriétés de widget pour ajuster la taille des widgets automatiquement lors du redimensionnement de la fenêtre parente.

Utiliser des tailles relatives

Au lieu de spécifier des tailles en pixels, utilisez des tailles relatives. Par exemple, vous pouvez utiliser la propriété expand du gestionnaire pack dans Tkinter ou la QSizePolicy de PyQt.

Exemple : Spécification de tailles relatives dans Tkinter

import tkinter as tk

root = tk.Tk()
root.geometry("400x300")

frame = tk.Frame(root)
frame.pack(fill=tk.BOTH, expand=True)

button1 = tk.Button(frame, text="Bouton 1")
button1.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

button2 = tk.Button(frame, text="Bouton 2")
button2.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)

root.mainloop()

Exemple : Spécification de tailles relatives dans PyQt

from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout

app = QApplication([])

window = QWidget()
window.setGeometry(100, 100, 400, 300)

layout = QVBoxLayout()

button1 = QPushButton('Bouton 1')
button2 = QPushButton('Bouton 2')

layout.addWidget(button1)
layout.addWidget(button2)

window.setLayout(layout)
window.show()
app.exec_()

Utiliser la mise en page en grille

Pour organiser plusieurs widgets de manière ordonnée, utilisez une mise en page en grille. Avec le gestionnaire grid de Tkinter ou le QGridLayout de PyQt, la gestion de la disposition et de la taille des widgets devient plus facile.

Exemple : Mise en page en grille dans Tkinter

import tkinter as tk

root = tk.Tk()
root.geometry("400x300")

for i in range(3):
    for j in range(3):
        button = tk.Button(root, text=f"Bouton {i},{j}")
        button.grid(row=i, column=j, sticky="nsew")

for i in range(3):
    root.grid_columnconfigure(i, weight=1)
    root.grid_rowconfigure(i, weight=1)

root.mainloop()

Exemple : Mise en page en grille dans PyQt

from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QGridLayout

app = QApplication([])

window = QWidget()
window.setGeometry(100, 100, 400, 300)

layout = QGridLayout()

for i in range(3):
    for j in range(3):
        button = QPushButton(f'Bouton {i},{j}', window)
        layout.addWidget(button, i, j)

window.setLayout(layout)
window.show()
app.exec_()

Définir les tailles minimales/maximales

Définir la taille minimale et maximale des widgets permet de limiter la taille qu’un utilisateur peut donner à un widget, évitant ainsi des problèmes de mise en page.

Exemple : Définition des tailles minimales/maximales dans Tkinter

import tkinter as tk

root = tk.Tk()
root.geometry("400x300")
root.minsize(300, 200)
root.maxsize(600, 400)

label = tk.Label(root, text="Fenêtre redimensionnable")
label.pack(expand=True)

root.mainloop()

Exemple : Définition des tailles minimales/maximales dans PyQt

from PyQt5.QtWidgets import QApplication, QWidget, QLabel

app = QApplication([])

window = QWidget()
window.setGeometry(100, 100, 400, 300)
window.setMinimumSize(300, 200)
window.setMaximumSize(600, 400)

label = QLabel('Fenêtre redimensionnable', window)
label.setAlignment(Qt.AlignCenter)

window.show()
app.exec_()

En suivant ces meilleures pratiques, vous pouvez gérer efficacement la taille des widgets et créer une interface utilisateur conviviale et stable.

Exemples pratiques : Gestion de la taille des widgets avec Tkinter

Dans cette section, nous montrons comment gérer la taille des widgets en utilisant Tkinter, avec des exemples de code pratiques.

Définir la taille initiale de la fenêtre

Tout d’abord, nous définissons la taille initiale de la fenêtre et y plaçons plusieurs widgets.

import tkinter as tk

root = tk.Tk()
root.geometry("400x300")  # Définir la taille initiale de la fenêtre

label = tk.Label(root, text="Bonjour, Tkinter!", bg="lightblue")
label.pack(fill=tk.BOTH, expand=True)

button1 = tk.Button(root, text="Bouton 1")
button1.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

button2 = tk.Button(root, text="Bouton 2")
button2.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)

root.mainloop()

Dans cet exemple, la fenêtre est définie sur une taille de 400×300 pixels, avec un label et deux boutons disposés dans la fenêtre. Le gestionnaire pack est utilisé pour s’assurer que les widgets suivent la taille de la fenêtre.

Gestion de la taille avec une mise en page en grille

Ensuite, nous utilisons une mise en page en grille pour disposer les widgets et gérer leur taille.

import tkinter as tk

root = tk.Tk()
root.geometry("400x300")

for i in range(3):
    for j in range(3):
        button = tk.Button(root, text=f"Bouton {i},{j}")
        button.grid(row=i, column=j, sticky="nsew")

# Ajuster la taille des lignes et des colonnes automatiquement
for i in range(3):
    root.grid_columnconfigure(i, weight=1)
    root.grid_rowconfigure(i, weight=1)

root.mainloop()

Dans cet exemple, des boutons sont ajoutés dans une grille 3×3, et la taille des lignes et des colonnes est ajustée automatiquement lors du redimensionnement de la fenêtre.

Définir la taille minimale et maximale des widgets

Nous définissons la taille minimale et maximale des widgets pour nous assurer qu’ils se redimensionnent correctement lors du redimensionnement de la fenêtre.

import tkinter as tk

root = tk.Tk()
root.geometry("400x300")
root.minsize(300, 200)  # Définir la taille minimale
root.maxsize(600, 400)  # Définir la taille maximale

label = tk.Label(root, text="Fenêtre redimensionnable", bg="lightgreen")
label.pack(fill=tk.BOTH, expand=True)

root.mainloop()

Dans cet exemple, la taille minimale de la fenêtre est définie à 300×200 pixels et la taille maximale à 600×400 pixels. Le label se redimensionne automatiquement en fonction de la taille de la fenêtre.

Grâce à ces exemples pratiques, vous comprendrez les bases de la gestion de la taille des widgets dans Tkinter et pourrez créer des applications GUI flexibles et réactives.

Exemples pratiques : Gestion de la taille des widgets avec PyQt

Voici des exemples pratiques pour gérer la taille des widgets en utilisant PyQt.

Définir la taille initiale de la fenêtre

Tout d’abord, définissons la taille initiale de la fenêtre et y plaçons plusieurs widgets.

from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QPushButton, QVBoxLayout

app = QApplication([])

window = QWidget()
window.setWindowTitle('Exemple de gestion de la taille avec PyQt')
window.setGeometry(100, 100, 400, 300)  # Définir la taille initiale de la fenêtre

layout = QVBoxLayout()

label = QLabel('Bonjour, PyQt!', window)
label.setStyleSheet("background-color: lightblue;")
layout.addWidget(label)

button1 = QPushButton('Bouton 1', window)
layout.addWidget(button1)

button2 = QPushButton('Bouton 2', window)
layout.addWidget(button2)

window.setLayout(layout)
window.show()
app.exec_()

Dans cet exemple, nous définissons la taille de la fenêtre à 400×300 pixels et plaçons un label et deux boutons dans la fenêtre en utilisant une mise en page verticale.

Gestion de la taille avec une mise en page en grille

Ensuite, nous utilisons une mise en page en grille pour disposer les widgets et gérer leur taille.

from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QGridLayout

app = QApplication([])

window = QWidget()
window.setWindowTitle('Exemple de mise en page en grille avec PyQt')
window.setGeometry(100, 100, 400, 300)

layout = QGridLayout()

for i in range(3):
    for j in range(3):
        button = QPushButton(f'Bouton {i},{j}', window)
        layout.addWidget(button, i, j)

window.setLayout(layout)
window.show()
app.exec_()

Dans cet exemple, nous utilisons une grille 3×3 pour organiser les boutons. Chaque bouton est ajouté à une cellule et la mise en page en grille permet à la taille des boutons de s’ajuster automatiquement.

Définir les tailles minimales/maximales des widgets

Nous définissons la taille minimale et maximale des widgets pour nous assurer qu’ils se redimensionnent correctement lors du redimensionnement de la fenêtre.

from PyQt5.QtWidgets import QApplication, QWidget, QLabel

app = QApplication([])

window = QWidget()
window.setWindowTitle('Exemple de taille min/max avec PyQt')
window.setGeometry(100, 100, 400, 300)
window.setMinimumSize(300, 200)  # Définir la taille minimale
window.setMaximumSize(600, 400)  # Définir la taille maximale

label = QLabel('Fenêtre redimensionnable', window)
label.setAlignment(Qt.AlignCenter)
label.setStyleSheet("background-color: lightgreen;")

layout = QVBoxLayout()
layout.addWidget(label)
window.setLayout(layout)

window.show()
app.exec_()

Dans cet exemple, nous définissons la taille minimale de la fenêtre à 300×200 pixels et la taille maximale à 600×400 pixels. Le label se redimensionne automatiquement en fonction de la taille de la fenêtre.

Ces exemples pratiques vous aideront à comprendre les bases de la gestion de la taille des widgets dans PyQt et à créer des applications GUI flexibles et réactives.

Problèmes courants et solutions pour la gestion de la taille

Il existe plusieurs défis courants lors de la gestion de la taille des widgets. Nous allons discuter des problèmes typiques et de leurs solutions.

Problème 1 : Les widgets de taille fixe perturbent la mise en page

Les widgets de taille fixe peuvent causer des problèmes de mise en page lorsque la fenêtre est redimensionnée. Ce problème peut être résolu en utilisant des tailles relatives ou le redimensionnement automatique.

Solution

Utilisez des tailles relatives et configurez les widgets pour qu’ils s’ajustent automatiquement à la taille de la fenêtre parente. Dans Tkinter, vous pouvez utiliser l’option expand du gestionnaire pack, et dans PyQt, vous pouvez utiliser QSizePolicy.

Problème 2 : Les contraintes de taille minimale/maximale des widgets

Lorsque les widgets dépassent leur taille minimale ou maximale, l’interface peut devenir difficile à utiliser.

Solution

Définissez correctement les tailles minimales et maximales des widgets pour éviter qu’ils ne deviennent trop petits ou trop grands lors du redimensionnement.

Problème 3 : Difficulté d’implémentation d’un design réactif

Implémenter un design réactif adapté à différentes tailles d’écrans et appareils peut être complexe, avec des widgets qui ne se redimensionnent pas correctement.

Solution

Utilisez les gestionnaires de mise en page et capturez les événements de redimensionnement pour ajuster dynamiquement la taille des widgets selon la taille de la fenêtre.

Problème 4 : Problèmes de mise à l’échelle sur les écrans haute résolution

Sur les écrans haute résolution, les widgets peuvent apparaître plus petits que prévu.

Solution

Configurez les frameworks GUI pour prendre en charge les écrans haute résolution. Par exemple, dans PyQt, vous pouvez activer la mise à l’échelle haute DPI avec QApplication.setAttribute(Qt.AA_EnableHighDpiScaling).

from PyQt5.QtWidgets import QApplication, QWidget, QLabel
from PyQt5.QtCore import Qt

app = QApplication([]) 
app.setAttribute(Qt.AA_EnableHighDpiScaling, True)  # Activer la mise à l'échelle haute DPI

window = QWidget()
window.setGeometry(100, 100, 400, 300)

label = QLabel('Exemple de mise à l'échelle haute DPI', window)
label.setAlignment(Qt.AlignCenter)
window.show()

app.exec_()

Problème 5 : Calcul de la mise en page lent

Lorsque la mise en page est complexe ou contient de nombreux widgets, le recalcul de la mise en page peut devenir lent lors du redimensionnement.

Solution

Choisissez des gestionnaires de mise en page efficaces et évitez de recalculer la mise en page inutilement. Vous pouvez également réduire le nombre de widgets ou simplifier la mise en page.

En appliquant ces solutions, vous pouvez résoudre les problèmes courants liés à la gestion de la taille des widgets et créer des applications GUI stables et conviviales.

Exemple avancé : Conception GUI réactive

La conception GUI réactive est essentielle pour s’adapter à différents appareils et tailles d’écrans. Voici un exemple de conception réactive de GUI avec Tkinter et PyQt.

Conception GUI réactive avec Tkinter

Pour concevoir une GUI réactive avec Tkinter, configurez les widgets pour qu’ils se redimensionnent automatiquement en fonction de la taille de la fenêtre. Voici un exemple de conception réactive de GUI avec Tkinter.

import tkinter as tk

root = tk.Tk()
root.geometry("600x400")  # Définir la taille initiale de la fenêtre

frame = tk.Frame(root)
frame.pack(fill=tk.BOTH, expand=True)

label = tk.Label(frame, text="Label réactif", bg="lightblue")
label.pack(fill=tk.BOTH, expand=True)

button1 = tk.Button(frame, text="Bouton 1")
button1.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

button2 = tk.Button(frame, text="Bouton 2")
button2.pack(side=tk.RIGHT, fill=tk.BOTH, expand=True)

root.mainloop()

Dans cet exemple, lorsque la taille de la fenêtre change, le cadre ainsi que le label et les boutons à l’intérieur se redimensionnent automatiquement. Les options fill et expand du gestionnaire pack permettent aux widgets de suivre la taille de la fenêtre parente.

Conception GUI réactive avec PyQt

Pour concevoir une GUI réactive avec PyQt, utilisez les gestionnaires de mise en page pour que les widgets se redimensionnent automatiquement en fonction de la taille de la fenêtre parente. Voici un exemple de conception réactive de GUI avec PyQt.

from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QVBoxLayout, QHBoxLayout

app = QApplication([])

window = QWidget()
window.setWindowTitle('Exemple réactif PyQt')
window.setGeometry(100, 100, 600, 400)  # Définir la taille initiale de la fenêtre

main_layout = QVBoxLayout(window)

top_layout = QHBoxLayout()
bottom_layout = QHBoxLayout()

label = QPushButton('Label réactif', window)
label.setStyleSheet("background-color: lightblue;")
top_layout.addWidget(label)

button1 = QPushButton('Bouton 1', window)
bottom_layout.addWidget(button1)

button2 = QPushButton('Bouton 2', window)
bottom_layout.addWidget(button2)

main_layout.addLayout(top_layout)
main_layout.addLayout(bottom_layout)

window.setLayout(main_layout)
window.show()
app.exec_()

Dans cet exemple, nous utilisons une combinaison de QVBoxLayout et QHBoxLayout pour organiser les widgets et garantir qu’ils se redimensionnent automatiquement en fonction de la taille de la fenêtre.

Meilleures pratiques pour la conception réactive

Voici quelques meilleures pratiques pour concevoir une GUI réactive.

1. Utiliser des mises en page flexibles

Configurez les tailles et positions des widgets de manière relative, évitant ainsi les tailles fixes. Utilisez des gestionnaires de mise en page pour créer des mises en page dynamiques qui s’ajustent à la taille de la fenêtre.

2. Définir les tailles minimales et maximales

Définissez les tailles minimales et maximales des widgets pour éviter qu’ils deviennent trop petits ou trop grands, ce qui améliore la cohérence de la mise en page et la convivialité.

3. Utiliser des requêtes média

Inspirez-vous des techniques de design réactif du web et effectuez des changements de mise en page ou de style en fonction de la taille ou de la résolution de l’écran. Cela permet de créer des designs plus flexibles.

Résumé

La conception GUI réactive est essentielle pour améliorer l’expérience utilisateur. En utilisant Tkinter ou PyQt, vous pouvez concevoir des interfaces flexibles où la taille et la position des widgets changent dynamiquement. En suivant les meilleures pratiques et en intégrant des designs réactifs, vous pourrez créer des applications adaptées à différents appareils et tailles d’écrans.

Exercices : Gestion de la taille des widgets

Voici des exercices pour vous aider à approfondir votre compréhension de la gestion de la taille des widgets. Résoudre ces exercices vous permettra de renforcer vos compétences pratiques.

Exercice 1 : Réponse au redimensionnement de la fenêtre dans Tkinter

Créez une application Tkinter qui répond aux conditions suivantes :

  • Définissez la taille initiale de la fenêtre à 600×400 pixels.
  • Lorsque la fenêtre est redimensionnée, les boutons et le label doivent se redimensionner automatiquement.
import tkinter as tk

root = tk.Tk()
root.geometry("600x400")  # Définir la taille initiale de la fenêtre

frame = tk.Frame(root)
frame.pack(fill=tk.BOTH, expand=True)

label = tk.Label(frame, text="Label réactif", bg="lightblue")
label.pack(fill=tk.BOTH, expand=True)

button = tk.Button(frame, text="Bouton réactif")
button.pack(fill=tk.BOTH, expand=True)

root.mainloop()

Utilisez ce code pour que les widgets se redimensionnent correctement.

Exercice 2 : Mise en page en grille avec PyQt

Créez une application PyQt qui répond aux conditions suivantes :

  • Définissez la taille initiale de la fenêtre à 600×400 pixels.
  • Disposez les boutons dans une grille 3×3, et redimensionnez-les automatiquement lorsque la fenêtre change de taille.
from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QGridLayout

app = QApplication([])

window = QWidget()
window.setWindowTitle('Exemple de mise en page en grille')
window.setGeometry(100, 100, 600, 400)

layout = QGridLayout()

for i in range(3):
    for j in range(3):
        button = QPushButton(f'Bouton {i},{j}', window)
        layout.addWidget(button, i, j)

window.setLayout(layout)
window.show()
app.exec_()

Utilisez ce code pour ajuster la taille des boutons automatiquement en fonction de la taille de la fenêtre.

Exercice 3 : Définir les tailles minimales et maximales

Créez une application qui respecte les conditions suivantes :

  • Définissez la taille minimale de la fenêtre à 300×200 pixels et la taille maximale à 800×600 pixels.
  • Les labels doivent se redimensionner en fonction de la taille de la fenêtre.

Exemple avec Tkinter :

import tkinter as tk

root = tk.Tk()
root.geometry("600x400")
root.minsize(300, 200)
root.maxsize(800, 600)

label = tk.Label(root, text="Fenêtre redimensionnable", bg="lightgreen")
label.pack(fill=tk.BOTH, expand=True)

root.mainloop()

Exemple avec PyQt :

from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QVBoxLayout
from PyQt5.QtCore import Qt

app = QApplication([])

window = QWidget()
window.setWindowTitle('Exemple de taille min/max')
window.setGeometry(100, 100, 600, 400)
window.setMinimumSize(300, 200)
window.setMaximumSize(800, 600)

label = QLabel('Fenêtre redimensionnable', window)
label.setAlignment(Qt.AlignCenter)
label.setStyleSheet("background-color: lightgreen;")

layout = QVBoxLayout()
layout.addWidget(label)
window.setLayout(layout)

window.show()
app.exec_()

Utilisez ces exemples pour définir les tailles minimales et maximales des widgets et les faire se redimensionner correctement.

Résumé

La gestion de la taille des widgets est un élément clé de la programmation GUI en Python. Cet article vous a montré comment définir la taille initiale des widgets, gérer leur redimensionnement et leur redimensionnement automatique en utilisant Tkinter et PyQt. Nous avons également discuté des défis courants et des meilleures pratiques pour la conception réactif. En pratiquant ces exercices, vous approfondirez vos compétences en gestion de la taille des widgets et créerez des applications GUI flexibles adaptées à différents appareils et tailles d’écran.

Python
Python Redimensionnement tkinter Développement GUI Widget Gestion des Tailles Design Réactif PyQt Gestionnaire de Mise en Page Événement de Redimensionnement
Sommaire