Récupérer une variable d'une fonction lancée par un menu

Salut.

Pourquoi ne pas utiliser un classe de façon à partager tes valeurs ?

from tkinter import *

class Point_3D:
    "Definition d'un point 3D"
    def __init__(self,x = 0.0,y = 0.0,z=0.0):
        self.__x = x
        self.__y = y
        self.__z = z

    def __repr__(self):
        return "X %f Y %f Z %f"%(self.__x,self.__y,self.__z)

    x = property(lambda s: s.__x)
    y = property(lambda s: s.__y)
    z = property(lambda s: s.__z)


class Point:
    def __init__(self, area):
        self.area = area
        self.pt = Point_3D(10.0, 12.0, 30.0)

    def add(self, *args):
        pass


    def show(self, evt=None):
        self.area.create_text(20, 20,text=self.pt.x)

WIDTH, HEIGHT = 400, 400

main_win = Tk()
main_win.title('Test')
main_win.geometry(str(WIDTH)+'x'+str(HEIGHT)+'+400+100')

graph_area = Canvas(main_win,bg='white',height=380,width=380)
graph_area.place(x = 10,y = 10)


pt = Point(graph_area)

menu_bar = Menu(main_win)
menu_file = Menu(menu_bar, tearoff=0)
menu_bar.add_cascade(label="Nouveau", underline=0, menu=menu_file)
menu_file.add_command(label="Dossier", command=pt.add)
main_win.config(menu=menu_bar)

graph_area.bind("<Button-1>", pt.show)

main_win.mainloop()

Le code est à revoir, mais l'idée globale est là.

Bah il suffit de mettre la création dans la méthode add.

class Point:
    def __init__(self, area):
        self.area = area
        self.pt = None


    def add(self, *args):
        self.pt = Point_3D(10.0, 12.0, 30.0)


    def show(self, evt=None):
        if self.pt is not None:
            self.area.create_text(20, 20,text=self.pt.x)

Si ça ne va pas, faut mieux expliquer comment doit se comporter ton script.

bonjour,

suggestion:

def new_point():
    
    graph_area.phil_pt = Point_3D(10.0, 12.0, 30.0)

def show_point(evt):
    
    graph_area.create_text(20,20,text = str(graph_area.phil_pt.x))

Pourquoi utilises-tu une variable globale (graph_area) et écris-tu que tu veux t'en passer?

Sans variable globale:

from tkinter import *

class Point_3D:
    "Definition d'un point 3D"
    def __init__(self,x = 0.0,y = 0.0,z=0.0):
        self.__x = x
        self.__y = y
        self.__z = z
        self.x=x

    def __repr__(self):
        return "X %f Y %f Z %f"%(self.__x,self.__y,self.__z)

def new_point(g):
    pt = Point_3D(10.0, 12.0, 30.0)
    g.bind("<Button-1>", lambda e : show_point(e,g,pt))
   
def show_point(evt,gr,p):
    gr.create_text(20,20,text = str(p.x))

WIDTH, HEIGHT = 400, 400

main_win = Tk()
main_win.title('Test')
main_win.geometry(str(WIDTH)+'x'+str(HEIGHT)+'+400+100')
menu_bar = Menu(main_win)
menu_file = Menu(menu_bar, tearoff=0)
menu_bar.add_cascade(label="Nouveau", underline=0, menu=menu_file)
main_win.config(menu=menu_bar)
graph_area = Canvas(main_win,bg='white',height=380,width=380)
graph_area.place(x = 10,y = 10)
menu_file.add_command(label="Dossier", command=lambda  : new_point(graph_area))

main_win.mainloop()

Bonjour,

J'ai trop simplifié mon exemple, je vais donc reformuler ma demande

from tkinter import *

class Object():

    def __init__(self,param_1, param_2):
        self.__param_1 = param_1
        self.__param_2 = param_2

def new_object(obj_type):
    global obj

    pos1 = obj_type.index('x')
    p1, p2 = float(obj_type[:pos1]), float(obj_type[pos1+1:])

    obj = Object(p1, p2)

objects_types = ['170x80', '100x50']
WIDTH, HEIGHT = 400, 400

main_win = Tk()
main_win.title('Test')
main_win.geometry(str(WIDTH)+'x'+str(HEIGHT)+'+400+100')

menu_bar = Menu(main_win)
menu_file = Menu(menu_bar, tearoff=0)
menu_bar.add_cascade(label="Nouveau", underline=0, menu=menu_file)
for k in range(len(objects_types)): menu_file.add_command(label='Objet '+str(k), command = lambda obj = objects_types[k] : new_object(obj)) 
main_win.config(menu=menu_bar)

