MENU
  1. Accueil
  2. Python
  3. Guide détaillé pour capturer les événements de souris et clavier avec Tkinter

Guide détaillé pour capturer les événements de souris et clavier avec Tkinter

Python

Tkinter est un kit d’outils très pratique pour développer des applications GUI en Python. Ce guide explique en détail comment obtenir les événements de la souris et du clavier en utilisant Tkinter. Il couvre des sujets allant de la configuration de base, des exemples d’applications spécifiques, jusqu’à des exercices pratiques, fournissant ainsi des connaissances utiles pour le développement réel.

Sommaire

Configuration de base de Tkinter et méthode d’installation

Tkinter est intégré par défaut dans Python, ce qui signifie qu’aucune installation supplémentaire n’est nécessaire. Cependant, nous expliquerons comment vérifier la version et comment l’installer si Tkinter n’est pas inclus.

Vérification de la version de Tkinter

Pour vérifier si Tkinter est installé, exécutez la commande suivante :

import tkinter as tk
print(tk.TkVersion)

Si cette commande renvoie une version, cela signifie que Tkinter est correctement installé.

Installation de Python et de Tkinter

Si Tkinter n’est pas installé, suivez les étapes ci-dessous pour l’installer.

Installation de Python

Téléchargez et installez la dernière version de Python depuis le site officiel. Assurez-vous de cocher l’option « Ajouter Python au PATH » pendant l’installation.

Installation de Tkinter

Généralement, lorsque vous installez Python, Tkinter est installé automatiquement. Toutefois, si ce n’est pas le cas, vous pouvez l’installer avec la commande suivante :

sudo apt-get install python3-tk

Pour les utilisateurs de Windows, vous pouvez résoudre ce problème en réinstallant Python ou en ajoutant le répertoire Python à la variable d’environnement PATH.

Création d’une application Tkinter simple

Exécutez le code suivant pour vérifier que la fenêtre Tkinter s’affiche correctement.

import tkinter as tk

root = tk.Tk()
root.title("Configuration de base de Tkinter")
root.geometry("300x200")

label = tk.Label(root, text="Bonjour, Tkinter !")
label.pack(pady=20)

root.mainloop()

Ce code crée une fenêtre Tkinter de base affichant le message « Bonjour, Tkinter ! ». À partir de là, vous avez terminé la configuration de base de Tkinter.

Obtention des événements de la souris

Ce chapitre décrit comment obtenir les événements de la souris en utilisant Tkinter. Nous allons aborder les événements tels que les clics, les déplacements, et les glissements de la souris.

Obtention des événements de clic de la souris

Pour obtenir les événements de clic de la souris, vous devez lier un événement à un widget. L’exemple suivant capture un clic gauche et affiche un message avec les coordonnées du clic.

import tkinter as tk

def on_left_click(event):
    print("Clic gauche à", event.x, event.y)

root = tk.Tk()
root.title("Événement de clic de la souris")

frame = tk.Frame(root, width=300, height=200)
frame.bind("", on_left_click)
frame.pack()

root.mainloop()

Obtention des événements de déplacement de la souris

Pour capturer les événements de mouvement de la souris, vous pouvez utiliser l’exemple suivant, qui affiche la position actuelle de la souris en temps réel.

import tkinter as tk

def on_mouse_move(event):
    label.config(text=f"Position de la souris : {event.x}, {event.y}")

root = tk.Tk()
root.title("Événement de mouvement de la souris")

label = tk.Label(root, text="Déplacez la souris dans le cadre")
label.pack(pady=10)

frame = tk.Frame(root, width=300, height=200, bg="lightgrey")
frame.bind("", on_mouse_move)
frame.pack()

root.mainloop()

Obtention des événements de glissement de la souris

Pour obtenir les événements de glissement de la souris, utilisez un événement tel que celui-ci. L’exemple suivant affiche la position de la souris pendant un glissement avec le bouton gauche enfoncé.

import tkinter as tk

def on_drag(event):
    label.config(text=f"En glissement à {event.x}, {event.y}")

root = tk.Tk()
root.title("Événement de glissement de la souris")

label = tk.Label(root, text="Faites glisser la souris dans le cadre")
label.pack(pady=10)

frame = tk.Frame(root, width=300, height=200, bg="lightgrey")
frame.bind("", on_drag)
frame.pack()

root.mainloop()

