Discussion :

[Devoghlockst]

Bonjour, j'ai un problème au niveau d'un bouton qui lance le programme du clique mais aucun clique ne se produit et au deuxième appuie du bouton le programme de clique ne s'arrête pas.

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
 
import tkinter as tk
from tkinter import messagebox
import pyautogui
 
# Creation de la fenetre
Fenetre_Principale = tk.Tk()
Fenetre_Principale.title("Auto-Clicker")
Fenetre_Principale.geometry("200x100")
Fenetre_Principale.resizable(False, False)
 
# Variable global qui dit si le clique est en marche ou non
Actif = False
 
# Variable globalpour le text du boutton de click
Action = "Démarrer"
 
# Initialisation des variables
Interval_h = tk.StringVar(Fenetre_Principale, value="0")
Interval_min = tk.StringVar(Fenetre_Principale, value="0")
Interval_s = tk.StringVar(Fenetre_Principale, value="0")
Interval_ms = tk.StringVar(Fenetre_Principale, value="0")
choix_click = tk.IntVar(Fenetre_Principale, value=1)
choix_position = tk.IntVar(Fenetre_Principale, value=1)
Valeur_X = tk.StringVar(Fenetre_Principale, value="100")
Valeur_Y = tk.StringVar(Fenetre_Principale, value="100")
Touche_demarrage = tk.StringVar(Fenetre_Principale, value="F6")
 
# Fonction qui change le text sur le bouton
def Update_Text_Button():
    Bouton_Start.config(text=f"{Action} ({Touche_demarrage.get()})")
 
# Fonction choix de l'action via titre boutton
def startstop():
    global Actif
    try :
        if not Actif :
            start_clicking()
        elif Actif :
            stop_clicking()
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
 
# Fonction qui clique avec un temps de repos
def auto_click(Interval):
    global Actif
    global choix_click
    if Actif :
        try :
            if int(choix_click.get()) == 1:
                pyautogui.click(button="left")
                Fenetre_Principale.after(Interval, lambda: auto_click(Interval))
            elif int(choix_click.get()) == 2:
                pyautogui.click(button="right")
                Fenetre_Principale.after(Interval, lambda: auto_click(Interval))
        except Exception as e:
            messagebox.showerror("Erreur", str(e))
 
# Fonction qui clique avec un temps de repos avec positionnement du curseur
def auto_click_positionnement(Interval, x, y):
    global Actif
    if Actif :
        try :
            pyautogui.moveTo(x, y)
            if int(choix_click.get()) == 1:
                pyautogui.click(button="left")
                Fenetre_Principale.after(Interval, lambda: auto_click_positionnement(Interval, x, y))
            elif int(choix_click.get()) == 2:
                pyautogui.click(button="right")
                Fenetre_Principale.after(Interval, lambda: auto_click_positionnement(Interval, x, y))
        except Exception as e:
            messagebox.showerror("Erreur", str(e))
 
# Fonction pour démarrer l'auto-clicker
def start_clicking():
    global Actif, Action
    Actif = True
    Action = "Arrêter"
    Update_Text_Button()
    try:
        h = int(Interval_h.get()) if Interval_h.get().isdigit() else 0
        m = int(Interval_min.get()) if Interval_min.get().isdigit() else 0
        s = int(Interval_s.get()) if Interval_s.get().isdigit() else 0
        ms = int(Interval_ms.get()) if Interval_ms.get().isdigit() else 0
        Interval = h * 3600000 + m * 60000 + s * 1000 + ms
        if Interval == 0:
            Interval = 1000
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
    if choix_position.get() == 1:
        auto_click(Interval)
    elif choix_position.get() == 2:
        x = int(Valeur_X.get())
        y = int(Valeur_Y.get())
        auto_click_positionnement(Interval, x, y)
 
# Fonction pour arrêter l'auto-clicker
def stop_clicking():
    global Actif
    Actif = False
    Action = "Démarrer"
    Update_Text_Button()
 
# Interface
Bouton_Start = tk.Button(Fenetre_Principale, text=f"{Action} ({Touche_demarrage.get()})", command=startstop)
Bouton_Start.pack()
 
# Lancement de la boucle principale Tkinter
Fenetre_Principale.mainloop()

