Bonjour à tous, lors d'un projet en python je voudrais allier tkinter et python. 

J'ai donc réaliser mon interface en tkinter qui me conviens, ainsi qu'une classe formation sur laquelle je veux travailler. Or lorsque je rentre des valeurs rien ne se passe, et seulement une droite s'affiche. Cette dernière semble correspondre au cas où tout mes int sont égaux à zéros, ce qui ne devrait pas parvenir puisqu'il semble être assignés... 

Si vous pouviez m'aiguiller sur une meilleur piste ;) 

Merci beaucoup, Thomas. 

Interface tkinter : 

from tkinter import *

from formation import *
from coord import Coord



# Début de la définition de l'interface graphique 


fenetre = Tk()

fenetre.title("Modélisation des plissements")


# Frame 1, boutons de commandes à droite de la fenêtre

Frame1 = Frame(fenetre, borderwidth=2)
Frame1.pack(side=RIGHT, padx=15, pady=15)

# Canvas : Zone de dessin pour la représentation 

can = Canvas(fenetre, height=600, width=800, bg='white', borderwidth=1)
can.pack(side=LEFT, padx=15, pady=15)

# Définition du texte et de la zone d'entrée pour le nombre de ligne :

txtli = Label(Frame1, text="Nombre de couches :")
txtli.pack(padx=5, pady=5)
Nbli = IntVar()
champ_Nbli = Entry(Frame1,textvariable = Nbli, width=30)
champ_Nbli.pack(padx=5, pady=5)

# Définition du texte et de la zone d'entrée pour le nombre de colonne :

txtcol = Label(Frame1, text="Nombre de points par couche :")
txtcol.pack(padx=5, pady=5)
Nbcol = IntVar()
champ_Nbcol = Entry(Frame1,textvariable = Nbcol, width=30)
champ_Nbcol.pack(padx=5, pady=5)

# Définition du texte et de la zone d'entrée pour beta :

txtbeta = Label(Frame1, text="Angle beta de la charnière en degré :")
txtbeta.pack(padx=5, pady=5)
beta = IntVar()
champ_beta = Entry(Frame1, textvariable = beta, width=30)
champ_beta.pack(padx=5, pady=5)


matrice = Formation(Nbli.get(), Nbcol.get(), beta.get(), can)

# Définition des boutons pour lancer les actions du programme :

boutonvalidation = Button(Frame1, text="Valider les valeurs", command=matrice.initialisation)
boutonvalidation.pack(padx=5, pady=20)

boutonajoutcouche = Button(Frame1, text="Dépot de sédiment")  # , command=sedimentation)
boutonajoutcouche.pack(padx=5, pady=10)

boutonsimulation = Button(Frame1, text="Simulation", command=matrice.simulationpli)
boutonsimulation.pack(side=BOTTOM, padx=5, pady=20)


# Fin de la définition de l'interface graphique 

fenetre.mainloop()

Class Formation : 

from math import *

from coord import Coord


# On défini la matrice qui va contenir toute les informations

class Formation:
    def __init__(self, ligne, colonne, beta, can, mat=[]):
        self.ligne_ = ligne
        self.colonne_ = colonne
        self.mat_ = mat
        self.beta_ = beta
        self.can_ = can

        # On défini la matrice avec la valeur de Coord associée

        for l in range(int(self.ligne_)):
            self.mat_.append([])
            for c in range(int(self.colonne_)):
                self.mat_[l].append(Coord(c, l))


    def affiche(self):


        for l in range(self.ligne_):
            for c in range(self.colonne_):
                if c == self.colonne_ - 1:
                    self.can_.create_line((800 / self.colonne_) * self.mat_[l][c - 1].getX(),(600 / self.ligne_) * self.mat_[l][c - 1].getY(),(800 / self.colonne_) * self.mat_[l][c].getX(),(600 / self.ligne_) * self.mat_[l][c].getY(), fill='blue')
                else:
                    self.can_.create_line((800 / self.colonne_) * self.mat_[l][c].getX(),(600 / self.ligne_) * self.mat_[l][c].getY(),(800 / self.colonne_) * self.mat_[l][c + 1].getX(),(600 / self.ligne_) * self.mat_[l][c + 1].getY(), fill='blue')

        self.can_.create_line(600, 600, 600 - 850 * sin(self.beta_ * (pi / 180)),
                              600 - 850 * cos(self.beta_ * (pi / 180)), fill='red')


    def simulation(self):


        for l in range(self.ligne_):
            for c in range(self.colonne_):
                self.mat_[l][c].incrX(1)


    def pli(self):
        for l in range(self.ligne_):
            for c in range(self.colonne_):
                if ((800 / self.colonne_) * (self.mat_[l][c].getX())) >= (
                    600 - (600 / self.ligne_) * ((self.ligne_ - l) * sin(self.beta_))):
                    self.mat_[l][c].incrX(-0.01)
                    self.mat_[l][c].incrY(-0.01)


    def initialisation(self):

        self.can_.delete()
        self.affiche()


    def simulationpli(self):


        self.can_.delete()
        self.pli()
        self.simulation()
        self.affiche()

-
Edité par t.beraud38 5 décembre 2015 à 17:50:54

Le seul moment où je vois que tu récupères les valeurs de tes Entry, c'est à la ligne 51 (dis-moi si je me trompe):

matrice = Formation(Nbli.get(), Nbcol.get(), beta.get(), can)

Et à ce moment-là, la valeur de chaque variable est bien égale à 0. Il faut donc récupérer les nouvelles valeurs lors de l'appel de tes méthodes .

Exact , comment puis-faire pour les récupérer ? 

Si je place cette ligne plus bas les commandes seront appelés avant la définition de ma class non ? 

-
Edité par t.beraud38 5 décembre 2015 à 18:41:55

En fait ça dépend énormément de ce que tu veux faire avec. Si j'ai compris (dans les grandes lignes) ton code, tu veux construire une matrice en fonction des valeurs données par l'utilisateur. Donc ta matrice doit être créée APRÈS le renseignement de ces valeurs.

Il faut que tu retiennes que dans une GUI, ce sont les événements qui déterminent le code qui va s'exécuter (en utilisant notamment le paramètre command). Donc l'utilisateur entre les données dans les différents champs Entry, et en cliquant sur un certain bouton (celui que tu veux) ça va créer la matrice.