Résumé des événements de la souris

En combinant ces événements, vous pouvez créer des interactions complexes de souris dans Tkinter. En configurant correctement les gestionnaires d’événements et en implémentant des actions pour chaque événement, vous pouvez améliorer l’interaction de l’interface utilisateur.

Obtention des événements du clavier

Ce chapitre explique comment obtenir les événements du clavier en utilisant Tkinter. Nous allons explorer la capture des événements de pression et de relâchement des touches.

Obtention des événements de pression des touches

Pour obtenir un événement de pression d’une touche, vous pouvez utiliser un gestionnaire d’événements. L’exemple ci-dessous affiche la touche pressée en temps réel.

import tkinter as tk

def on_key_press(event):
    label.config(text=f"Touche pressée : {event.keysym}")

root = tk.Tk()
root.title("Événement de pression de touche")

label = tk.Label(root, text="Appuyez sur une touche")
label.pack(pady=20)

root.bind("", on_key_press)

root.mainloop()

Obtention des événements de relâchement des touches

Pour capturer les événements de relâchement d’une touche, utilisez l’exemple suivant, qui affiche la touche relâchée.

import tkinter as tk

def on_key_release(event):
    label.config(text=f"Touche relâchée : {event.keysym}")

root = tk.Tk()
root.title("Événement de relâchement de touche")

label = tk.Label(root, text="Appuyez et relâchez une touche")
label.pack(pady=20)

root.bind("", on_key_release)

root.mainloop()

Obtention des événements de touches spécifiques

Pour capturer un événement d’une touche spécifique, vous spécifiez le symbole de la touche lors de l’attachement de l’événement. L’exemple ci-dessous montre comment détecter quand la barre d’espace est pressée.

import tkinter as tk

def on_space_press(event):
    label.config(text="Barre d'espace pressée")

root = tk.Tk()
root.title("Événement de pression d'une touche spécifique")

label = tk.Label(root, text="Appuyez sur la barre d'espace")
label.pack(pady=20)

root.bind("", on_space_press)

root.mainloop()

Gestion de plusieurs événements de touches

Pour gérer plusieurs événements de touches simultanément, vous pouvez lier plusieurs événements à un même widget. L’exemple ci-dessous montre comment gérer les événements des touches fléchées gauche et droite.

import tkinter as tk

def on_left_key(event):
    label.config(text="Flèche gauche pressée")

def on_right_key(event):
    label.config(text="Flèche droite pressée")

root = tk.Tk()
root.title("Événements de touches multiples")

label = tk.Label(root, text="Appuyez sur la flèche gauche ou droite")
label.pack(pady=20)

root.bind("", on_left_key)
root.bind("", on_right_key)

root.mainloop()

Résumé des événements du clavier

En utilisant ces événements de clavier, vous pouvez créer des applications interactives qui réagissent immédiatement aux entrées de l’utilisateur. En configurant correctement les gestionnaires d’événements et en implémentant des actions pour chaque événement, vous pouvez améliorer l’interaction de l’interface utilisateur.

Méthode de configuration des gestionnaires d’événements

Pour traiter les événements de la souris ou du clavier avec Tkinter, il est nécessaire de configurer des gestionnaires d’événements. Ce chapitre explique comment configurer et utiliser les gestionnaires d’événements dans Tkinter.

Qu’est-ce qu’un gestionnaire d’événements ?

Un gestionnaire d’événements est une fonction appelée lorsqu’un événement spécifique se produit. En configurant un gestionnaire d’événements, vous pouvez ajouter des actions à exécuter en réponse aux interactions de l’utilisateur.

Base de la liaison des événements

Pour configurer un gestionnaire d’événements, vous liez un événement à un widget. Lors de cette liaison, vous spécifiez l’événement et la fonction de gestionnaire associée.

import tkinter as tk

def on_event(event):
    print("Événement déclenché:", event)

root = tk.Tk()
root.title("Exemple de liaison d'événements")

button = tk.Button(root, text="Cliquez-moi")
button.bind("", on_event)
button.pack(pady=20)

root.mainloop()

Dans cet exemple, lorsque le bouton est cliqué, la fonction on_event est appelée et l’information de l’événement est affichée.

Liaison de plusieurs événements à un gestionnaire

Il est également possible de lier plusieurs événements au même widget. L’exemple ci-dessous montre comment lier à la fois les événements de clic et de pression d’une touche à un bouton.

