Aide pour tkinter/console application

Bonjour,

J'ai une application que j'ai fait en mode console, et je veux maintenant la faire fonctionner en mode gui, dans quel widget tkinter je peux emuler la console windows dans une fenetre tkinter et lancer mon l'application.

Merçi.

Bonjour,

Text ?

@+

Merçi pour la reponse, mais:(

Je ne cherche pas a appeler la cmd, exactement je veux executer mon code dans un widget qui fait appeler l'interpreteur python dedans, du genre la touche F5 dans idle.

Bonjour.

Il y a ce module que j'ai fais, il faudra que tu change la fonction foo pour quelle face des
appèle système.

VirtualConsole.py

Bonjour,

merçi pour le module, mais je suis débutant :oops: et encore avec python 2.5.4

J'ai cru que c'est simple à faire, mais...
Peut-être j'ai pas très bien exprimé mon besoin:
1-J'ai un script en python pour console.
2-Je trace une fenêtre et j'ajoute un bouton.
Je veux lancer le script (par pression sur le bouton) dans un ??? dans la fenêtre... un widget console, quoi ? un widget qui est un interpréteur python ?

C'est comme la cmd, la console est dans une fenêtre sans bouton, sans menu, non ? une idée s'il vous plait...

Bonsoir,

C'est bien le sens des réponses.

Voici un code sur lequel je bosse

mavar.py

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
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
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
#
# class myvar for jlg_47
# http://www.developpez.net/forums/d915461/autres-langages/python-zope/general-python/crash-aleatoire-thread/
# Based on Tkinter variable class
class myvar:
    _default = ""
    def __init__(self, master=None, value=None, name=None, trace=None, mode=None):
        if not master:
            master = self
        self._master = master
        if value is not None:
            self._value=value
        else:
            self._value=self._default
        if trace:
            self._trace=trace
        else:
            self._trace=None
        if mode:
            self._mode=mode
        else:
            self._mode=None
        self._oldmode=None
        self._oldtrace=None
        if name:
            self._name = name
            globals()[self._name] = self
 
    # def __call__(self):
 
    def __str__(self):
        return str(self._name)
 
    def set(self, value):
        self._value=value
        if self._trace is not None and (self._mode == 'u' or self._mode == 'w'):
            self.savetrace()
            self._oldtrace()
        elif self._oldtrace is not None:
            self.restauretrace()
 
    def get(self):
        if self._trace is not None and (self._mode == 'u' or self._mode == 'r'):
            self.savetrace()
            self._oldtrace()
        elif self._oldtrace is not None:
            self.restauretrace()
        return self._value
 
    def trace_variable(self, mode, callback):
        self._mode=mode
        self._trace=callback
 
    trace = trace_variable
 
    def trace_vdelete(self):
        self._mode=None
        self._trace=None
 
    def trace_vinfo(self):
        return self._mode, self._trace
 
    def varinfo(self):
        return "Master", self._master, "Name", self._name, "Value", str(self._value), "Trace callback", self._trace, "Trace mode", self._mode
 
    # TODO For callback recursion
    def restauretrace(self):
        self._trace=self._oldtrace
        self._mode=self._oldmode
        self._oldtrace=None
        self._oldmode=None
 
    def savetrace(self):
        self._oldtrace=self._trace
        self._oldmode=self._mode
        self._trace=None
        self._mode=None
 
if __name__ == "__main__":
    a=myvar()
 
    # Default value = ""
    print a.get()
    # Set a value
    a.set(10)
    # Get the value
    print a.get()
 
    # trace value
    def callback():
        # Please, don't use multiples get()/set() whith callback
        print 'a in callback', a.get()
        # a.set(30)
        # Named variables is in globals : globals()["b"] = myvar(name='b')
        b=myvar(name='b')
    a.trace('u', callback)
    a.set(20)
    print 'a after callback'
    print a.get()
 
    # Callback informations
    print 'Callback informations', a.trace_vinfo()
 
    # Name
    print 'b name', b
 
    # Variable informations
    print 'Variable informations'
    dir(b)
    print b.varinfo()
 
    # Delete callback
    a.trace_vdelete()
    print a.trace_vinfo()
 
    # Named variables (b) in globals
    print globals()

Revoici le code de la console ( > Rappel : sur le code de vincent.mbg. Merci vincent.mbg :ccool:)

pyconsole.py

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
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
#! /usr/bin/env/ python
# -*- coding: utf-8 -*-
 
 
from platform import python_version
is_version_3 = python_version().startswith( '3' )
 
if is_version_3 :
    from tkinter import Text, StringVar, TclError
else :
    from Tkinter import Text, StringVar, TclError    
 
from subprocess import Popen, PIPE
import re
 
class pyConsole(Text) :
    def __init__( self, master=None, prompt = "> ", width=80, fg='white', bg='black') :
        Text.__init__( self, master, width=width, fg=fg, bg=bg, insertbackground=fg)
        self.prompt = prompt
        self.bind( "<BackSpace>", self.backspace)
        self.bind( "<Key-Return>",self.execute)
        self.bind( "<Key-Left>", self.left)
        self.bind( "<Key-Up>", self.rappelerLigne)
        self.bind( "<Key-Down>", self.rappelerLigne)
        self.bind( "<1>", self.button_1)
        self.bind( "<B1-Motion>", self.button_1)
        self.bind( "<B1-Leave>", lambda event : "break")
        self.bind( "<Double-1>", lambda event : "break") 
        self.bind( "<Triple-1>", lambda event : "break")
        self.bind( "<<Paste>>", self.insert_commande)
        self.insert( "end", self.prompt )
        self.start_commande = '1.0 + %d chars' % len( self.prompt )
        self.lignes = []
        self.numeroligne = 0
 
    def backspace( self, event ) :
        if int( self.index( "insert" ).split(".")[1] ) > len( self.prompt ) :
             self.delete('insert - 1 chars', 'insert')
        return "break"
 
 
    def button_1( self, event ) :
        last_index = self.index( "insert" )
        def testPosition( index ):
            if self.compare( "insert", "<=", "%d.%d" % ( float( self.index( "end" ) ), len( self.prompt ) ) ) :
                self.mark_set( "insert", index )  
        self.after_idle( testPosition, last_index )
 
    def execute( self, event, *args ) :
        commande = self.get()[:-1]
        if self.lignes == [] or self.lignes[-1] != commande and commande != "" :
            self.lignes.append( commande )
            self.numeroligne = len( self.lignes )
        self.insert(END, "\n")
        self.traite(commande)
        self.event_generate('<<command_interpreted>>')
        self.mark_start_commande()
        self.see( "end" )
        self.mark_set( "insert", "end" )
        return "break"
 
    def insert_commande(self, commande) :
        """ A corriger """
        if is_version_3 :
            if type(commande) is not str :
                try :
                    commande = self.clipboard_get()
                except TclError as e :
                    commande = "" 
        else :
            if type(commande) is not unicode :
                try :
                    commande = self.clipboard_get()
                except TclError as e :
                    commande = "" 
        self.insert(END, '\n'+self.prompt+commande+'\n')
        self.traite(commande)
        return "break"
 
    def left( self, event ) :
        if int(self.index("insert").split(".")[1]) <= len(self.prompt) :
            return "break"
 
    def mark_start_commande( self ):
        self.start_commande = self.index('end - 1 chars')
 
 
    def get( self, index1 = None, index2 = None ):
            if index1 is None :
                commande = Text.get(self, self.start_commande, 'end')
                return(commande)
            else :
                return(Text.get(self, index1, index2))
 
    def rappelerLigne(self, event) :
        if self.numeroligne != [] :
            if event.keysym == "Up" :
                self.numeroligne -= 1 
            else :
                self.numeroligne += 1
                
            if self.numeroligne < 0 :
                self.numeroligne = 0
            elif self.numeroligne > len(self.lignes) -1 :
                self.numeroligne = len(self.lignes) -1
            else :
                self.delete("end - 1 line", "end - 1 char")
                self.insert("end", self.prompt + self.lignes[self.numeroligne])                
        return "break"
 
    def traite(self, commande):
        if commande == 'cls' or commande == 'clear': self.clean()
        elif commande.lower == 'exit' or commande == 'quit': self.quit()
        else:
            p = Popen([commande], shell=True, stdout=PIPE, stderr=PIPE)
            output, errors = p.communicate()
            retour = []
            if errors: leretour=errors
            else: leretour=output
            self.insert(END, leretour)
            leretour = leretour.split('\n')
            for elems in leretour:
                retour.append(elems)
            self.insert(END, self.prompt)
            return retour
 
    def clean(self):
        """ Traitement cls/clear """
        self.delete(1.0, END)
        self.insert(END, self.prompt)
 
    def quit(self):
        """ Traitement exit/quit """
        self.destroy()
 
    """ Appels externes """
    def insercmd(self, cmd):
        self.insert(END, '\n'+self.prompt)
        self.insert(END, cmd+'\n')
        retour = self.traite(cmd)
        return retour
 
if __name__ == '__main__' :
    if is_version_3 :
        from tkinter import *
    else :
        from Tkinter import *
 
    def mescommandes():
        reponse1 = pyc.insercmd('python mavar.py')
        print (reponse1)
 
    root = Tk()
    pyc = pyConsole(root)
    pyc.pack()
    Button(root, text='Test', command=mescommandes).pack()
    root.mainloop()

Regarde en rouge dans pyconsole.py.

@+

Salut

Bonjour,

Je ne sais pas si ceci peut t'aider mais tu pourrais l'exécuter comme ceci:
Code:

1 2 3 4 5 6 7 from Tkinter import * root = Tk() def f(): execfile("mon_script_console.py") Button(root,text="Lancer la console",command=f).pack() root.mainloop()
salut et à bientôt.