daved170 wrote:
On May 13, 7:42 pm, Dave Angel <da...@ieee.org> wrote:
daved170 wrote:
Hi there,
I'm newbie in pythonCard.
I have an application with 2 buttons : START , STOP
Start execute a while(1) loop that execute my calculations.
Stop suppose to raise a flag that will end that loop.
Whenever I pish the START button my GUI is stuck. the calculation
executes but I can't push the STOP button.
I added thread that START start a thread that execute my calculations.
I also added a Global variable that will hold the indication if the
loop should continue.
The problem now is that the thread ignore that variable and loop
forever.
Is there a simple way to make sure that the GUI won't stuck (without
threads)?
And if there isn't such way I would appriciet it very much if anyone
could post an example of how to make my thread read that variable
Thanks
Dave
I don't know PythonCard, but most GUI's are similar enough that the
concepts will work, even though the details differ. I'll assume that
PythonCard has a traditional event loop, from which all events are
dispatched.
If your loop is fairly small, then you should keep it to one thread.
Debugging it will usually be much easier. The trick is to break the
task into pieces (each piece might be once around what is now a loop),
and invoke one piece each time the event loop empties. I can't tell you
how to do that without seeing your loop, but it's not usually very hard.
Now, there is some way of POSTing an event to the event loop. That puts
the event *after* all the events that are already there, but returns
control immediately. So create a custom event, and POST it from the
START button's button-pressed event. That will fire off one "loop" of
the special task, in other words, make one function call to your new
function. Then at the end of the function, POST it again, unless the
STOP button has been pressed in the meantime.
An optimization for this is to use coroutines, which are usually done
with a generator. It's much trickier to describe, but much easier to
accomplish. Roughly, you'd take your existing loop, and put a yield
statement in it at appropriate place(s). Then the custom event is
simply a call to the .next() function of that generator.
Now, threading isn't that tough either, depending on how much data is
being shared between the thread and the main program. You say that
sharing a global flag isn't working, but it should. So how about if you
show us some code, and somebody'll spot the trouble. For example, is
the thread defined in the same module as the App? Global only shares
between a single module. Another reason globals might seem to fail is
if you tried to do mutual imports between two or more modules. (A
imports B, which imports A). Sometimes that fails in mysterious ways.
Make a simple (stripped) example of what you're trying, and we'll try to
find the problem. Without concrete code, we end up with ambiguities
like the above usage of two different meanings for "the loop."- Hide quoted
text -
- Show quoted text -
Thank's Dave,
Here my code, It's a very simple app. the Start button starts a TCP/IP
communication and the Stop should dtop it and kill the client.
I'll be thankful if you'll be able to spot my mistake.
Thanks again
Dave
#Global Variable
bStopLoop = False
#Global Function
def execute(sockObj):
while(!bStopLoop):
That should be:
while not bStopLoop:
str = sockObj.recv(1024)
tmpStr = "Hello " + str
sockObj.send(tmpStr)
#Thread handle class
class myThread(threading.Thread):
def __init__(self,sockObj):
threading.Thread.__init__(self)
bStopLoop = False
'bStopLoop' is local to __init__. Add:
global bStopLoop
self.sockObj = sockObj
def run(self):
execute(self.SockObj)
# GUI
class GUI(model.Background)
def on_Start_mouseclick(self,event):
try:
event.target.enable = False
event.target.redraw()
self.components.Start.enable = False
self.currThread = myThread(self.sockObj)
self.currThread.Start()
wx.SafeYield(self)
self.components.Start.enable = True
except:
.....
def on_Stop_mouseclick(self,event):
bStopLoop = True
'bStopLoop' is local to on_Stop_mouseclick. Add:
global bStopLoop
--
http://mail.python.org/mailman/listinfo/python-list