import tkinter as tk

def on_click(event):
    print("Bouton cliqué")

def on_key(event):
    print("Touche pressée:", event.keysym)

root = tk.Tk()
root.title("Liaison d'événements multiples")

button = tk.Button(root, text="Cliquez ou appuyez sur une touche")
button.bind("", on_click)
button.bind("", on_key)
button.pack(pady=20)

button.focus_set()  # Définir le focus pour obtenir des événements clavier

root.mainloop()

Dans cet exemple, lorsque le bouton est cliqué ou qu’une touche est pressée, un gestionnaire différent est appelé pour chaque événement.

Dissociation des gestionnaires d’événements

Il est possible de dissocier un gestionnaire d’événements lié. L’exemple suivant montre comment dissocier un événement lié.

import tkinter as tk

def on_click(event):
    print("Bouton cliqué")

root = tk.Tk()
root.title("Exemple de dissociation d'événements")

button = tk.Button(root, text="Cliquez-moi")
button.bind("", on_click)
button.pack(pady=20)

# Dissocier la liaison
button.unbind("")

root.mainloop()

Exemples d’application des gestionnaires d’événements

Les gestionnaires d’événements permettent de réaliser des interactions complexes. Voici quelques exemples d’applications pratiques.

Glisser-déposer

Un exemple de mise en œuvre d’une fonctionnalité de glisser-déposer. Les éléments peuvent être déplacés en les faisant glisser.

import tkinter as tk

def start_drag(event):
    widget = event.widget
    widget._drag_data = {"x": event.x, "y": event.y}

def do_drag(event):
    widget = event.widget
    x = widget.winfo_x() + event.x - widget._drag_data["x"]
    y = widget.winfo_y() + event.y - widget._drag_data["y"]
    widget.place(x=x, y=y)

root = tk.Tk()
root.title("Exemple de glisser-déposer")

label = tk.Label(root, text="Faites glisser-moi", bg="lightblue", width=10, height=2)
label.place(x=50, y=50)
label.bind("", start_drag)
label.bind("", do_drag)

root.mainloop()

Création d’événements personnalisés

Un exemple de création et de gestion d’événements personnalisés. Vous pouvez générer des événements définis par l’utilisateur.

import tkinter as tk

def custom_event_handler(event):
    print("Événement personnalisé déclenché")

root = tk.Tk()
root.title("Exemple d'événement personnalisé")

root.bind("<>", custom_event_handler)

# Déclenchement de l'événement personnalisé
root.event_generate("<>")

root.mainloop()

Résumé des gestionnaires d’événements

En utilisant efficacement les gestionnaires d’événements, vous pouvez améliorer considérablement l’interactivité des applications Tkinter. Configurer correctement la liaison des événements, gérer plusieurs événements simultanément et dissocier les événements lorsque cela est nécessaire, vous permet de créer une expérience utilisateur enrichie.

Exemples d’application des événements de la souris

Les événements de la souris peuvent améliorer l’interaction de l’interface utilisateur. Voici quelques exemples pratiques.

Mise en œuvre du glisser-déposer

Ce code implémente une fonctionnalité de glisser-déposer, permettant de déplacer un widget.

import tkinter as tk

def start_drag(event):
    widget = event.widget
    widget._drag_data = {"x": event.x, "y": event.y}

def do_drag(event):
    widget = event.widget
    x = widget.winfo_x() + event.x - widget._drag_data["x"]
    y = widget.winfo_y() + event.y - widget._drag_data["y"]
    widget.place(x=x, y=y)

root = tk.Tk()
root.title("Exemple de glisser-déposer")

label = tk.Label(root, text="Faites glisser-moi", bg="lightblue", width=10, height=2)
label.place(x=50, y=50)
label.bind("", start_drag)
label.bind("", do_drag)

root.mainloop()

Mise en œuvre d’un menu de clic droit

Un exemple pour afficher un menu contextuel avec un clic droit. Le menu est déclenché à partir d’un événement de bouton droit.

import tkinter as tk
from tkinter import Menu

def show_context_menu(event):
    context_menu.post(event.x_root, event.y_root)

root = tk.Tk()
root.title("Exemple de menu contextuel")

context_menu = Menu(root, tearoff=0)
context_menu.add_command(label="Option 1")
context_menu.add_command(label="Option 2")
context_menu.add_command(label="Option 3")

