créer exe puis ouvrir avec

Version imprimable

Bonjour,

J'arrive avec cx_freeze à transformer ce code ci-dessous .py en executable .exe.
Code:

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 import tkinter as tk import tkinter.filedialog as tkFD def open_file(): name = tkFD.askopenfilename(filetypes = [("Fichiers Tex","*.tex")]) if name: with open(name, "r") as f: t.insert(tk.INSERT, f.read()) t.update() root = tk.Tk() f = tk.Frame(root) geoargs = {'fill':'both', 'padx':5, 'pady':5} f.pack(side=tk.BOTTOM, **geoargs) tk.Button(f, text='Open File', command=open_file).pack(side=tk.LEFT, **geoargs) tk.Button(f, text='Quit', command=root.quit).pack(side=tk.RIGHT, **geoargs) xscrollbar = tk.Scrollbar(root, orient=tk.HORIZONTAL) xscrollbar.pack(side=tk.BOTTOM, fill=tk.X) yscrollbar = tk.Scrollbar(root) yscrollbar.pack(side=tk.RIGHT, fill=tk.Y) t = tk.Text(root, wrap=tk.NONE, xscrollcommand=xscrollbar.set, yscrollcommand=yscrollbar.set) t.pack() xscrollbar.config(command=t.xview) yscrollbar.config(command=t.yview) t.focus_set() root.mainloop()
Je pensais que je devais passer par cette procédure pour pouvoir accéder au <<ouvrir avec>> de windows pour ouvrir directement les fichiers d'extension .tex (cf code ci dessus).

En fait, avec <<ouvrir avec>>, il ouvre l'application mais il n'ouvre pas le fichier. Que faut-il rajouter (au code?) pour faire fonctionner le <<ouvrir avec>>.

Merci pour vos réponses.

Gabriel

PS: dans le setup.py j'ai mis:
Code:

1 2 3 4 5 6 7 8 from cx_Freeze import setup, Executable setup( name = "essai_code", version = "1.0", description = "Edit essai", executables = [Executable(r"c:\gabriel\gabytex\essai_code.py")] )

Bonjour,

Code:

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
import tkinter as tk
import tkinter.filedialog as tkFD
import sys
import os
 
def open_file():
    name = tkFD.askopenfilename(filetypes = [("Fichiers Tex","*.tex")])
    if name:
        with open(name, "r") as f:
            t.insert(tk.INSERT, f.read())
    t.update()
 
def open_onstart(fichier):
    print(fichier)
 
root = tk.Tk()
f = tk.Frame(root)
geoargs = {'fill':'both', 'padx':5, 'pady':5}
f.pack(side=tk.BOTTOM, **geoargs)
tk.Button(f, text='Open File', command=open_file).pack(side=tk.LEFT, **geoargs)
tk.Button(f, text='Quit', command=root.quit).pack(side=tk.RIGHT, **geoargs)
xscrollbar = tk.Scrollbar(root, orient=tk.HORIZONTAL)
xscrollbar.pack(side=tk.BOTTOM, fill=tk.X)
yscrollbar = tk.Scrollbar(root)
yscrollbar.pack(side=tk.RIGHT, fill=tk.Y)
t = tk.Text(root, wrap=tk.NONE, xscrollcommand=xscrollbar.set,
            yscrollcommand=yscrollbar.set)
t.pack()
xscrollbar.config(command=t.xview)
yscrollbar.config(command=t.yview)
t.focus_set()
if len(sys.argv) > 1 and os.path.isfile(sys.argv[1]):
    with open(sys.argv[1], "r") as f:
        t.insert(tk.INSERT, f.read())
    t.update()
root.mainloop()

A vous de voir ce que retourne sys.argv et de lire la doc d'os.path.

@+

11/03/2012, 19h37
Ruyneau

Bonsoir,

J'ai donc insérer les lignes manquantes et çà fonctionne.

