def run(self):
while True:
threads_enter()
# logging.debug("LoopingThread")
self.process()
threads_leave()
time.sleep(self.speed)
def get(self, timeout=None):
"""
'get' will block until the processed function returns, timeout
happens, or the work is cancelled. You can test if you were
cancelled by the isCancelled() method, and you can test if you
reached the timeout by the isAlive() method. Notice,
cancelling will not make 'get' unblock, besides if you build
'isCancelled' calls into your function.
Warning: the get function assumes that if you are the MainThread you
have the gdklock and if you are not the MainThread you don't have
the gdklock.
If this is not true, and the work is not done, calling get
will result in a deadlock.
If you haven't used the gtk.gdk.threads_enter nor
gtk.gdk.threads_leave function, everything should be fine."""
if not self.isDone():
if type(currentThread()) == _MainThread:
threads_leave()
self.join(timeout)
if type(currentThread()) == _MainThread:
threads_enter()
if self.isAlive():
return None
self.done = True
return self.result
def acquire():
me = currentThread()
t = time.strftime("%H:%M:%S")
if me.ident not in gdklocks:
gdklocks[me.ident] = 0
# Ensure we don't deadlock if another thread is waiting on threads_enter
# while we wait on _rlock.acquire()
if me.getName() == "MainThread" and not has():
if debug:
print >> debug_stream, "%s %s: %s: glock.acquire: ---> threads_leave()" % (t, me.ident, me.name)
threads_leave()
gdklocks[me.ident] -= 1
if debug:
print >> debug_stream, "%s %s: %s: glock.acquire: <--- threads_leave()" % (t, me.ident, me.name)
# Acquire the lock, if it is not ours, or add one to the recursive counter
if debug:
print >> debug_stream, "%s %s: %s: glock.acquire: ---> _rlock.acquire()" % (t, me.ident, me.name)
_rlock.acquire()
if debug:
print >> debug_stream, "%s %s: %s: glock.acquire: <--- _rlock.acquire()" % (t, me.ident, me.name)
# If it is the first time we lock, we will acquire the gdklock
if _rlock._RLock__count == 1:
if debug:
print >> debug_stream, "%s %s: %s: glock.acquire: ---> threads_enter()" % (t, me.ident, me.name)
threads_enter()
gdklocks[me.ident] += 1
if debug:
print >> debug_stream, "%s %s: %s: glock.acquire: <--- threads_enter()" % (t, me.ident, me.name)
def get(self, timeout=None):
"""
'get' will block until the processed function returns, timeout
happens, or the work is cancelled. You can test if you were
cancelled by the isCancelled() method, and you can test if you
reached the timeout by the isAlive() method. Notice,
cancelling will not make 'get' unblock, besides if you build
'isCancelled' calls into your function.
Warning: the get function assumes that if you are the MainThread you
have the gdklock and if you are not the MainThread you don't have
the gdklock.
If this is not true, and the work is not done, calling get
will result in a deadlock.
If you haven't used the gtk.gdk.threads_enter nor
gtk.gdk.threads_leave function, everything should be fine."""
if not self.isDone():
if type(currentThread()) == _MainThread:
threads_leave()
self.join(timeout)
if type(currentThread()) == _MainThread:
threads_enter()
if self.isAlive():
return None
self.done = True
return self.result
def update_mem_map(self, mem_map): if self.mem_map == None: self.m_lock.acquire() self.mem_map = mem_map; self.m_lock.release() threads_enter() self.expose_cb(self.da, None) threads_leave() else: i ,x ,y = 0, 10, 26 cx, cy = self.get_size() while i < self.max_mapnr: if self.mem_map[i] == mem_map[i]: pass else: self.m_lock.acquire() self.mem_map[i] = mem_map[i] self.m_lock.release() threads_enter() v = int(self.mem_map[i], 16) self.da.window.draw_rectangle(self.gcs[v], True, x, y , 6, 6) self.da.window.draw_rectangle(self.style.black_gc, False, x, y , 6, 6) threads_leave() x = x + 8 i = i + 1 if x>= cx - 8: y = y + 8 x = 10
def loop(self):
gdk.threads_enter()
try:
gtk.main()
except KeyboardInterrupt:
print "Leaving on ^C"
gdk.threads_leave()
def update_txt(self, message, color=None):
gdk.threads_enter()
self.cfvGtk.append_string(message, color)
self.cfvGtk.progressbar.set_pulse_step(0.05)
self.cfvGtk.progressbar.pulse()
self.cfvGtk.progressbar.set_text("checking...")
gdk.threads_leave()
def start(self):
reactor.callWhenRunning(self._on_reactor_start)
# Initialize gdk threading
threads_enter()
reactor.run()
# Reactor no longer running so async callbacks (Deferreds) cannot be
# processed after this point.
threads_leave()
def start(self):
reactor.callWhenRunning(self._on_reactor_start)
# Initialize gdk threading
threads_enter()
reactor.run()
# Reactor no longer running so async callbacks (Deferreds) cannot be
# processed after this point.
threads_leave()
def run (self):
self.result = self.func(self)
self.done = True
if self.connections["done"] >= 1:
threads_enter()
# In python 2.5 we can use self.publishQueue.join() to wait for all
# publish items to have been processed.
self.emit("done")
threads_leave()
def add_gdk_calls(*args, **kwargs):
global gtk_fiddle_count
gtk_fiddle_count += 1
if not gtk_fiddle_count > 1:
gdk.threads_enter()
method(*args, **kwargs)
gtk_fiddle_count -= 1
if gtk_fiddle_count == 0:
gdk.threads_leave()
def run(self):
# print self.func_args
# print self.func_kwargs
self.result = self.func(self, *self.func_args, **self.func_kwargs)
self.done = True
if self.connections["done"] >= 1:
threads_enter()
# In python 2.5 we can use self.publishQueue.join() to wait for all
# publish items to have been processed.
self.emit("done")
threads_leave()
def On_Expose(canvas, evt):
gc = canvas.window.new_gc()
lb = canvas.window.new_gc()
cm = gc.get_colormap()
gdk.threads_enter()
for i in xrange(7):
color = cm.alloc_color(*index2rgb(i))
gc.set_foreground(color)
canvas.window.draw_rectangle(gc, True , 75, (2 * i + 1) * RowHght , canvas.ThrdInfo[i][1] , RowHght )
canvas.layout.set_text("%8d" % (canvas.ThrdInfo[i][0],))
canvas.window.draw_layout(lb, 5 , (2 * i + 1) * RowHght + canvas.TxtPad , canvas.layout)
#end for
gdk.threads_leave()
def acquire():
me = currentThread()
if me.ident not in gdklocks:
gdklocks[me.ident] = 0
# Ensure we don't deadlock if another thread is waiting on threads_enter
# while we wait on _rlock.acquire()
if me.getName() == "MainThread" and not has():
threads_leave()
gdklocks[me.ident] -= 1
# Acquire the lock, if it is not ours, or add one to the recursive counter
_rlock.acquire()
# If it is the first time we lock, we will acquire the gdklock
if _rlock._RLock__count == 1:
threads_enter()
gdklocks[me.ident] += 1
def __init__(self, conn):
self.__conn = conn
self.__path = SPEED_METER_PATH
# initiate parent class
super(SpeedMeter, self).__init__(self.__conn, self.__path)
# list for caculate typing speed
self.list = [(0, time.time(), 0)]
# do gui part here
self.create_ui()
# timer
self.full = False
self.c_time = 0
self.timer = Timer(self.update_speed)
gdk.threads_enter()
self.timer.start()
gdk.threads_leave()
# showing
self.run ()
def run (self):
while True:
v = self.queue.get()
if v == None:
break
threads_enter()
l = [v]
while True:
try:
v = self.queue.get_nowait()
except Queue.Empty:
break
else: l.append(v)
try:
if self.sendPolicy == self.SEND_LIST:
self.parrent.emit(self.signal, l)
elif self.sendPolicy == self.SEND_LAST:
self.parrent.emit(self.signal, l[-1])
finally:
threads_leave()
def run (self):
while True:
v = self.queue.get()
if v == None:
break
threads_enter()
l = [v]
while True:
try:
v = self.queue.get_nowait()
except Queue.Empty:
break
else: l.append(v)
try:
if self.sendPolicy == self.SEND_LIST:
self.parrent.emit(self.signal, l)
elif self.sendPolicy == self.SEND_LAST:
self.parrent.emit(self.signal, l[-1])
finally:
threads_leave()
def run(self):
threads_enter()
try:
f = open(self.filename,'rw+')
except:
f = open(self.filename, 'w')
try:
allconfig = json.loads(f.read())
except:
allconfig = {}
if self.namespace in allconfig:
results = self.action(self.context,allconfig[self.namespace])
else:
results = self.action(self.context,{})
if results != None:
f.seek(0)
allconfig[self.namespace] = results
f.write(json.dumps(allconfig))
f.truncate()
f.close()
threads_leave()
def download(self): threads_enter() try: self.lock.acquire() self.magic = self.uri self.lock.release() infile = urllib2.urlopen(self.uri) outfile = open(self.filename,'wb') outfile.truncate() outfile.write(infile.read()) self.expires = datetime.datetime.now()+self.lifetime self.lock.acquire() self.magic = self.filename self.lock.release() if self.done != None: self.done() finally: threads_leave()
def release():
me = currentThread()
# As it is the natural state for the MainThread to control the gdklock, we
# only release it if _rlock has been released so many times that we don't
# own it any more
if me.getName() == "MainThread":
if not has():
threads_leave()
gdklocks[me.ident] -= 1
else:
_rlock.release()
# If this is the last unlock, we also free the gdklock.
elif has():
if _rlock._RLock__count == 1:
threads_leave()
gdklocks[me.ident] -= 1
_rlock.release()
else:
t = time.strftime("%H:%M:%S")
print "%s %s: %s: Warning: Releasing nonowned glock has no effect\n" + \
"Traceback was: %s" % (t, me.ident, me.name, traceback.extract_stack())
def save(self, threaded = True):
''' Save a cacheitem to disk '''
print "Trying to get into save"
if threaded: threads_enter()
print "threads_enter success"
self.lock.acquire()
print "lock acquired"
try:
print "Trying to save"
self.lastSave = datetime.datetime.now()
index = open(os.path.join(self.dir, 'index'), 'w')
index.truncate()
res = {}
for resource in self.resources:
res[resource] = self.resources[resource].toJSON()
index.write(json.dumps({'index':self.index,
'resources':res
}))
print "saved"
finally:
index.close()
self.lock.release()
if threaded: threads_leave()
def Adjust(self, ThrdIx, Time, Value):
gdk.threads_enter()
gc = self.window.new_gc()
lb = self.window.new_gc()
cm = gc.get_colormap()
OldValue = self.ThrdInfo[ThrdIx][1]
if OldValue < Value:
color = cm.alloc_color(*index2rgb(ThrdIx))
base = 75 + OldValue
else:
color = self.style.bg[0]
base = 75 + Value
#end if
gc.set_foreground(color)
self.window.draw_rectangle(gc, True , base , (2 * ThrdIx + 1) * RowHght , abs(Value - OldValue) , RowHght)
self.layout.set_text("%8d" % (Time,))
self.window.begin_paint_rect((0, (2 * ThrdIx + 1) * RowHght, 75 , RowHght))
self.window.draw_layout(lb, 5 , (2 * ThrdIx + 1) * RowHght + self.TxtPad , self.layout)
self.window.end_paint()
gdk.flush()
gdk.threads_leave()
self.ThrdInfo[ThrdIx] = [Time, Value]
def release():
me = currentThread()
t = time.strftime("%H:%M:%S")
# As it is the natural state for the MainThread to control the gdklock, we
# only release it if _rlock has been released so many times that we don't
# own it any more
if me.getName() == "MainThread":
if not has():
if debug:
print >> debug_stream, "%s %s: %s: glock.release: ---> threads_leave()" % (t, me.ident, me.name)
threads_leave()
gdklocks[me.ident] -= 1
if debug:
print >> debug_stream, "%s %s: %s: glock.release: <--- threads_leave()" % (t, me.ident, me.name)
else:
if debug:
print >> debug_stream, "%s %s: %s: glock.release: ---> _rlock.release()" % (t, me.ident, me.name)
_rlock.release()
if debug:
print >> debug_stream, "%s %s: %s: glock.release: <--- _rlock.release()" % (t, me.ident, me.name)
# If this is the last unlock, we also free the gdklock.
elif has():
if _rlock._RLock__count == 1:
if debug:
print >> debug_stream, "%s %s: %s: glock.release: ---> threads_leave()" % (t, me.ident, me.name)
threads_leave()
gdklocks[me.ident] -= 1
if debug:
print >> debug_stream, "%s %s: %s: glock.release: <--- threads_leave()" % (t, me.ident, me.name)
if debug:
print >> debug_stream, "%s %s: %s: glock.release: ---> _rlock.release()" % (t, me.ident, me.name)
_rlock.release()
if debug:
print >> debug_stream, "%s %s: %s: glock.release: <--- _rlock.release()" % (t, me.ident, me.name)
else:
print "%s %s: %s: Warning: Tried to release unowned glock\nTraceback was: %s" % \
(t, me.ident, me.name, traceback.extract_stack())
def run(self):
threads_enter()
pipe = popen(self.command,"r")
threads_leave()
self.output = pipe.read()
def update_done(self, message):
gdk.threads_enter()
self.cfvGtk.append_string(message)
self.cfvGtk.progressbar.set_fraction(1.0)
self.cfvGtk.progressbar.set_text("done")
gdk.threads_leave()
def serve_forever(self):
gdk.threads_enter()
gtk.main()
gdk.threads_leave()
def _wrapped(*k, **kw):
try:
func(*k, **kw)
finally:
gdk.threads_leave()
def __init__(self, func, *func_args, **func_kwargs):
""" Initialize a new GtkWorker around a specific function """
# WARNING: This deadlocks if calling code already has the gdk lock and
# is not the MainThread
if type(currentThread()) != _MainThread:
threads_enter()
GObject.__init__(self)
if type(currentThread()) != _MainThread:
threads_leave()
Thread.__init__(self, args=func_args, kwargs=func_kwargs)
self.func_args = func_args
self.func_kwargs = func_kwargs
self.setDaemon(True)
# By some reason we cannot access __gsignals__, so we have to do a
# little double work here
self.connections = {"progressed": 0, "published": 0, "done": 0}
self.handler_ids = {}
self.func = func
self.cancelled = False
self.done = False
self.progress = 0
#######################################################################
# Publish and progress queues #
#######################################################################
class Publisher(Thread):
SEND_LIST, SEND_LAST = range(2)
def __init__(self, parrent, queue, signal, sendPolicy):
Thread.__init__(self)
self.setDaemon(True)
self.parrent = parrent
self.queue = queue
self.signal = signal
self.sendPolicy = sendPolicy
def run(self):
while True:
v = self.queue.get()
if v is None:
break
threads_enter()
l = [v]
while True:
try:
v = self.queue.get_nowait()
except Queue.Empty:
break
else:
l.append(v)
try:
if self.sendPolicy == self.SEND_LIST:
self.parrent.emit(self.signal, l)
elif self.sendPolicy == self.SEND_LAST:
self.parrent.emit(self.signal, l[-1])
finally:
threads_leave()
self.publishQueue = Queue.Queue()
self.publisher = Publisher(self, self.publishQueue, "published",
Publisher.SEND_LIST)
self.publisher.start()
self.progressQueue = Queue.Queue()
self.progressor = Publisher(self, self.progressQueue, "progressed",
Publisher.SEND_LAST)
self.progressor.start()
def serve_forever(self):
gdk.threads_enter()
gtk.main()
gdk.threads_leave()
def __init__(self):
threads_enter()
gobject.type_register(VideoWidget)
gobject.type_register(ShowBox)
gobject.type_register(Configer)
gobject.type_register(DescriptionWindow)
gobject.type_register(SearchBar)
locale.setlocale(locale.LC_ALL,locale.getdefaultlocale())
factory=gtk.IconFactory()
try:
f=self.get_resource('pixmaps/bookmark.png')
loader=gtk.gdk.PixbufLoader()
loader.write(f.read())
f.close()
factory.add(self.STOCK_BOOKMARK,gtk.IconSet(loader.get_pixbuf()))
loader.close()
except:
raise
factory.add_default()
gtk.stock_add(((self.STOCK_BOOKMARK, "_Bookmarks", gtk.gdk.CONTROL_MASK, gtk.gdk.keyval_from_name('B'), "youtube-show",),))
self.userDir=UserDir()
self.config=Config(self.userDir.get_conf_file())
self.config.load()
self.bookmarks=Bookmarks.Bookmarks(self.userDir.get_file('bookmarks'))
self.bookmarks.load()
self.caches=YoutubeConnector.CacheSaver(self.userDir.get_file('caches.txt'))
self.cookies=CookieJar()
self.downloader=urllib2.build_opener(urllib2.HTTPCookieProcessor(self.cookies))
self.ytsearcher = YoutubeConnector.YTSearcher(self.downloader)
self.ytconnector = YoutubeConnector.YTConnector(self.downloader, self.caches)
self.searching = threading.Event()
self.is_fullscreen=False
self.history=History()
self.viewer = Viewer.Viewer()
self.win = gtk.Window(gtk.WINDOW_TOPLEVEL)
if not self.win:
raise RuntimeError()
self.win.connect('delete_event', self.cleanup)
self.win.connect('destroy', self.destroy)
self.win.connect('key_press_event', self.on_key_press)
self.win.connect_object('window-state-event', self.on_window_state_change,self)
self.build_menu_bar()
self.build_tool_bar()
self.showbox = ShowBox()
self.showbox.connect('scroll-end-event', self.do_next_search)
self.showbox.show()
self.statusbar = gtk.Statusbar()
self.statusbar.show()
self.progressbar = gtk.ProgressBar()
self.statusbar.add(self.progressbar)
self.align = gtk.VBox()
self.align.pack_start(self.menubar, expand=False, fill=True)
self.align.pack_start(self.toolbar, expand=False, fill=True)
self.align.pack_start(self.showbox, expand=True, fill=True)
self.align.pack_start(self.statusbar, expand=False, fill=True)
self.statusbar.push(1, 'Ready')
self.apply_config()
self.align.show()
self.win.add(self.align)
self.win.set_title("youtube-show")
theme=gtk.icon_theme_get_for_screen(gtk.gdk.screen_get_default())
try:
icon=theme.load_icon('youtube_show',48,0)
self.win.set_icon(icon)
except:
try:
with self.get_resource('pixmaps/youtube-show.png') as iconfile:
loader=gdk.PixbufLoader()
loader.write(iconfile.read())
self.win.set_icon(loader.get_pixbuf())
loader.close()
except:
pass
w,h=self.config['size']
if w>-1 and h>-1:
self.win.resize(w,h)
else:
self.win.resize(500, 600)
self.win.show()
threads_leave()
def quit( self ):
gtk.main_quit()
gdk.threads_leave()
self.timer.join()
def quit_from_timer( self ):
gtk.main_quit()
gdk.threads_leave()
def __init__(self, func, *func_args, **func_kwargs):
""" Initialize a new GtkWorker around a specific function """
# WARNING: This deadlocks if calling code already has the gdk lock and
# is not the MainThread
if type(currentThread()) != _MainThread:
threads_enter()
GObject.__init__(self)
if type(currentThread()) != _MainThread:
threads_leave()
Thread.__init__(self, args=func_args, kwargs=func_kwargs)
self.func_args = func_args
self.func_kwargs = func_kwargs
self.setDaemon(True)
# By some reason we cannot access __gsignals__, so we have to do a
# little double work here
self.connections = {"progressed": 0, "published": 0, "done": 0}
self.handler_ids = {}
self.func = func
self.cancelled = False
self.done = False
self.progress = 0
#######################################################################
# Publish and progress queues #
#######################################################################
class Publisher(Thread):
SEND_LIST, SEND_LAST = range(2)
def __init__(self, parrent, queue, signal, sendPolicy):
Thread.__init__(self)
self.setDaemon(True)
self.parrent = parrent
self.queue = queue
self.signal = signal
self.sendPolicy = sendPolicy
def run(self):
while True:
v = self.queue.get()
if v is None:
break
threads_enter()
l = [v]
while True:
try:
v = self.queue.get_nowait()
except Queue.Empty:
break
else:
l.append(v)
try:
if self.sendPolicy == self.SEND_LIST:
self.parrent.emit(self.signal, l)
elif self.sendPolicy == self.SEND_LAST:
self.parrent.emit(self.signal, l[-1])
finally:
threads_leave()
self.publishQueue = Queue.Queue()
self.publisher = Publisher(self, self.publishQueue, "published", Publisher.SEND_LIST)
self.publisher.start()
self.progressQueue = Queue.Queue()
self.progressor = Publisher(self, self.progressQueue, "progressed", Publisher.SEND_LAST)
self.progressor.start()
def __init__(self):
threads_enter()
gobject.type_register(VideoWidget)
gobject.type_register(ShowBox)
gobject.type_register(Configer)
gobject.type_register(DescriptionWindow)
gobject.type_register(SearchBar)
locale.setlocale(locale.LC_ALL, locale.getdefaultlocale())
factory = gtk.IconFactory()
try:
f = self.get_resource('pixmaps/bookmark.png')
loader = gtk.gdk.PixbufLoader()
loader.write(f.read())
f.close()
factory.add(self.STOCK_BOOKMARK, gtk.IconSet(loader.get_pixbuf()))
loader.close()
except:
raise
factory.add_default()
gtk.stock_add(((
self.STOCK_BOOKMARK,
"_Bookmarks",
gtk.gdk.CONTROL_MASK,
gtk.gdk.keyval_from_name('B'),
"youtube-show",
), ))
self.userDir = UserDir()
self.config = Config(self.userDir.get_conf_file())
self.config.load()
self.bookmarks = Bookmarks.Bookmarks(
self.userDir.get_file('bookmarks'))
self.bookmarks.load()
self.caches = YoutubeConnector.CacheSaver(
self.userDir.get_file('caches.txt'))
self.cookies = CookieJar()
self.downloader = urllib2.build_opener(
urllib2.HTTPCookieProcessor(self.cookies))
self.ytsearcher = YoutubeConnector.YTSearcher(self.downloader)
self.ytconnector = YoutubeConnector.YTConnector(
self.downloader, self.caches)
self.searching = threading.Event()
self.is_fullscreen = False
self.history = History()
self.viewer = Viewer.Viewer()
self.win = gtk.Window(gtk.WINDOW_TOPLEVEL)
if not self.win:
raise RuntimeError()
self.win.connect('delete_event', self.cleanup)
self.win.connect('destroy', self.destroy)
self.win.connect('key_press_event', self.on_key_press)
self.win.connect_object('window-state-event',
self.on_window_state_change, self)
self.build_menu_bar()
self.build_tool_bar()
self.showbox = ShowBox()
self.showbox.connect('scroll-end-event', self.do_next_search)
self.showbox.show()
self.statusbar = gtk.Statusbar()
self.statusbar.show()
self.progressbar = gtk.ProgressBar()
self.statusbar.add(self.progressbar)
self.align = gtk.VBox()
self.align.pack_start(self.menubar, expand=False, fill=True)
self.align.pack_start(self.toolbar, expand=False, fill=True)
self.align.pack_start(self.showbox, expand=True, fill=True)
self.align.pack_start(self.statusbar, expand=False, fill=True)
self.statusbar.push(1, 'Ready')
self.apply_config()
self.align.show()
self.win.add(self.align)
self.win.set_title("youtube-show")
theme = gtk.icon_theme_get_for_screen(gtk.gdk.screen_get_default())
try:
icon = theme.load_icon('youtube_show', 48, 0)
self.win.set_icon(icon)
except:
try:
with self.get_resource('pixmaps/youtube-show.png') as iconfile:
loader = gdk.PixbufLoader()
loader.write(iconfile.read())
self.win.set_icon(loader.get_pixbuf())
loader.close()
except:
pass
w, h = self.config['size']
if w > -1 and h > -1:
self.win.resize(w, h)
else:
self.win.resize(500, 600)
self.win.show()
threads_leave()
def wrapper(obj, *args): gdk.threads_leave() handler(obj, *args) gdk.threads_enter()