frame = tk.Frame(root, width=300, height=200, bg="lightgrey")
frame.bind("", show_context_menu)
frame.pack()

root.mainloop()

Mise en œuvre d’une application de dessin

Un exemple pour créer une simple application de dessin en utilisant les événements de la souris pour dessiner des lignes.

import tkinter as tk

def start_draw(event):
    global last_x, last_y
    last_x, last_y = event.x, event.y

def draw(event):
    global last_x, last_y
    canvas.create_line((last_x, last_y, event.x, event.y), width=2)
    last_x, last_y = event.x, event.y

root = tk.Tk()
root.title("Application de dessin")

last_x, last_y = None, None

canvas = tk.Canvas(root, bg="white", width=400, height=300)
canvas.pack()

canvas.bind("", start_draw)
canvas.bind("", draw)

root.mainloop()

Mise en œuvre de la fonctionnalité de zoom

Un exemple de zoom utilisant la molette de la souris pour changer l’échelle du widget.

import tkinter as tk

def zoom(event):
    scale = 1.0
    if event.delta > 0:
        scale *= 1.1
    else:
        scale /= 1.1
    canvas.scale("all", event.x, event.y, scale, scale)

root = tk.Tk()
root.title("Exemple de zoom")

canvas = tk.Canvas(root, bg="white", width=400, height=300)
canvas.pack(fill=tk.BOTH, expand=True)

canvas.bind("", zoom)

# Dessiner des formes initiales
canvas.create_rectangle(50, 50, 150, 150, fill="blue")
canvas.create_oval(200, 50, 300, 150, fill="red")

root.mainloop()

Résumé des événements de la souris

Les événements de la souris peuvent être utilisés pour créer des interfaces utilisateurs interactives telles que des fonctionnalités de glisser-déposer, des menus contextuels, des applications de dessin, et des fonctions de zoom. Ces techniques permettent de fournir une interface intuitive et attrayante pour l’utilisateur.

Exemples d’application des événements du clavier

Les événements du clavier peuvent améliorer l’expérience utilisateur. Voici quelques exemples pratiques.

Mise en œuvre des raccourcis clavier

Un exemple de raccourci clavier permettant d’effectuer une action avec une combinaison de touches, comme Ctrl+S pour afficher un message.

import tkinter as tk

def save(event):
    label.config(text="Raccourci activé (Ctrl+S)")

root = tk.Tk()
root.title("Exemple de raccourci clavier")

label = tk.Label(root, text="Appuyez sur Ctrl+S pour activer le raccourci")
label.pack(pady=20)

root.bind("", save)

root.mainloop()

Personnalisation des champs de saisie de texte

Exemple de personnalisation d’un champ de saisie de texte avec un événement pour afficher le texte lorsque la touche Entrée est pressée.

import tkinter as tk

def on_enter(event):
    label.config(text=f"Texte saisi : {entry.get()}")

root = tk.Tk()
root.title("Exemple de saisie de texte")

entry = tk.Entry(root)
entry.pack(pady=10)
entry.bind("", on_enter)

label = tk.Label(root, text="Appuyez sur Entrée après avoir tapé")
label.pack(pady=10)

root.mainloop()

Mise en œuvre d’un contrôleur de jeu

Un exemple pour créer un contrôleur de jeu simple en utilisant les événements du clavier pour déplacer un objet.

import tkinter as tk

def move_left(event):
    canvas.move(rect, -10, 0)

def move_right(event):
    canvas.move(rect, 10, 0)

def move_up(event):
    canvas.move(rect, 0, -10)

def move_down(event):
    canvas.move(rect, 0, 10)

root = tk.Tk()
root.title("Exemple de contrôleur de jeu")

canvas = tk.Canvas(root, width=400, height=400, bg="white")
canvas.pack()

rect = canvas.create_rectangle(180, 180, 220, 220, fill="blue")

root.bind("", move_left)
root.bind("", move_right)
root.bind("", move_up)
root.bind("", move_down)

root.mainloop()

Navigation dans un formulaire

Un exemple pour personnaliser la navigation entre les champs de saisie d’un formulaire en utilisant la touche Tab.

import tkinter as tk

def focus_next_widget(event):
    event.widget.tk_focusNext().focus()
    return "break"