Il reste cependant un problème (dont j'ai cherché les réponses sur le forum). Lorsque je sélectionne plusieurs fichiers, il m'ouvre autant de console et d'instance. Or dans mon instance, j'ai créé un notebook avec des onglets. Serait-il possible d'adapter le code pour que s'il y a plusieurs fichiers à ouvrir, il ouvre à chaque fois un onglet et non pas une instance?

Merci pour vos réponses.

Gabriel
11/03/2012, 20h19
PauseKawa
Bonsoir,

Ce n'est pas dans le code cela...

sys.argv retourne une liste et là c'est le traitement des listes qu'il vas falloir revoir.
Code:

1 2 3 4 for fichier in sys.argv[1:]: if os.path.isfile(fichier): ouvrir un onglet le remplir.
@+

Edit: Après cela dépend du système. Il est toujours possible de n'ouvrir qu'une seule fois le programme et que s'il est ré-ouvert les nouvelles instances du programme lui retourne le fichier a ouvrir.
12/03/2012, 10h49
Ruyneau

Bonjour,

En fait je voudrais surtout que lorsque le programme est ouvert, de ne plus le réouvrir pour des nouveaux fichiers et que si je clique (pas forcément simultanément) le fichier cliqué s'insère directement dans un nouvel onglet du programme ouvert.

Je pense que cela correspond à la remarque que pausekawa m'a faite:

Citation:

Il est toujours possible de n'ouvrir qu'une seule fois le programme et que s'il est ré-ouvert les nouvelles instances du programme lui retourne le fichier à ouvrir.

Mais, je ne vois vraiment pas comment faire.

Merci pour vos réponses.
Gabriel
12/03/2012, 11h50
wiztricks

Salut,

Citation:

Mais, je ne vois vraiment pas comment faire.

Ce n'est pas "trivial".
1 - il faut créer un objet système genre mutex pour que les instances suivantes "voient" si l'application a été ou pas démarrée,
2 - le cas échéant, plutôt que de démarrer l'application, il faudra expédier un message à l'application démarrée pour qu'elle récupère le fichier à intégrer dans les fichiers "ouverts".
Pour 1: voir la discussion.
Pour 2: le plus simple serait sans doute de passer par un client RPC. Mais ce n'est qu'un avis.
Cordialement,
- W

Bonjour,
Je suis arrivé à faire un truc...mais bon ce n'est certainement pas le top.
Donc j'ai pris l'option de création d'un fichier annexe avec sa destruction lorsque l'on quitte l'application...
Lorsque l'executable est appelé, il vérifie d'abord l'existence ou non du fichier.
Si le fichier n'existe pas, alors on exécute l'instance et on créé le fichier annexe sinon on écrit une information (ici le nom du fichier) dans le fichier annexe.
Dans la class Fichier, il y a une fonction vérification qui est relancée toutes les secondes... et qui teste s'il y a modification ou non du fichier annexe. S'il y a modification alors on ouvre le fichier inscrit dans le fichier annexe.
J'ai fait quelques tests et çà a l'air de marcher. Je perds l'ouverture simultanée de fichiers - mais en ce qui me concerne, finalement, ce n'est pas un problème -
Le code est ci-dessous. Si vous voyez une solution meilleure et que çà ne vous prend pas trop de temps, je suis preneur.

Gabriel

Code:

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
import tkinter
import tkinter.filedialog as tkFileDialog
import tkinter.ttk as ttk
import os
import sys
 
class Application():
 
    def __init__(self,to_open):
        self.root = tkinter.Tk()
        self.onglet = ttk.Notebook(self.root)
        self.onglet.pack()
        self.fc=Fichier(self.root,self.onglet)
        self.b1=tkinter.Button(self.root,text='Ouvrir',command=self.fc.ouvrir_bouton)
        self.b1.pack(side=tkinter.LEFT)
        self.b2=tkinter.Button(self.root,text='Quitter',command=self.fc.fermer)
        self.b2.pack(side=tkinter.RIGHT)
        if to_open:
            self.fc.ouvrir(to_open)
        else:
            self.fc.nouvelle_feuille()
        self.root.mainloop()
 
class Fichier():
 
    def __init__(self,root, onglet):
#Appel des variables
        self.fe = root
        self.ong = onglet
        self.date_modif=os.path.getmtime(r'c:\test_ouverture.gab')
        self.verification()
 
    def _new_sheet(self, nom_fichier):
        """création d'une nouvelle feuille"""
        f1 = tkinter.Frame(self.ong, bg='gray', bd=1)
        texte1 = tkinter.Text(f1, wrap=tkinter.WORD)
        s1 = tkinter.Scrollbar(f1, orient=tkinter.VERTICAL)        
        s1.config(command=texte1.yview)
        texte1.config(yscrollcommand=s1.set)                      
        self.ong.add(f1, text=nom_fichier)
        texte1.grid(row=0,column=0,padx=10, sticky=tkinter.S+tkinter.N)
        s1.grid(row=0,column=1, sticky=tkinter.S+tkinter.N)
        texte1.focus_set()
        return texte1
 
    def nouvelle_feuille(self, event=None):
        texte1=self._new_sheet('nouveau')
 
    def ouvrir(self,fichier,event=None):
        f=open(fichier,'r')
        texte=f.read()
        f.close()
        texte1=self._new_sheet(os.path.basename(fichier))
        texte1.insert(tkinter.INSERT,texte)
 
    def ouvrir_bouton(self,event=None):
        name = tkFileDialog.askopenfilename(filetypes =[("Tous", "*")])
        if name:
            self.ouvrir(name)
 
    def fermer(self,event=None):
        os.remove(r'c:\test_ouverture.gab')
        self.fe.destroy()
 
    def verification(self,event=None):
        if os.path.getmtime(r'c:\test_ouverture.gab')!=self.date_modif:
            self.date_modif=os.path.getmtime(r'c:\test_ouverture.gab')
            f=open(r'c:\test_ouverture.gab','r')
            op=f.read()
            f.close()
            self.ouvrir(op)
        self.fe.after(1000,self.verification)
 
if __name__ == '__main__':
    if len(sys.argv) > 1:
        if os.path.exists(r'c:\test_ouverture.gab') ==False:
            f=open(r'c:\test_ouverture.gab','w')
            f.write(sys.argv[1])
            f.close()
            Application(sys.argv[1])
        else:
            f=open(r'c:\test_ouverture.gab','w')
            f.write(sys.argv[1])
            f.close()
    else:
        f=open(r'c:\test_ouverture.gab','w')
        f.write('création')
        f.close()
        Application(None)

15/03/2012, 15h17
afranck64

Vu qu'on y est, autant sauvegarder un <set> de fichiers via pickle dans "xyz.gab" et l'application en elle-même (le notebook) en ayant la liste/set des fichiers déjà ouvert, ouvre juste les fichiers contenu dans xyz.gab et pas dans son set-personnel.
15/03/2012, 15h45
Ruyneau

Bonjour,

Citation:

autant sauvegarder un <set> de fichiers via pickle dans "xyz.gab" et l'application en elle-même (le notebook) en ayant la liste/set des fichiers déjà ouvert, ouvre juste les fichiers contenu dans xyz.gab et pas dans son set-personnel.

Cà me parait bien puisqu'effectivement on peut comparer ce qui est à ouvrir avec ce qui est déjà ouvert mais je ne vois pas comment faire : sauvegarder un <set> via pickle ???? et sauvegarder l'application en elle même????
Si vous avez une piste plus précise, merci d'avance.

Gabriel

voici ce à quoi je pense...

Code:

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
import pickle
 
FILENAME = "temporal.gab"
 
def getSet():
    """Load data in file <FILENAME>"""
    try:
        f = open(FILENAME, "rb")
        res = pickle.load(f)
        f.close()
        return res
    except:
        return set()
 
def saveSet(mySet):
    """Save <mySet> in file <FILENAME>"""
    try:
        f = open(FILENAME, "wb")
        pickle.dump(mySet, f)
        f.close()
    except:
        pass
 
def addValue(newValue):
    """Add/update file <FILENAME> whit value <newValue>"""
    last_set = getSet()
    last_set.add(newValue.lower())
    saveSet(last_set)
 
 
def delValue(value):
    """remove  <value> in file <FILENAME>"""
    last_set = getSet()
    last_set.discard(value.lower())
    saveSet(last_set)
 
 
def test():
    """Test the methods"""
    addValue("hello world.txt")
    addValue("how are you world.movie")
    addValue("man.bin")
    print (getSet())
    delValue("man.bin")
    print (getSet())
 
 
if __name__ == "__main__":
    test()

Et donc, en ayant ton <set> d'éléments affichés, tu as juste à afficher tous les éléments dans:

Code:

a_afficher = set_deja_afficher - set_recupere_du_fichier

16/03/2012, 09h23
Ruyneau

OK merci.

Je vais étudier tout ça.

Gabriel