graph_area = Canvas(main_win,bg='white',height=380,width=380)
graph_area.place(x = 10,y = 10)

main_win.mainloop()

Je crée une instance en lançant une fonction lambda avec mon menu

On peut lui passer des arguments mais pas récupérer de valeur de retour

Or, je dois ensuite utiliser mon instance dans plusieurs fonctions de mon

application réelle, j'ai donc écrit global obj dans cette fonction, mais

je voudrais bien m'en passer

(la fonction principale contient aussi ce global et ensuite, je passe

l'instance en argument aux autres fonctions)

Pour résumer:

créer une instance suite à une action dans un menu, ou avec un bind

sur une touche du clavier, par exemple (donc pas de return possible)

puis utiliser cette instance dans plusieurs fonctions du code sans

global

Holà yg_be

Merci pour ça

Dans le 1er exemple, l'objet est donc un attribut de la fenêtre principale ?

Je pense que je vais opter pour le 2eme exemple avec la classe M() vide

Je teste tout ça dans mon code réel ...

Pourquoi une classe vide ?

Tout simplement passer en autres arguments de ta fonction anonyme, les références des fonctions ayant besoin de travailler avec tes valeurs.

class Object:
    def __init__(self, param_1, param_2):
        self._param_1 = param_1
        self._param_2 = param_2


def new_object(obj_type, call_func):
    pos1 = obj_type.index('x')
    p1, p2 = float(obj_type[:pos1]), float(obj_type[pos1+1:])

    call_func(Object(p1, p2))

def func(obj):
    print(obj._param_1, obj._param_2)

Et donc

for k in range(len(objects_types)):
    menu_file.add_command(
        label=f'Objet {k})',
        command = lambda : new_object(objects_types[k], func),
    )

Non, ça ne va pas:

en fait je ne veux pas lancer func() tout de suite

avec mon menu, je choisi seulement un objet pour initialiser une instance

ensuite, je remplis des Entry boxes et j'appuie sur la touche Entrée du clavier

main_win.bind("<Return>", calculation)

J'ai donc ceci:

def new_object(obj_type):

    global obj

    ........

et:

def calculation(evt):

    global obj

    #on lance les fonctions utiles en passant obj en argument

Donc, 2 global à éliminer ...

Bonjour yg_be,

Oui, tu as surement raison, je vais prendre un peu de recul et revoir

tout ça.

Cependant, avant de clore cet appel, je voudrais te poser une dernière

question

Dans un certain nombre d'applications professionnelles, on trouve ce type

de menu:

Ne parlons pas de Word ou Excel, qui proposent un nom par défaut lorsque l'on

clique Fichier -> Nouveau

Lorsque j'étais en activité, j'utilisais un soft de CFAO, et l'on entrait

tout de suite le nom du fichier pièce à créer, ensuite, on travaillait à modéliser

une pièce, faire des plans, etc ..

A la fin on cliquait Fichier -> Enregistrer (on on cliquait l'icone que l'on

appelait familièrement "la biscotte")

Moi en Python, je fais comme ceci:

menu_bar = Menu(main_win)
file_menu = Menu(menu_bar, tearoff=0)
menu_bar.add_cascade(label="Fichier", menu=file_menu)
file_menu.add_command(label="Nouveau", command=new_file)
file_menu.add_command(label="Ouvrir...", command=open_file)
file_menu.add_command(label="Sauvegarder", state = DISABLED, command=save_file)
file_menu.add_command(label="Sauvegarder sous ...", state = DISABLED, command=save_file_as)
file_menu.add_command(label="Fermer", state = DISABLED, command=close_file)
file_menu.add_separator()
file_menu.add_command(label="Quitter", command=main_win.destroy)

J'ai donc ces 2 fonctions:

def new_file():
    ''' Creates a new file'''

    current_file =  filedialog.asksaveasfilename(initialdir = os.getcwd(),title = "Nouveau fichier",filetypes =(("Fichiers modèles", "*.prt"),("Tous fichiers","*.*")))

def save_file():
    ''' Saves the current file '''

    with open(current_file,'wb') as fo:
        pickle.dump(objects_list, fo)

Et il faut bien récupérer current_file créé dans new_file()

Comment faisaient-ils donc, ces castars de chez Siemens, pour traiter

ce cas-là ?

(et je pense que dans une boite comme ça, ce n'était pas des amateurs)

Pas mal ...

Pour info, le soft avait été développé initialement en C, puis retaillé en C++ au milieu

des années 80...