J'ai reproduit le problème avec cette partie de mon code mais je peu fournir le code complet au besoin. Merci du temps que vous m'aurez accordé
(Suite de l'ancienne discussion : https://www.developpez.net/forums/d2...yautogui-time/)

[wiztricks]

Merci du temps que vous m'aurez accordé

Le code que vous avez posté ne fait pas ce que vous voulez.... ok mais c'est vous qui avez imaginé la logique du code(*) qui devait traduire ces désirs/souhaits.
De fait quand vous relisez ce code, ce qu'il fait (ou pas) dépend de condition (if...else...) et de l'état de certaines variables.
Comprendre ce qu'il se passe et imaginer une solution passe par la vérification de cet état et la confirmation que ces valeurs sont bien celles attendues.
Basiquement ça peut se faire avec des "print" et si vous utilisez un IDE, positionner des breakpoints et regarder l'état des variables intéressantes lorsqu'on arrive aux instructions correspondantes sera plus facile.

La mise au point d'un programme se fit avec ces outils, bonne occasion d'apprendre à les utiliser!

(*)Votre code est illisible i.e. quand je le lis, je ne comprends pas ce que vous avez cherché à faire. Donc je peux tracer l'état et confirmer que vu l'état des variables ça fait bien ce qui est écrit mais pour "corriger", il faudrait "ré-ecrire" et le préalable serait de comprendre la logique...

- W

[Devoghlockst]

L
(*)Votre code est illisible i.e. quand je le lis, je ne comprends pas ce que vous avez cherché à faire. Donc je peux tracer l'état et confirmer que vu l'état des variables ça fait bien ce qui est écrit mais pour "corriger", il faudrait "ré-ecrire" et le préalable serait de comprendre la logique...

Effectivement je me rend compte que j'ai pas assez détailler mon problème en vu du code.

La variable la plus importante est ma variable "Actif" qui me permet de savoir de le statut de mon auto clique, si Actif est a True alors l'auto clique est en fonctionnement et s'il est a False il ne fonctionne pas.

La variable Action sert seulement de variable global pour changer le text du bouton si l'auto clique est en marche ou non

Toute les variable StringVar et IntVar sont des paramètre essentiel au lancement du clique mais immuable dans ce programme.

Au clique sur le bouton Il va sur la fonction "startstop" qui vérifie si l'auto clique est actif ou non pour le démarrer s'il n'est pas actif ou l'arrêter s'il est déjà actif.

Si il n'est pas actif alors il va dans la fonction "start_clicking" qui change le text du bouton récupère l'intervalle et appelle le fonction "auto_click" qui permet de cliquer

La fonction qui clique vérifie l'état de la variable actif pour voir si elle continue a cliquer si c'est bon la fonction effectue un clique et s'appelle elle même avec un délai grâce a after, le temps qui a été déterminé par l'intervalle.

En cas d'arrêt la fonction "startstop" va cette fois dans "stop_clicking" qui modifie la variable Actif a False pour arrêter le clique et change le text du bouton.



Le problème est que au clique sur le bouton le programme va bien dans "startstop" quand la variable Actif est a False donc il lance le programme "start_clicking", je reçois bien l'intervalle et le programme suis le chemin vers la fonction "auto_click", le clique s'effectue (même si je ne le perçois pas avec un test de clique en ligne) mais a ce moment au lieu de continuer le clique avec after il va dans startstop avec la variable Actif a True et il va dans le "stop_clicking" et modifie le text du bouton (Celui ci ne change pas sur l'interface alors que c'est la même fonction qu'au premier changement qui celui-ci avait marcher).

Ma recherche en ce moment c'est pourquoi il retourne dans le fonction startstop apres seulement une seule itération.

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
 
import tkinter as tk
from tkinter import messagebox
import pyautogui
 
# Creation de la fenetre
Fenetre_Principale = tk.Tk()
Fenetre_Principale.title("Auto-Clicker")
Fenetre_Principale.geometry("200x100")
Fenetre_Principale.resizable(False, False)
 
# Variable global qui dit si le clique est en marche ou non
Actif = False
 
# Variable global pour le text du boutton de click
Action = "Démarrer"
 
# Initialisation des variables
Interval_h = tk.StringVar(Fenetre_Principale, value="0")
Interval_min = tk.StringVar(Fenetre_Principale, value="0")
Interval_s = tk.StringVar(Fenetre_Principale, value="1")
Interval_ms = tk.StringVar(Fenetre_Principale, value="1")
choix_click = tk.IntVar(Fenetre_Principale, value=1)
choix_position = tk.IntVar(Fenetre_Principale, value=1)
Valeur_X = tk.StringVar(Fenetre_Principale, value="100")
Valeur_Y = tk.StringVar(Fenetre_Principale, value="100")
Touche_demarrage = tk.StringVar(Fenetre_Principale, value="F6")
 
# Fonction qui change le text sur le bouton
def Update_Text_Button():
    Bouton_Start.config(text=f"{Action} ({Touche_demarrage.get()})")
    print("Texte changer")
 
# Fonction choix de l'action via titre boutton
def startstop():
    global Actif
    print("actif : ",Actif)
    try :
        if not Actif :
            start_clicking()
        elif Actif :
            stop_clicking()
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
 
# Fonction qui clique avec un temps de repos
def auto_click(Interval):
    global Actif
    global choix_click
    if Actif :
        try :
            if int(choix_click.get()) == 1:
                pyautogui.click(button="left")
                print("j'ai cliqué")
                Fenetre_Principale.after(Interval, lambda: auto_click(Interval))
            elif int(choix_click.get()) == 2:
                pyautogui.click(button="right")
                Fenetre_Principale.after(Interval, lambda: auto_click(Interval))
        except Exception as e:
            messagebox.showerror("Erreur", str(e))
 
# Fonction qui clique avec un temps de repos avec positionnement du curseur
def auto_click_positionnement(Interval, x, y):
    global Actif
    if Actif :
        try :
            pyautogui.moveTo(x, y)
            if int(choix_click.get()) == 1:
                pyautogui.click(button="left")
                Fenetre_Principale.after(Interval, lambda: auto_click_positionnement(Interval, x, y))
            elif int(choix_click.get()) == 2:
                pyautogui.click(button="right")
                Fenetre_Principale.after(Interval, lambda: auto_click_positionnement(Interval, x, y))
        except Exception as e:
            messagebox.showerror("Erreur", str(e))
 
# Fonction pour démarrer l'auto-clicker
def start_clicking():
    global Actif, Action
    Actif = True
    Action = "Arrêter"
    Update_Text_Button()
    try:
        h = int(Interval_h.get()) if Interval_h.get().isdigit() else 0
        m = int(Interval_min.get()) if Interval_min.get().isdigit() else 0
        s = int(Interval_s.get()) if Interval_s.get().isdigit() else 0
        ms = int(Interval_ms.get()) if Interval_ms.get().isdigit() else 0
        Interval = h * 3600000 + m * 60000 + s * 1000 + ms
        if Interval == 0:
            Interval = 1000
        print("interval : ",Interval)
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
    if choix_position.get() == 1:
        auto_click(Interval)
    elif choix_position.get() == 2:
        x = int(Valeur_X.get())
        y = int(Valeur_Y.get())
        auto_click_positionnement(Interval, x, y)
 
# Fonction pour arrêter l'auto-clicker
def stop_clicking():
    global Actif
    Actif = False
    print("je suis dans le stop")
    Action = "Démarrer"
    Update_Text_Button()
 
# Interface
Bouton_Start = tk.Button(Fenetre_Principale, text=f"{Action} ({Touche_demarrage.get()})", command=startstop)
Bouton_Start.pack()
 
# Lancement de la boucle principale Tkinter
Fenetre_Principale.mainloop()

[AznarAkeba]

Bonjour,

Je n'ai pas regardé dans le détail, mais si j'étais toi, je vérifierais déjà si pyautogui.click(button='left') dans auto_click() ne vient pas cliquer sur ton bouton "Arrêter"...

[wiztricks]

Effectivement je me rend compte que j'ai pas assez détailler mon problème en vu du code.

Ce que vous semblez cherchez à faire semble être: un bouton marche/arrêt qui, lorsque l'utilisateur a cliqué sur "marche", il va devoir cliquer sur "arrêt" avant un certain délai où on cliquera sur "arrêt" à sa place.

Ce qui se fait en quelques lignes de 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
import tkinter as tk
 
START = 'start'
STOP = 'stop'
interval = 1000
timer_id = None
 
root = tk.Tk()
variable = tk.StringVar(root, value=START)
 
def do_switch():
    global timer_id
 
    if timer_id is None:
        timer_id = root.after(interval, button.invoke)
        variable.set(STOP)
    else:
        root.after_cancel(timer_id)
        timer_id = None
        variable.set(START)
 
button = tk.Button(root, textvariable=variable, command=do_switch)
button.pack()
root.mainloop()

Après les explications que vous donnez concernant votre code, je n'en ai pas besoin: avec python votre code doit être lisible et on doit y retrouver l'intention de départ sans devoir écrire plus de commentaires que de lignes de code.
Ce qui suppose, par exemple, avoir pris le temps de potasser tkinter avant de partir à écrire des rustines avec un autogui qui ajoutent des complications (pourquoi faire?).

- W

[Devoghlockst]

Bonjour,

Je n'ai pas regardé dans le détail, mais si j'étais toi, je vérifierais déjà si pyautogui.click(button='left') dans auto_click() ne vient pas cliquer sur ton bouton "Arrêter"...

... Effectivement j'ai ajouter un écouteur de touche pour lancer le programme sans cliquer sur le bouton et ça fonctionne ...

Pour ce qui est du clique je vais rajouter un délai avant le premier clique ou réduire la fenêtre au lancement

Malheureusement il reste un problème a l'arrêt du programme le text du bouton ne se remet pas a son état initial. Réctification je ne récupere pas la variable global Action c'est pour ça que l'update du text de la touche n'est pas correct

code corrigé

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
 
import tkinter as tk
from tkinter import messagebox
import pyautogui
 
# Creation de la fenetre
Fenetre_Principale = tk.Tk()
Fenetre_Principale.title("Auto-Clicker")
Fenetre_Principale.geometry("200x100")
Fenetre_Principale.resizable(False, False)
 
# Variable global qui dit si le clique est en marche ou non
Actif = False
 
# Variable global pour le text du boutton de click
Action = "Démarrer"
 
 
# Initialisation des variables
Interval_h = tk.StringVar(Fenetre_Principale, value="0")
Interval_min = tk.StringVar(Fenetre_Principale, value="0")
Interval_s = tk.StringVar(Fenetre_Principale, value="1")
Interval_ms = tk.StringVar(Fenetre_Principale, value="1")
choix_click = tk.IntVar(Fenetre_Principale, value=1)
choix_position = tk.IntVar(Fenetre_Principale, value=1)
Valeur_X = tk.StringVar(Fenetre_Principale, value="100")
Valeur_Y = tk.StringVar(Fenetre_Principale, value="100")
Touche_demarrage = tk.StringVar(Fenetre_Principale, value="F6")
 
# Fonction qui change le text sur le bouton
def Update_Text_Button():
    Bouton_Start.config(text=f"{Action} ({Touche_demarrage.get()})")
    print("Texte changer")
 
# Fonction choix de l'action via titre boutton
def startstop():
    global Actif
    print("actif : ",Actif)
    try :
        if not Actif :
            start_clicking()
        elif Actif :
            stop_clicking()
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
 
# Fonction qui clique avec un temps de repos
def auto_click(Interval):
    global Actif
    global choix_click
    if Actif :
        try :
            if int(choix_click.get()) == 1:
                pyautogui.click(button="left")
                print("j'ai cliqué")
                Fenetre_Principale.after(Interval, lambda: auto_click(Interval))
            elif int(choix_click.get()) == 2:
                pyautogui.click(button="right")
                Fenetre_Principale.after(Interval, lambda: auto_click(Interval))
        except Exception as e:
            messagebox.showerror("Erreur", str(e))
 
# Fonction qui clique avec un temps de repos avec positionnement du curseur
def auto_click_positionnement(Interval, x, y):
    global Actif
    if Actif :
        try :
            pyautogui.moveTo(x, y)
            if int(choix_click.get()) == 1:
                pyautogui.click(button="left")
                Fenetre_Principale.after(Interval, lambda: auto_click_positionnement(Interval, x, y))
            elif int(choix_click.get()) == 2:
                pyautogui.click(button="right")
                Fenetre_Principale.after(Interval, lambda: auto_click_positionnement(Interval, x, y))
        except Exception as e:
            messagebox.showerror("Erreur", str(e))
 
# Fonction pour démarrer l'auto-clicker
def start_clicking():
    global Actif, Action
    Actif = True
    Action = "Arrêter"
    Update_Text_Button()
    try:
        h = int(Interval_h.get()) if Interval_h.get().isdigit() else 0
        m = int(Interval_min.get()) if Interval_min.get().isdigit() else 0
        s = int(Interval_s.get()) if Interval_s.get().isdigit() else 0
        ms = int(Interval_ms.get()) if Interval_ms.get().isdigit() else 0
        Interval = h * 3600000 + m * 60000 + s * 1000 + ms
        if Interval == 0:
            Interval = 1000
        print("interval : ",Interval)
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
    if choix_position.get() == 1:
        Fenetre_Principale.after(2000, lambda: auto_click(Interval))
    elif choix_position.get() == 2:
        x = int(Valeur_X.get())
        y = int(Valeur_Y.get())
        Fenetre_Principale.after(2000, lambda: auto_click_positionnement(Interval, x, y))
 
# Fonction pour arrêter l'auto-clicker
def stop_clicking():
    global Actif, Action
    Actif = False
    print("je suis dans le stop")
    Action = "Démarrer"
    Update_Text_Button()
 
 
# Ecouteur de touche (enlever le commentaire des 2 prochaine ligne pour avoir l'écouteur)
#import keyboard
#Id_Touche_Ecoute = keyboard.add_hotkey(Touche_demarrage.get(), startstop)    
 
# Interface
Bouton_Start = tk.Button(Fenetre_Principale, text=f"{Action} ({Touche_demarrage.get()})", command=startstop)
Bouton_Start.pack()
 
# Lancement de la boucle principale Tkinter
Fenetre_Principale.mainloop()

Merci pour vos réponses

[wiztricks]

Salut,

Vous vous contentez d'un code qui à l'air de fonctionner même si en y regardant de plus près il ne fait pas ce qu'on en attend.

La variable "Actif" duplique le texte affiché par le Button:
Si "Démarrer" alors Actif est False, si "Arrêter", il est True.
Comme ce texte est reflété par la variable Action... et que la synchronisation des deux n'est pas automatique, ce sera source de désagréments.

2ème problème, lorsque l'utilisateur clique sur le Button avant que le timer expire, le callback sera toujours appelé... Du coup si l'utilisateur clique deux fois avant que le timer expire, le délai au bout duquel le texte du Button sera modifié automatiquement sera bien plus tôt qu'attendu.

Continuez à programmer comme çà: pas grand monde voudra vous aider à la vue de ce genre de code... et vous ne progresserez que lorsque vous en aurez marre de perdre votre temps à corriger des erreurs qui pourraient être évitée en étudiant un peu plus/mieux les mécanismes utilisés.
Je vous ai posté un exemple d'une 20aine de lignes... si vous ne comprenez pas tout, vous pouvez poser des questions.



- W

[Devoghlockst]

La variable "Actif" duplique le texte affiché par le Button:
Si "Démarrer" alors Actif est False, si "Arrêter", il est True.
Comme ce texte est reflété par la variable Action... et que la synchronisation des deux n'est pas automatique, ce sera source de désagréments.

Effectivement je vais tout mettre sous la variable actif et changer les textes a l'endroit ou cela est nécessaire sans appelé de fonction avec une variable global.

2ème problème, lorsque l'utilisateur clique sur le Button avant que le timer expire, le callback sera toujours appelé... Du coup si l'utilisateur clique deux fois avant que le timer expire, le délai au bout duquel le texte du Button sera modifié automatiquement sera bien plus tôt qu'attendu.

Je n'avais pas vu se problème, mais dans mon programme lorsque l'on clique plusieurs fois rapidement on peut lancer plusieurs instance de clique ce qui est problématique.

Continuez à programmer comme çà: pas grand monde voudra vous aider à la vue de ce genre de code... et vous ne progresserez que lorsque vous en aurez marre de perdre votre temps à corriger des erreurs qui pourraient être évitée en étudiant un peu plus/mieux les mécanismes utilisés.
Je vous ai posté un exemple d'une 20aine de lignes... si vous ne comprenez pas tout, vous pouvez poser des questions.

Pour le code que vous m'avez fournit je m'excuse mais je n'avais pas vu une seule fois la ligne

Code :

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

root.after_cancel(ident)

c'est pour cela que le code me semblait assez similaire alors que non avec cette ligne couper l'opération en cours est bien mieux et résous le problème N°2
Pour le changement de text sur le bouton j'avais garder une autre méthode car j'avais des problèmes sur votre façon, mais finalement c'est juste moi qui l'avais mal implémenter dans mon code.

Merci de ses conseils que je n'avais pas vu mais que vous m'aviez déjà donner.

Si vous avez d'autre remarque sur le code ou autre n'hésitez pas, merci de votre aide.

Correction :

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
 
import tkinter as tk
from tkinter import messagebox
import pyautogui
 
# Creation de la fenetre
Fenetre_Principale = tk.Tk()
Fenetre_Principale.title("Auto-Clicker")
Fenetre_Principale.geometry("200x100")
Fenetre_Principale.resizable(False, False)
 
# Variable global qui prend en variable le clicque pour qu'il puisse etre cancel
Actif = None
 
# Initialisation des variables
Interval_h = tk.StringVar(Fenetre_Principale, value="0")
Interval_min = tk.StringVar(Fenetre_Principale, value="0")
Interval_s = tk.StringVar(Fenetre_Principale, value="1")
Interval_ms = tk.StringVar(Fenetre_Principale, value="1")
choix_click = tk.IntVar(Fenetre_Principale, value=1)
choix_position = tk.IntVar(Fenetre_Principale, value=1)
Valeur_X = tk.StringVar(Fenetre_Principale, value="100")
Valeur_Y = tk.StringVar(Fenetre_Principale, value="100")
Touche_demarrage = tk.StringVar(Fenetre_Principale, value="F6")
 
# Fonction qui change le text sur le bouton
#def Update_Text_Button():
#    if Actif is None:
#        Bouton_Start.config(text=f"Démarrer ({Touche_demarrage.get()})")
#    else:
#        Bouton_Start.config(text=f"Arrêter ({Touche_demarrage.get()})")
#    print("Texte changer")
 
# Fonction choix de l'action via titre boutton
def startstop():
    global Actif
    print("actif : ",Actif)
    try :
        if Actif is None :
            start_clicking()
        elif Actif is not None :
            stop_clicking()
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
 
# Fonction qui clique avec un temps de repos
def auto_click(Interval):
    global Actif
    global choix_click
    try :
        if int(choix_click.get()) == 1:
            pyautogui.click(button="left")
            print("j'ai cliqué")
            Actif = Fenetre_Principale.after(Interval, lambda: auto_click(Interval))
        elif int(choix_click.get()) == 2:
            pyautogui.click(button="right")
            Actif = Fenetre_Principale.after(Interval, lambda: auto_click(Interval))
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
 
# Fonction qui clique avec un temps de repos avec positionnement du curseur
def auto_click_positionnement(Interval, x, y):
    global Actif
    try :
        pyautogui.moveTo(x, y)
        if int(choix_click.get()) == 1:
            pyautogui.click(button="left")
            Actif = Fenetre_Principale.after(Interval, lambda: auto_click_positionnement(Interval, x, y))
        elif int(choix_click.get()) == 2:
            pyautogui.click(button="right")
            Actif = Fenetre_Principale.after(Interval, lambda: auto_click_positionnement(Interval, x, y))
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
 
# Fonction pour démarrer l'auto-clicker
def start_clicking():
    global Actif
    Bouton_Start['text'] = f"Arrêter ({Touche_demarrage.get()})"
    try:
        h = int(Interval_h.get()) if Interval_h.get().isdigit() else 0
        m = int(Interval_min.get()) if Interval_min.get().isdigit() else 0
        s = int(Interval_s.get()) if Interval_s.get().isdigit() else 0
        ms = int(Interval_ms.get()) if Interval_ms.get().isdigit() else 0
        Interval = h * 3600000 + m * 60000 + s * 1000 + ms
        if Interval == 0:
            Interval = 1000
        print("interval : ",Interval)
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
    if choix_position.get() == 1:
        Actif = Fenetre_Principale.after(2000, lambda: auto_click(Interval))
    elif choix_position.get() == 2:
        x = int(Valeur_X.get())
        y = int(Valeur_Y.get())
        Actif = Fenetre_Principale.after(2000, lambda: auto_click_positionnement(Interval, x, y))
 
# Fonction pour arrêter l'auto-clicker
def stop_clicking():
    global Actif
    Fenetre_Principale.after_cancel(Actif)
    Actif = None
    print("je suis dans le stop")
    Bouton_Start['text'] = f"Démarrer ({Touche_demarrage.get()})"
 
 
# Ecouteur de touche (enlever le commentaire des 2 prochaine ligne pour avoir l'écouteur)
#import keyboard
#Id_Touche_Ecoute = keyboard.add_hotkey(Touche_demarrage.get(), startstop)    
 
# Interface
Bouton_Start = tk.Button(Fenetre_Principale, text=f"Démarrer ({Touche_demarrage.get()})", command=startstop)
Bouton_Start.pack()
 
# Lancement de la boucle principale Tkinter
Fenetre_Principale.mainloop()

[wiztricks]

Si vous avez d'autre remarque sur le code ou autre n'hésitez pas, merci de votre aide.

Votre code n'est pas plus lisible...
Par exemple ça définit une fonction auto_click_positionnement qui n'est jamais appelée. Elle sera peut être utile un jour mais pour l'instant, c'est juste du bruit...
Après essayez de vous relire, si je prends la fonction:

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
# Fonction pour démarrer l'auto-clicker
def start_clicking():
    global Actif
    Bouton_Start['text'] = f"Arrêter ({Touche_demarrage.get()})"
    try:
        h = int(Interval_h.get()) if Interval_h.get().isdigit() else 0
        m = int(Interval_min.get()) if Interval_min.get().isdigit() else 0
        s = int(Interval_s.get()) if Interval_s.get().isdigit() else 0
        ms = int(Interval_ms.get()) if Interval_ms.get().isdigit() else 0
        Interval = h * 3600000 + m * 60000 + s * 1000 + ms
        if Interval == 0:
            Interval = 1000
        print("interval : ",Interval)
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
    if choix_position.get() == 1:
        Actif = Fenetre_Principale.after(2000, lambda: auto_click(Interval))
    elif choix_position.get() == 2:
        x = int(Valeur_X.get())
        y = int(Valeur_Y.get())
        Actif = Fenetre_Principale.after(2000, lambda: auto_click_positionnement(Interval, x, y))

C'est bien joli mais nombre de vos variables sont des constantes: de nombreux tests ne servent à rien.
Vous gardez le calcul d'Interval dans un try.... except... alors qu'ayant écrit: int(Interval_h.get()) if Interval_h.get().isdigit() else 0, aucune chance pour que ça lève une exception. Si on vire tout ce qui n esert à rien, ça devient:

Code :

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

1
2
3
4
5
6
7
# Fonction pour démarrer l'auto-clicker
def start_clicking():
    global Actif
 
    Bouton_Start['text'] = f"Arrêter ({Touche_demarrage.get()})"
    Interval = 1000
    Actif = Fenetre_Principale.after(2000, lambda: auto_click(Interval))

On y voit déjà plus clair... et la question qui vient immédiatement à l'esprit est pourquoi calculer Interval, si le timeout est constant = 2000ms?
Puis on peut se demander pourquoi auto_click a besoin de cet interval (il ne devrait cliquer qu'une fois).
Admettons, cette ligne là devient alors:

Code :

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

    Actif = Fenetre_Principale.after(Interval, auto_click, Interval)

Alors voir auto_click:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# Fonction qui clique avec un temps de repos
def auto_click(Interval):
    global Actif
    global choix_click
    try :
        if int(choix_click.get()) == 1:
            pyautogui.click(button="left")
            print("j'ai cliqué")
            Actif = Fenetre_Principale.after(Interval, lambda: auto_click(Interval))
        elif int(choix_click.get()) == 2:
            pyautogui.click(button="right")
            Actif = Fenetre_Principale.after(Interval, lambda: auto_click(Interval))
    except Exception as e:
        messagebox.showerror("Erreur", str(e))

Encore un try...except... dont je ne vois pas l'intérêt. Il n'y a pas l'interface qui modifie choix_click mais, par principe, si on proposait à l'utilisateur de mettre à jour cette valeur, on lui demanderait de "valider" et le code vérifiera que la saisie est correcte. Si on fait çà bien après, on ne sait pas trop comment proposer à l'utilisateur comment corriger.
Autre soucis, les blocks du if...elif... ne diffèrent que par le paramètre passé à button=.
Enfin, la fonction est appelée lorsque l'utilisateur n'a pas cliqué assez vite, pourquoi demander à l'exécuter encore?
Le tout dans le troisième, on peut résumer cela en:

Code :

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

1
2
3
4
5
def auto_click():
 
    side = dict(1='left', 2='right').get(choix_click.get(), default=None)
    assert side is not None, 'Unexpected value for {choix_click.get()=}')
    pyautogui.click(button=side)

Apprenez à relire votre code, ça fait partie du boulot... et il ne suffit pas de voir les lignes danser devant ses yeux: c'est une lecture active, ou vous cherchez à comprendre ce que la machine python va bien pourvoir exécuter les instructions demandées.

- W

[Devoghlockst]

Apprenez à relire votre code, ça fait partie du boulot... et il ne suffit pas de voir les lignes danser devant ses yeux: c'est une lecture active, ou vous cherchez à comprendre ce que la machine python va bien pourvoir exécuter les instructions demandées.

Bonjour,
Dans le premier message j'ai bien préciser qu'il s'agit d'une partie du programme et non le programme en entier.

J'ai seulement reproduit les erreurs que j'avais. Si vous voulez le code entier je vous le met ici :

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
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
 
##### Importation des bibliothèques utilisé #####
import tkinter as tk
import ttkbootstrap as ttk
from ttkbootstrap.constants import *
from tkinter import LEFT, RIGHT, TOP, BOTTOM
from tkinter import filedialog, simpledialog
from tkinter import messagebox, Toplevel
from tkinter import PhotoImage
from pynput import mouse
import webbrowser
import pyautogui
import keyboard
import json
import re
import os, sys
 
# Test de fonctionnement de keyboard
try:
    # Test simple : tenter d'enregistrer un raccourci clavier temporaire
    id_test = keyboard.add_hotkey("ctrl+shift+alt+9", lambda: None)
    keyboard.remove_hotkey(id_test)
except Exception as e:
    messagebox.showerror(
        "Erreur avec le module 'keyboard'\n",
        "Le module 'keyboard' ne fonctionne pas correctement.\n"
        "La touche de démarrage ne sera pas fonctionnelle.\n"
        "Essayez d'exécuter ce programme en tant qu'administrateur.\n\n"
        f"Détails : {e}"
    )
 
##### Main #####
 
# Creation de la fenetre
Fenetre_Principale = ttk.Window(themename="vapor")
Fenetre_Principale.title("Auto-Clicker")
Fenetre_Principale.resizable(False, False)
 
# Variable global qui dit si le clique est en marche ou non
Actif = None
 
# Variable global qui prend en variable le clicque pour qu'il puisse etre cancel
Id_Touche_Ecoute = None
 
# Fonction choix de l'action via titre boutton
def startstop():
    global Actif
    try :
        if Actif is None:
            start_clicking()
        elif Actif is not None:
            stop_clicking()
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
 
##### Paramète de premier lancement #####
 
# Création du json setting s'il n'existe pas
try :
    if not os.path.exists("setting/"):
        os.makedirs("setting/")
 
    if not os.path.exists("setting/setting_start.json"):
        parametres = {
            "default_h": "0",
            "default_min": "0",
            "default_s": "1",
            "default_ms": "0",
            "choix_click": 1,
            "choix_position": 1,
            "Delai_premier_click": "2000",
            "Valeur_X": "0",
            "Valeur_Y": "0",
            "Touche_demarrage" : "F6"
        }
        with open("setting/setting_start.json", "w") as fichier:
            json.dump(parametres, fichier, indent=4)
except Exception as e:
    messagebox.showerror("Erreur", str(e))
 
# Initialisation des variables
default_h = tk.StringVar(Fenetre_Principale, value="0")
default_min = tk.StringVar(Fenetre_Principale, value="0")
default_s = tk.StringVar(Fenetre_Principale, value="0")
default_ms = tk.StringVar(Fenetre_Principale, value="0")
choix_click = tk.IntVar(Fenetre_Principale, value=1)
choix_position = tk.IntVar(Fenetre_Principale, value=1)
Delai_premier_click = tk.StringVar(Fenetre_Principale, value="2000")
Valeur_X = tk.StringVar(Fenetre_Principale, value="0")
Valeur_Y = tk.StringVar(Fenetre_Principale, value="0")
Touche_demarrage = tk.StringVar(Fenetre_Principale, value="F6")
 
# Fonction qui change le text sur le bouton
def Update_Text_Button():
    Bouton_Start.config(text=f"{Action} ({Touche_demarrage.get()})")
 
#Mettre a jour la touche de lancement
def Update_touche():
    global Id_Touche_Ecoute
 
    if Id_Touche_Ecoute:
        keyboard.remove_hotkey(Id_Touche_Ecoute)
 
    Id_Touche_Ecoute = keyboard.add_hotkey(Touche_demarrage.get(), startstop)
 
# Charger un fichier de setting
def charger_setting(fichier_choisi):
 
    # Apelle de toute les variable global pour les inclurent dans la fonction
    global default_h, default_min, default_s, default_ms, choix_click, choix_position, Valeur_X, Valeur_Y
    try:
        with open(fichier_choisi, "r") as fichier:
            parametres = json.load(fichier)
 
            # Mise a jour de toute les variable globales
            default_h.set(parametres.get("default_h"))
            default_min.set(parametres.get("default_min"))
            default_s.set(parametres.get("default_s"))
            default_ms.set(parametres.get("default_ms"))
            choix_click.set(parametres.get("choix_click"))
            choix_position.set(parametres.get("choix_position"))
            Delai_premier_click.set(parametres.get("Delai_premier_click"))
            Valeur_X.set(parametres.get("Valeur_X"))
            Valeur_Y.set(parametres.get("Valeur_Y"))
            Touche_demarrage.set(parametres.get("Touche_demarrage"))
 
            Update_touche()
 
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
 
charger_setting("setting/setting_start.json")
 
Update_touche()
 
##### Fonction pour le click #####
 
# Fonction qui clique avec un temps de repos
def auto_click(Interval):
    global Actif
    global choix_click
    try :
        if int(choix_click.get()) == 1:
            pyautogui.click(button="left")
            Actif = Fenetre_Principale.after(Interval, lambda: auto_click(Interval))
        elif int(choix_click.get()) == 2:
            pyautogui.click(button="right")
            Actif = Fenetre_Principale.after(Interval, lambda: auto_click(Interval))
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
 
# Fonction qui clique avec un temps de repos avec positionnement du curseur
def auto_click_positionnement(Interval, x, y):
    global Actif
    try :
        pyautogui.moveTo(x, y)
        if int(choix_click.get()) == 1:
            pyautogui.click(button="left")
            Actif = Fenetre_Principale.after(Interval, lambda: auto_click_positionnement(Interval, x, y))
        elif int(choix_click.get()) == 2:
            pyautogui.click(button="right")
            Actif = Fenetre_Principale.after(Interval, lambda: auto_click_positionnement(Interval, x, y))
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
 
# Fonction pour démarrer l'auto-clicker
def start_clicking():
    global Actif
    Bouton_Start['text'] = f"Arrêter ({Touche_demarrage.get()})"
    try:
        h = int(Interval_h.get()) if Interval_h.get().isdigit() else 0
        m = int(Interval_min.get()) if Interval_min.get().isdigit() else 0
        s = int(Interval_s.get()) if Interval_s.get().isdigit() else 0
        ms = int(Interval_ms.get()) if Interval_ms.get().isdigit() else 0
        Interval = h * 3600000 + m * 60000 + s * 1000 + ms
        if Interval == 0:
            Interval = 1000
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
    if choix_position.get() == 1:
        Actif = Fenetre_Principale.after(2000, lambda: auto_click(Interval))
    elif choix_position.get() == 2:
        x = int(Valeur_X.get())
        y = int(Valeur_Y.get())
        Actif = Fenetre_Principale.after(2000, lambda: auto_click_positionnement(Interval, x, y))
 
# Fonction pour arrêter l'auto-clicker
def stop_clicking():
    global Actif
    Fenetre_Principale.after_cancel(Actif)
    Actif = None
    Bouton_Start['text'] = f"Démarrer ({Touche_demarrage.get()})"
 
##### Fonction barre de menu #####
 
def Sauvegarder():
    try:
        parametres = {
            "default_h": default_h.get(),
            "default_min": default_min.get(),
            "default_s": default_s.get(),
            "default_ms": default_ms.get(),
            "choix_click": choix_click.get(),
            "choix_position": choix_position.get(),
            "Delai_premier_click": Delai_premier_click.get(),
            "Valeur_X": Valeur_X.get(),
            "Valeur_Y": Valeur_Y.get(),
            "Touche_demarrage" : Touche_demarrage.get()
        }
        with open("setting/setting_start.json", "w") as fichier:
            json.dump(parametres, fichier, indent=4)
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
 
def Reset_setting():
    default_h.set("0")
    default_min.set("0")
    default_s.set("1")
    default_ms.set("0")
    choix_click.set(1)
    choix_position.set(1)
    Delai_premier_click.set("2000")
    Valeur_X.set("0")
    Valeur_Y.set("0")
    Touche_demarrage.set("F6")
 
def importer_setting():
    fichier_choisi = filedialog.askopenfilename(
        title="Choisir un fichier JSON",
        filetypes=[("Fichiers JSON", "*.json")],
        initialdir="setting"  # Dossier par défaut
    )
    if re.search(r"^.*\.json$", fichier_choisi):
        charger_setting(fichier_choisi)
    else:
        tk.messagebox.showinfo("Erreur", "Mauvais fichier")
 
def exporter_setting():
    nom_fichier = simpledialog.askstring("Exporter les parametres actuelle", "Nom du fichier :")
    if not nom_fichier:
        return
    if not re.search(r"^.*\.json$", nom_fichier):
        nom_fichier += ".json"
    if os.path.exists(f"setting/{nom_fichier}"):
        Reponse_Remplacer = tk.messagebox.askyesno(f"Fichier existant", f"Le fichier {nom_fichier} existe déja voulez vous le remplacer ? ")
        if not Reponse_Remplacer:
            return
    try:
        parametres = {
            "default_h": default_h.get(),
            "default_min": default_min.get(),
            "default_s": default_s.get(),
            "default_ms": default_ms.get(),
            "choix_click": choix_click.get(),
            "choix_position": choix_position.get(),
            "Delai_premier_click": Delai_premier_click.get(),
            "Valeur_X": Valeur_X.get(),
            "Valeur_Y": Valeur_Y.get(),
            "Touche_demarrage" : Touche_demarrage.get()
        }
        with open(f"setting/{nom_fichier}", "w") as fichier:
            json.dump(parametres, fichier, indent=4)
    except Exception as e:
        messagebox.showerror("Erreur", str(e))
 
def A_propos():
    A_propos_window = tk.Toplevel()
    A_propos_window.title("A propos")
    A_propos_window.resizable(False, False)
 
    msg_apropos =   ("Nom du programme : AutoClicker\n"
                    "Version : 1.0\n"
                    "Développé par : Devoghlockst\n\n"
                    "Ce programme est un auto-clicker\n\n"
                    "Parametrage possible :\n"
                    "- Temps entre les cliques\n"
                    "- Type de clique\n"
                    "- Position du clique\n"
                    "- Délai de lancement du premier clique \n"
                    "- Touche de démarrage\n\n"
                    "Les paramètres peuvent être enregistrés, exportés et importés au format JSON."
                    )
 
    label_texte = tk.Label(A_propos_window, text=msg_apropos, justify="left")
    label_texte.pack(padx=10, pady=10)
 
def Aide():
    Aide_window = tk.Toplevel()
    Aide_window.title("Aide")
    Aide_window.resizable(False, False)
    msg_aide =  ("La sauvegarde du paramétrage est stockée par défaut dans le dossier créer par l'autoclicker nomer setting.\n\n"
                "Tous les fichiers paramètre sauvegardé sont aux format json.\n\n"
                "Il y a un délai de 2seconde avant le début du premier clique.")
 
    label_texte = tk.Label(Aide_window, text=msg_aide, justify="left")
    label_texte.pack(padx=10, pady=10)
 
def Touche_set():
    global Touche_demarrage
 
    def Key_Press(event):
        global Touche_demarrage
        Touche_demarrage.set(event.keysym) #Recupération de la touche presser
        Update_touche()
        popup.destroy()
        Update_Text_Button()
 
    popup = tk.Toplevel()
    popup.title("Changement de la touche de lancement")
    popup.resizable(False, False)
    label = tk.Label(popup, text="Appuyer sur une touche de votre clavier pour paramètrer la touche de démarrage.")
    label.pack(expand=True, fill="both", padx=5, pady=5)
 
    #Paralysie de l'utilisateur
    popup.grab_set()
    popup.focus_force()
 
    #Quand une touche est appuyer faire la fonction on_key_press
    popup.bind("<KeyPress>", Key_Press)
 
def Recuperation_Position_Click():
    def on_click(x, y, button, pressed):
        Valeur_X.set(x)
        Valeur_Y.set(y)
        Listener.stop()
 
        Fenetre_Principale.deiconify()
        Fenetre_Principale.after(50, lambda: Fenetre_Principale.lift())
 
    Fenetre_Principale.withdraw()
 
    #Ajout d'un écouteur de clique
    Listener = mouse.Listener(on_click=on_click)
    Listener.start()
 
def resource_path(relative_path):
    try:
        base_path = sys._MEIPASS # Acces via MEIPASS
    except AttributeError:
        base_path = os.path.abspath(".") # Acces via dossier actuel
 
    return os.path.join(base_path, relative_path)
# ###   en cours  ###
 
# ######    A FAIRE    ######
 
# Changer la langue en anglais ou fr via le menu parametre (plus tard)
# Ajouter la possibiliter de combinaison de touche pour le changement de touche (plus tard)
# Ajouter une variable de temps pour le temps que met l'autoclicker a démarer
 
# ######    A FAIRE    ######
 
#############################################################################
##### Interface tkinter #####
 
# Icone du la fenetre
Fenetre_Principale.iconbitmap(resource_path("Image_icon/Icone_Mouse.ico"))
 
# Création de la barre de menu principale (Tkinter classique)
Menu_Principale = tk.Menu(Fenetre_Principale)
 
# Icone de la barre menu
Icone_Save = PhotoImage(file=resource_path("Image_icon/Save.png"))
Icone_Exit = PhotoImage(file=resource_path("Image_icon/Exit.png"))
Icone_Import = PhotoImage(file=resource_path("Image_icon/Import.png"))
Icone_Export = PhotoImage(file=resource_path("Image_icon/Export.png"))
Icone_Keyboard = PhotoImage(file=resource_path("Image_icon/Keyboard.png"))
Icone_Reset = PhotoImage(file=resource_path("Image_icon/Reset.png"))
Icone_Help = PhotoImage(file=resource_path("Image_icon/Help.png"))
Icone_Propos = PhotoImage(file=resource_path("Image_icon/Propos.png"))
 
# Menu "Fichier" : options pour sauvegarder ou quitter
Menu_fichier = tk.Menu(Menu_Principale, tearoff=0)
Menu_fichier.add_command(label="Sauvegarder les paramètres", image=Icone_Save, compound="left", command=Sauvegarder)
Menu_fichier.add_command(label="Quitter", image=Icone_Exit, compound="left", command=Fenetre_Principale.quit)
Menu_Principale.add_cascade(label="Fichier", menu=Menu_fichier)
 
# Menu "Paramètres" : import/export des réglages, personnalisation des touches, réinitialisation
Menu_setting = tk.Menu(Menu_Principale, tearoff=0)
Menu_setting.add_command(label="Importer les paramètres", image=Icone_Import, compound="left", command=importer_setting)
Menu_setting.add_command(label="Exporter les paramètres", image=Icone_Export, compound="left", command=exporter_setting)
Menu_setting.add_command(label="Changer la touche de démarrage", image=Icone_Keyboard, compound="left", command=Touche_set)
Menu_setting.add_command(label="Réinitialiser les paramètres", image=Icone_Reset, compound="left", command=Reset_setting)
Menu_Principale.add_cascade(label="Paramètres", menu=Menu_setting)
 
# Menu "Plus" : accès à l'aide et aux informations sur l'application
Menu_plus = tk.Menu(Menu_Principale, tearoff=0)
Menu_plus.add_command(label="Aide", image=Icone_Help, compound="left", command=Aide)
Menu_plus.add_command(label="À propos", image=Icone_Propos, compound="left", command=A_propos)
Menu_Principale.add_cascade(label="Plus", menu=Menu_plus)
 
# Application de la barre de menu à la fenêtre principale
Fenetre_Principale.config(menu=Menu_Principale)
 
# Conteneur principal de l'interface
Frame_Principale = ttk.Frame(Fenetre_Principale, padding=15)
Frame_Principale.pack(fill=BOTH, expand=True)
 
# Section : Réglage de l'Intervalle entre les clics
Frame_Interval = ttk.LabelFrame(Frame_Principale, text="Intervalle entre les clics", padding=(15,10))
Frame_Interval.grid(row=0, column=0, columnspan=2, sticky="ew", pady=(0,15))
Frame_Interval.columnconfigure((0,2,4,6), weight=1)  # Colonnes des Spinbox (extensibles)
Frame_Interval.columnconfigure((1,3,5,7), weight=0)  # Colonnes des labels (fixes)
 
# Spinbox pour heures / minutes / secondes / millisecondes avec leurs labels
Interval_h = tk.Spinbox(Frame_Interval, from_=0, to=999999, width=5, textvariable=default_h, font=("Consolas", 11), justify="center")
Interval_h.grid(row=0, column=0, padx=(3,8), pady=5, sticky="ew")
ttk.Label(Frame_Interval, text="h").grid(row=0, column=1, sticky=W, padx=(0,15))
 
Interval_min = tk.Spinbox(Frame_Interval, from_=0, to=999999, width=5, textvariable=default_min, font=("Consolas", 11), justify="center")
Interval_min.grid(row=0, column=2, padx=(3,8), pady=5, sticky="ew")
ttk.Label(Frame_Interval, text="min").grid(row=0, column=3, sticky=W, padx=(0,15))
 
Interval_s = tk.Spinbox(Frame_Interval, from_=0, to=999999, width=5, textvariable=default_s, font=("Consolas", 11), justify="center")
Interval_s.grid(row=0, column=4, padx=(3,8), pady=5, sticky="ew")
ttk.Label(Frame_Interval, text="s").grid(row=0, column=5, sticky=W, padx=(0,15))
 
Interval_ms = tk.Spinbox(Frame_Interval, from_=0, to=999999, width=5, textvariable=default_ms, font=("Consolas", 11), justify="center")
Interval_ms.grid(row=0, column=6, padx=(3,8), pady=5, sticky="ew")
ttk.Label(Frame_Interval, text="ms").grid(row=0, column=7, sticky=W, padx=(0,5))
 
# Section : Définir la position du curseur
Frame_Position_Curseur = ttk.LabelFrame(Frame_Principale, text="Position du curseur", padding=(15,10))
Frame_Position_Curseur.grid(row=1, column=0, sticky="nsew", padx=(0,10))
Frame_Position_Curseur.columnconfigure(0, weight=1)
 
# Choix entre utiliser la position actuelle ou en définir une manuellement
Position_Actuelle = ttk.Radiobutton(Frame_Position_Curseur, text="Position actuelle", variable=choix_position, value=1)
Position_Actuelle.grid(row=0, column=0, sticky="ew", pady=5)
 
Position_Defini = ttk.Radiobutton(Frame_Position_Curseur, text="Définir une position", variable=choix_position, value=2)
Position_Defini.grid(row=1, column=0, sticky="ew", pady=5)
 
# Sous-section pour définir manuellement les coordonnées X et Y
Frame_Position_Valeur = ttk.LabelFrame(Frame_Position_Curseur, text="Valeurs X et Y", padding=(10,10))
Frame_Position_Valeur.grid(row=2, column=0, sticky="ew", pady=(10,0))
Frame_Position_Valeur.columnconfigure((1,3), weight=1)
 
# Bouton pour sélectionner automatiquement une position à l’écran
Bouton_Position = ttk.Button(Frame_Position_Valeur, text="Sélectionner une position", command=Recuperation_Position_Click, bootstyle="warning-outline")
Bouton_Position.grid(row=0, column=0, columnspan=4, sticky="ew", pady=(0,10))
 
# Champs de saisie des coordonnées X et Y
ttk.Label(Frame_Position_Valeur, text="X :").grid(row=1, column=0, sticky=E, padx=5)
Position_Valeur_X = ttk.Entry(Frame_Position_Valeur, textvariable=Valeur_X, width=8)
Position_Valeur_X.grid(row=1, column=1, sticky="ew", padx=5)
 
ttk.Label(Frame_Position_Valeur, text="Y :").grid(row=1, column=2, sticky=E, padx=5)
Position_Valeur_Y = ttk.Entry(Frame_Position_Valeur, textvariable=Valeur_Y, width=8)
Position_Valeur_Y.grid(row=1, column=3, sticky="ew", padx=5)
 
# Section : Choix du type de clic, délai au lancement, bouton démarrer
Frame_Choix_Click_Button = ttk.Frame(Frame_Principale)
Frame_Choix_Click_Button.grid(row=1, column=1, sticky="nsew")
Frame_Choix_Click_Button.columnconfigure(0, weight=1)
 
# Sous-section : choix entre clic gauche ou droit
Frame_choix_click = ttk.LabelFrame(Frame_Choix_Click_Button, text="Choix du clic", padding=(10,10))
Frame_choix_click.grid(row=0, column=0, sticky="ew")
 
Click_Gauche = ttk.Radiobutton(Frame_choix_click, text="Gauche", variable=choix_click, value=1)
Click_Gauche.pack(side=LEFT, expand=True, fill="x", padx=10, pady=5)
 
Click_Droite = ttk.Radiobutton(Frame_choix_click, text="Droite", variable=choix_click, value=2)
Click_Droite.pack(side=LEFT, expand=True, fill="x", padx=10, pady=5)
 
# Sous-section : Délai au lancement
Frame_delai_debut = ttk.LabelFrame(Frame_Choix_Click_Button, text="Délai au démarrage", padding=(10,10))
Frame_delai_debut.grid(row=1, column=0, sticky="ew")
 
Delai_debut = tk.Spinbox(Frame_delai_debut, from_=0, to=9999999999, width=10, textvariable=Delai_premier_click, font=("Consolas", 11), justify="center")
Delai_debut.grid(row=0, column=0, sticky="ew", padx=10, pady=5)
ttk.Label(Frame_delai_debut, text="ms").grid(row=0, column=1, sticky="w", padx=(0, 15))
 
# Bouton principal pour démarrer/arrêter l'action automatisée
Bouton_Start = ttk.Button(Frame_Choix_Click_Button, text=f"Démarrer ({Touche_demarrage.get()})", command=startstop, bootstyle="warning-outline")
Bouton_Start.grid(row=2, column=0, sticky="ew", pady=(15, 0), ipady=15)  # Hauteur accrue avec `ipady`
 
# Rendre la grille principale flexible et adaptative
Frame_Principale.rowconfigure(1, weight=1)
Frame_Principale.columnconfigure(0, weight=1)
Frame_Principale.columnconfigure(1, weight=1)
 
# Lancement de la boucle principale Tkinter
if __name__ == "__main__":
    Fenetre_Principale.mainloop()

Image_icon.zip

Le tout dans le troisième, on peut résumer cela en:

Code :

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

1
2
3
4
5
6
 
def auto_click():
 
    side = dict(1='left', 2='right').get(choix_click.get(), default=None)
    assert side is not None, 'Unexpected value for {choix_click.get()=}')
    pyautogui.click(button=side)

Je vais essayer de bien comprendre la première ligne de se code, par contre je suis pas sur que la parenthèse seul sur la deuxième ligne soit voulue si je ne me trompe pas.

[wiztricks]

Je vais essayer de bien comprendre la première ligne de se code, par contre je suis pas sur que la parenthèse seul sur la deuxième ligne soit voulue si je ne me trompe pas.

Absolument... mais je partage des idées de codage pas du code "testé".

- W

[wiztricks]

Dans le premier message j'ai bien préciser qu'il s'agit d'une partie du programme et non le programme en entier.

J'ai seulement reproduit les erreurs que j'avais.

J'avais compris! Mas pas besoin de tout ce que vous avez posté pour reproduire ces erreurs. Du coup ce code en trop gène la lecture du code qui est impliqué dans les erreurs qu'on cherche à comprendre. Cela n'aide pas le travail de relecture nécessaire à la compréhension des soucis qu'on cherche à corriger.

Pour le reste (du code), il est de la même eau que ce que vous avez déjà posté:
1/ try except qui masquent les erreurs (souvent inutiles ou détectées trop tard(*).
2/ utilisation de fonctionnalités sans trop avoir pris le temps de comprendre comment elle fonctionnent,
3/...
Si vous voulez progresser dans les interfaces utilisateurs, vous gagneriez à apprendre à utiliser les "class" car on se retrouve facilement avec un tas de widgets à organiser.
(*) Je comprends le pourquoi du h = int(Interval_h.get()) if Interval_h.get().isdigit() else 0. Interval_h est un Spinbox. On peut le modifier avec des flèches mais aussi comment une Entry. On a donc accès aux paramètre validatecommand,... qui permettent de valider la saisie au moment de la saisie. Si vous faites l'impasse là dessus, effectivement vous vous retrouver à bricoler... mais c'est votre choix! Il y a ce qu'il faut côté tuto et articles pour voir comment faire.

- W

[Devoghlockst]

J'avais compris! Mas pas besoin de tout ce que vous avez posté pour reproduire ces erreurs. Du coup ce code en trop gène la lecture du code qui est impliqué dans les erreurs qu'on cherche à comprendre. Cela n'aide pas le travail de relecture nécessaire à la compréhension des soucis qu'on cherche à corriger.

D'accord je comprend mieux se que vous voulez dire.

Si vous voulez progresser dans les interfaces utilisateurs, vous gagneriez à apprendre à utiliser les "class" car on se retrouve facilement avec un tas de widgets à organiser.

J'ai commencé a regarder un module sur les class il y a 2 jour surement que je reprendrais se code et le transformerait avec des class mais pour l'instant je doit encore apprendre sur les class...

Si vous faites l'impasse là dessus, effectivement vous vous retrouver à bricoler... mais c'est votre choix! Il y a ce qu'il faut côté tuto et articles pour voir comment faire.

Exactement il y a se qu'il faut coter tuto mais pas tout les tuto montre l'utilisation de validatecommand avec un spinbox... Maintenant que vous me le dite je vais chercher ce que c'est, Merci.

[wiztricks]

Exactement il y a se qu'il faut coter tuto mais pas tout les tuto montre l'utilisation de validatecommand avec un spinbox... Maintenant que vous me le dite je vais chercher ce que c'est, Merci.

Relisez votre code, ok, vous l'avez fait avec le "python" que vous connaissiez/maîtrisiez.

Plutôt que de le faire tomber en marche à grand coups de pieds, vous auriez pu ouvrir la documentation pour voir les différentes moutures de .after comme .after_idle ou .after_cancel.

Mettre des try...except... partout pour masquer les erreurs sans les gérer est juste une mauvaise habitude: vous aurez des difficultés à vous en défaire... et ce masquage n'aide pas.

A un moment donné, quand on code, on réalise qu'on répète les mêmes constructions. Des fois, c'est pas évident mais on constate la lourdeur sans imaginer comment faire autrement. C'est la qu'il faut poser des questions à un forum de discussion (et/ou compléter sa formation).

Regardez un peu ces perles dans votre code:

Code :

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

1
2
3
4
5
6
7
    parametres = {
        "default_h": "0",
        "default_min": "0",
        ...
        "Valeur_Y": "0",
        "Touche_demarrage" : "F6"
    }

qui ressemble à:

Code :

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

1
2
3
4
5
default_h = tk.StringVar(Fenetre_Principale, value="0")
default_min = tk.StringVar(Fenetre_Principale, value="0")
...
Valeur_Y = tk.StringVar(Fenetre_Principale, value="0")
Touche_demarrage = tk.StringVar(Fenetre_Principale, value="F6")

qu'on retrouve jusqu'à 6 fois ici ou là.

quelque part lorsque vous avez écrit ça, vous avez du vous demander (j'espère) s'il n'y avait pas "mieux" que ces "répétitions"...

- W

[Devoghlockst]

Mettre des try...except... partout pour masquer les erreurs sans les gérer est juste une mauvaise habitude: vous aurez des difficultés à vous en défaire... et ce masquage n'aide pas.

Je ne pensais que cette instruction soit si néfaste au fonctionnement du code mais d'accord je vais les enlever.

quelque part lorsque vous avez écrit ça, vous avez du vous demander (j'espère) s'il n'y avait pas "mieux" que ces "répétitions"...

Pour l'instant c'est juste une V1.0 dont j'avais besoin fonctionnelle, bien évidement qu'il reste à améliorer et optimiser se code, mais je préfère prendre le temps pour ça et ne pas y allez a l'aveugle non plus, en lisant plus de documentation comme vous m'avez conseillé de le faire.

Se contenter de se code serait une erreur pour mon apprentissage c'est pour ça qu'il sera etoffer et améliorer avec le temps pour pas rester sur ces basiques acquis.

[fred1599]

Je ne pensais que cette instruction soit si néfaste au fonctionnement du code mais d'accord je vais les enlever.

Au contraire elle est fort utile cette instruction, mais c'est comme tout, à utiliser à bon escient.
Pour catcher une exception, il faut bien avoir vécu l'erreur indiquée par l'interpréteur python, c'est à ce moment là où vous pourrez déterminer les actions à mener quand cette erreur se produira avec l'instruction try-except.

Soyez sûr que si dans la documentation cette instruction s'y trouve sans dépréciation, c'est qu'elle a un intérêt.

[wiztricks]

Je ne pensais que cette instruction soit si néfaste au fonctionnement du code mais d'accord je vais les enlever.

Le soucis n'est pas dans le try...except... mais sur le comment vous l'utilisez.

Si on appelle une fonction, c'est pour qu'elle retourne un résultat. L'exception est quand elle ne peut pas retourner ce résultat. Elle dit à l'appelant "je ne peux pas à cause de...", charge à l'appelant de savoir que faire en fonction et décider comment continuer le programme malgré tout.
note: cela suppose aussi qu'on va mettre que les instruction susceptible de lever une exception dans le try...except... et non toutes les instructions d'une fonction.... histoire de savoir que faire lorsqu'une instruction donnée plante et remonte une des exceptions documentées.

Si on se contente d'afficher l'erreur, l'utilisateur pourra vous téléphoner mais vous n'aurez même pas la trace complète: quelle instruction/ quelle ligne/... pour aller voir ce qu'il s'est passé. Puis au lieu de planter, le programme continue... en espérant pouvoir ne pas encore planter plus tard.

- W