def focus_prev_widget(event):
    event.widget.tk_focusPrev().focus()
    return "break"

root = tk.Tk()
root.title("Exemple de navigation dans un formulaire")

entry1 = tk.Entry(root)
entry2 = tk.Entry(root)
entry3 = tk.Entry(root)

entry1.pack(pady=5)
entry2.pack(pady=5)
entry3.pack(pady=5)

entry1.bind("", focus_next_widget)
entry2.bind("", focus_next_widget)
entry3.bind("", focus_next_widget)

entry1.bind("", focus_prev_widget)
entry2.bind("", focus_prev_widget)
entry3.bind("", focus_prev_widget)

root.mainloop()

Résumé des événements du clavier

En utilisant les événements du clavier, vous pouvez mettre en place des raccourcis, personnaliser les champs de saisie, créer des contrôleurs de jeu, et personnaliser la navigation entre les champs de saisie, ce qui améliore considérablement l’interactivité et l’efficacité de vos applications.

Résumé des exercices

Les exercices suivants vous permettront de tester vos connaissances sur les événements de la souris et du clavier dans Tkinter. Vous pourrez mettre en pratique les concepts que vous avez appris dans ce guide.

Exercice 1 : Changer la couleur au clic de souris

Problème : Créez un programme qui change la couleur d’arrière-plan d’un label de manière aléatoire lorsque vous cliquez sur un bouton.

Indice : Utilisez le module random pour générer des couleurs aléatoires.

Solution : 

import tkinter as tk
import random

def change_color(event):
    colors = ["red", "green", "blue", "yellow", "purple", "orange"]
    color = random.choice(colors)
    label.config(bg=color)

root = tk.Tk()
root.title("Changement de couleur au clic")

label = tk.Label(root, text="Cliquez sur le bouton pour changer ma couleur", width=40, height=10)
label.pack(pady=20)

button = tk.Button(root, text="Changer la couleur")
button.bind("", change_color)
button.pack()

root.mainloop()

Exercice 2 : Compter les caractères entrés

Problème : Créez un programme qui compte et affiche en temps réel le nombre de caractères entrés dans un champ de texte.

Indice : Utilisez l’événement <KeyRelease>.

Solution : 

import tkinter as tk

def update_count(event):
    count = len(entry.get())
    label.config(text=f"Nombre de caractères : {count}")

root = tk.Tk()
root.title("Compteur de caractères")

entry = tk.Entry(root)
entry.pack(pady=10)
entry.bind("", update_count)

label = tk.Label(root, text="Nombre de caractères : 0")
label.pack(pady=10)

root.mainloop()

Exercice 3 : Dessiner un cercle avec un glissement de souris

Problème : Créez un programme qui dessine un cercle sur un canevas lorsque vous faites glisser la souris avec le bouton gauche enfoncé.

Indice : Utilisez la méthode create_oval.

Solution : 

import tkinter as tk

def draw_circle(event):
    x, y = event.x, event.y
    r = 10  # Rayon
    canvas.create_oval(x-r, y-r, x+r, y+r, fill="blue")

root = tk.Tk()
root.title("Dessiner des cercles")

canvas = tk.Canvas(root, bg="white", width=400, height=300)
canvas.pack()
canvas.bind("", draw_circle)

root.mainloop()

Exercice 4 : Mettre à jour le label avec un raccourci clavier

Problème : Créez un programme qui met à jour le texte d’un label en « Raccourci activé ! » lorsque vous appuyez sur Ctrl+U.

Indice : Utilisez l’événement <Control-u>.

Solution : 

import tkinter as tk

def update_label(event):
    label.config(text="Raccourci activé !")

root = tk.Tk()
root.title("Raccourci clavier")

label = tk.Label(root, text="Appuyez sur Ctrl+U pour mettre à jour ce texte")
label.pack(pady=20)

root.bind("", update_label)

root.mainloop()

Résumé des exercices

Ces exercices vous permettent de réviser et d’appliquer les connaissances acquises sur les événements de la souris et du clavier dans Tkinter. En pratiquant, vous pourrez améliorer vos compétences et créer des applications interactives et réactives.

Questions fréquentes et dépannage

Ce chapitre aborde les problèmes courants rencontrés lors de l’utilisation de Tkinter et propose des solutions pour résoudre ces problèmes. Ces informations vous aideront à surmonter les défis lors du développement de vos applications.

