← Back to branch summary

~vorlon/ubuntu/saucy/gourmet/trunk

« back to all changes in this revision

Viewing changes to src/lib/GourmetThreads.py

  • Committer: Bazaar Package Importer
  • Author(s): Rolf Leggewie
  • Date: 2008-07-26 13:29:41 UTC
  • Revision ID: james.westby@ubuntu.com-20080726132941-6ldd73qmacrzz0bn
Tags: upstream-0.14.0
Import upstream version 0.14.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/lib/GourmetThreads.py
 
1
import threading, gtk
 
2
from gdebug import *
 
3
import traceback
 
4
from gettext import gettext as _
 
5
from gettext import ngettext
 
6
 
 
7
class Terminated (Exception):
 
8
    def __init__ (self, value):
 
9
        self.value=value
 
10
    def __str__(self):
 
11
        return repr(self.value)
 
12
 
 
13
class SuspendableThread (threading.Thread):
 
14
    """A SuspendableThread. We take a runnerClass which must have a
 
15
    run, suspend, terminate, and resume method. We then launch our thread
 
16
    and provide methods by the same name that interface with our runnerClass.
 
17
    Before running the run() method, we call pre_hooks. Afterward we call any
 
18
    post_hooks. (Pre and post hooks get called with this instance as their only
 
19
    argument."""
 
20
    def __init__ (self, runnerClass, name=None, pre_hooks=[], post_hooks=[],
 
21
                  display_errors=True):
 
22
        self.display_errors=display_errors
 
23
        self.c = runnerClass
 
24
        self.pre_hooks=pre_hooks
 
25
        self.post_hooks=post_hooks
 
26
        self.name = name
 
27
        self.completed = False
 
28
        debug("SuspendableThread starting thread.",2)
 
29
        self.initialize_thread()
 
30
 
 
31
    def initialize_thread (self):
 
32
        threading.Thread.__init__(self, target=self.target_func, name=name)
 
33
 
 
34
    def target_func (self):
 
35
        self.run_hooks(self.pre_hooks)
 
36
        try:
 
37
            debug('SuspendableThread Running %s'%self.c,3)
 
38
            self.c.run()
 
39
        except Terminated:
 
40
            from gtk_extras import dialog_extras
 
41
            dialog_extras.show_message(
 
42
                    label=_("%s stopped."%self.name.title()),
 
43
                    sublabel=_("%s was interrupted by user request."%self.name.title())
 
44
                    )
 
45
        except:            
 
46
            if self.display_errors:
 
47
                self._threads_enter()
 
48
                from gtk_extras import dialog_extras
 
49
                dialog_extras.show_traceback(
 
50
                    label=_("%s interrupted")%self.name.title(),
 
51
                    sublabel=_("There was an error during %s.")%self.name,
 
52
                    )
 
53
                self._threads_leave()
 
54
            self.run_hooks(self.post_hooks)
 
55
            raise
 
56
        else:
 
57
            self.completed = True
 
58
            self.run_hooks(self.post_hooks)
 
59
 
 
60
    def run_hooks (self, hooks):
 
61
        """We hand all hooks ourselves as an argument"""
 
62
        for h in hooks:
 
63
            debug('Running %s'%h,3)
 
64
            h(self)
 
65
        
 
66
    def suspend (self):
 
67
        debug('suspending thread',0)
 
68
        self.c.suspend()
 
69
 
 
70
    def resume (self):
 
71
        debug('resuming thread',0)
 
72
        self.c.resume()
 
73
 
 
74
    def terminate (self):
 
75
        debug('terminating thread',0)
 
76
        self.c.terminate()
 
77
 
 
78
    def _threads_enter (self):
 
79
        gtk.threads_enter()
 
80
 
 
81
    def _threads_leave (self):
 
82
        gtk.threads_leave()
 
83
 
 
84
class SuspendableDeletions:
 
85
    def __init__ (self, rg, recs):
 
86
        self.suspended = False
 
87
        self.terminated = False
 
88
        self.recs = recs
 
89
        print 'SuspendableDeletions handed ',recs
 
90
        self.rg = rg
 
91
        
 
92
    def check_for_sleep (self):
 
93
        if self.terminated:
 
94
            raise Terminated("Deletion Terminated!")
 
95
        while self.suspended:
 
96
            if self.terminated:
 
97
                raise "Deletion Terminated!"
 
98
            time.sleep(1)
 
99
    
 
100
    def run (self):
 
101
        debug('running GourmetThreads.py',0)
 
102
        rtot = len(self.recs)
 
103
        n = 0        
 
104
        for r in self.recs:
 
105
            self.check_for_sleep()
 
106
            #r = self.rg.rd.get_rec(i)
 
107
            self.rg.set_progress_thr(float(n)/float(rtot),
 
108
                                     _("Deleting recipes from database... (%s of %s deleted)"%(n,rtot))
 
109
                                       )
 
110
            self.rg.delete_rec(r)
 
111
            n += 1
 
112
        msg = ngettext('Deleted %s recipe','Deleted %s recipes',
 
113
                       rtot)%rtot
 
114
        self.rg.reset_prog_thr(message=msg)
 
115
        self.rg.doing_multiple_deletions=False
 
116
 
 
117
    def suspend (self): self.suspended = True
 
118
 
 
119
    def terminate (self): self.terminated = True
 
120
 
 
121
    def resume (self): self.suspended = False
 
122
 
 
123
def get_lock ():
 
124
    return threading.Lock()
 
125
 
 
126
def gtk_enter ():
 
127
    print 'threads_enter'
 
128
    gtk.threads_enter()
 
129
 
 
130
def gtk_leave ():
 
131
    print 'threads_leave'
 
132
    gtk.threads_leave()
 
133
 
 
134
def gtk_threads_init ():
 
135
    print 'threads_init'
 
136
    gtk.threads_init()
 
137
 
 
138
def gtk_update ():
 
139
    """This is for FauxThreads to use to update the GUI periodically"""
 
140
    pass