Question 1 : La fenêtre Tkinter ne s’affiche pas

Problème : La fenêtre Tkinter ne s’affiche pas après l’exécution du programme.

Solution : La cause la plus fréquente est que root.mainloop() n’a pas été appelé. La fonction mainloop lance la boucle d’événements Tkinter, ce qui est nécessaire pour afficher la fenêtre.

import tkinter as tk

root = tk.Tk()
root.title("Fenêtre d'exemple")
root.geometry("300x200")

root.mainloop()  # Doit être appelé

Question 2 : Les événements clavier ne répondent pas

Problème : Les événements clavier ne répondent pas même après les avoir configurés.

Solution : Assurez-vous que le widget a le focus pour capter les événements clavier. Utilisez la méthode focus_set pour définir le focus sur le widget cible.

import tkinter as tk

def on_key_press(event):
    print("Touche pressée :", event.keysym)

root = tk.Tk()
root.title("Exemple d'événement clavier")

entry = tk.Entry(root)
entry.pack()
entry.bind("", on_key_press)
entry.focus_set()  # Définir le focus

root.mainloop()

Question 3 : Les événements de la souris ne fonctionnent pas

Problème : Les événements de la souris ne fonctionnent pas correctement malgré la liaison.

Solution : Vérifiez que les événements sont bien liés au widget après qu’il ait été placé dans la fenêtre. Les liaisons d’événements doivent être définies après la création du widget.

import tkinter as tk

def on_click(event):
    print("Clic de souris à", event.x, event.y)

root = tk.Tk()
root.title("Exemple d'événement de la souris")

frame = tk.Frame(root, width=300, height=200, bg="lightgrey")
frame.pack()
frame.bind("", on_click)  # Lier après la création du widget

root.mainloop()

Question 4 : Les formes sur le canevas ne s’affichent pas comme prévu

Problème : Les formes dessinées sur le canevas ne s’affichent pas comme prévu.

Solution : Vérifiez que les coordonnées des formes sont appropriées et qu’elles sont bien contenues dans le canevas.

import tkinter as tk

root = tk.Tk()
root.title("Exemple de dessin sur canevas")

canvas = tk.Canvas(root, bg="white", width=400, height=300)
canvas.pack()

# Vérifiez que les formes sont bien dans les limites du canevas
canvas.create_rectangle(50, 50, 150, 150, fill="blue")
canvas.create_oval(200, 50, 300, 150, fill="red")

root.mainloop()

Question 5 : L’application Tkinter se bloque

Problème : L’application Tkinter se bloque de manière intermittente.

Solution : Cela peut être dû à des traitements de données lourds ou à une mauvaise gestion des ressources. Veillez à gérer correctement les exceptions et à ne pas effectuer d’opérations GUI sur des threads autres que le thread principal.

import tkinter as tk

def update_label():
    try:
        label.config(text="Texte mis à jour")
    except Exception as e:
        print("Erreur :", e)

root = tk.Tk()
root.title("Exemple de gestion des exceptions")

label = tk.Label(root, text="Texte initial")
label.pack()

button = tk.Button(root, text="Mettre à jour le label", command=update_label)
button.pack()

root.mainloop()

Résumé

Dans cet article, nous avons expliqué en détail comment obtenir les événements de la souris et du clavier en utilisant Tkinter. En commençant par les bases, nous avons exploré la manière de configurer les gestionnaires d’événements, des exemples d’applications pratiques, des exercices, ainsi que des solutions aux problèmes courants.

La gestion des événements est un élément clé pour rendre les interfaces Tkinter interactives et améliorer l’expérience utilisateur. En tirant parti des événements de la souris et du clavier, vous pouvez créer des applications réactives et intuitives.

En appliquant ces techniques à vos projets, vous pouvez améliorer vos compétences en développement avec Tkinter et créer des applications plus complexes et fonctionnelles. Nous espérons que ce guide vous sera utile dans vos projets à venir.

Le prochain étape consistera à explorer des fonctionnalités avancées de Tkinter et à apprendre à intégrer Tkinter avec d’autres bibliothèques Python pour créer des applications encore plus complexes.

Python
dépannage Association d'Événements Python Raccourcis Clavier tkinter Événements de Clavier Glisser-Déposer Application de Dessin Événements de Souris Développement GUI Menu Clic Droit
Sommaire