def clipboard_nesting_check(self, action, packet_type, ss):
clipboardlog("clipboard_nesting_check(%s, %s, %s)", action,
packet_type, ss)
cc = self._clipboard_client
if cc is None:
clipboardlog("not %s clipboard packet '%s': no clipboard client",
action, packet_type)
return False
if not cc.clipboard_enabled:
clipboardlog(
"not %s clipboard packet '%s': client %s has clipboard disabled",
action, packet_type, cc)
return False
if gtk.main_level() >= 10:
clipboardlog.warn("Warning: loop nesting too deep: %s",
gtk.main_level())
clipboardlog.warn(
" you may have a clipboard forwarding loop, disabling the clipboard"
)
#turn off clipboard at our end:
self.set_clipboard_enabled_status(ss, False)
#if we can, tell the client to do the same:
if ss.clipboard_set_enabled:
ss.send_clipboard_enabled("probable clipboard loop detected")
return False
return True
def _run_gtk_main(self):
print("_run_gtk_main")
print(gtk.main_level())
if gtk.main_level() < 3:
gobject.timeout_add(0, self._run_gtk_main)
else:
gobject.timeout_add(0, wimpiggy.util.gtk_main_quit_really)
gtk.main()
return False
def _run_gtk_main(self):
print("_run_gtk_main")
print(gtk.main_level())
if gtk.main_level() < 3:
gobject.timeout_add(0, self._run_gtk_main)
else:
gobject.timeout_add(0, wimpiggy.util.gtk_main_quit_really)
gtk.main()
return False
def process_clipboard_packet(self, packet):
clipboardlog("process_clipboard_packet(%s) level=%s", packet, gtk.main_level())
#check for clipboard loops:
if gtk.main_level()>=40:
clipboardlog.warn("loop nesting too deep: %s", gtk.main_level())
clipboardlog.warn("you may have a clipboard forwarding loop, disabling the clipboard")
self.clipboard_enabled = False
self.emit("clipboard-toggled")
return
self.idle_add(self.clipboard_helper.process_clipboard_packet, packet)
def process_clipboard_packet(self, packet):
clipboardlog("process_clipboard_packet(%s) level=%s", packet, gtk.main_level())
#check for clipboard loops:
if gtk.main_level()>=40:
clipboardlog.warn("loop nesting too deep: %s", gtk.main_level())
clipboardlog.warn("you may have a clipboard forwarding loop, disabling the clipboard")
self.clipboard_enabled = False
self.emit("clipboard-toggled")
return
self.idle_add(self.clipboard_helper.process_clipboard_packet, packet)
def terminate_program(self, save_current_file=False):
"""Run clean-up tasks and exit the program."""
self.hide()
if gtk.main_level() > 0:
gtk.main_quit()
if prefs['auto load last file'] and self.filehandler.file_loaded:
prefs['path to last file'] = self.imagehandler.get_real_path()
prefs['page of last file'] = self.imagehandler.get_current_page()
else:
prefs['path to last file'] = ''
prefs['page of last file'] = 1
if prefs['hide all'] and self.hide_all_forced and self.fullscreen:
prefs['hide all'] = False
self.write_config_files()
self.filehandler.cleanup()
self.imagehandler.cleanup()
self.thumbnailsidebar.clear()
backend.LibraryBackend().close()
# This hack is to avoid Python issue #1856.
for thread in threading.enumerate():
if thread is not threading.currentThread():
thread.join()
def terminate_program(self):
"""Run clean-up tasks and exit the program."""
self.hide()
if gtk.main_level() > 0:
gtk.main_quit()
if prefs['auto load last file'] and self.filehandler.file_loaded:
prefs['path to last file'] = self.imagehandler.get_real_path()
prefs['page of last file'] = self.imagehandler.get_current_page()
else:
prefs['path to last file'] = ''
prefs['page of last file'] = 1
if prefs['hide all'] and self.hide_all_forced and self.fullscreen:
prefs['hide all'] = False
self.write_config_files()
self.filehandler.close_file()
if main_dialog._dialog is not None:
main_dialog._dialog.close()
backend.LibraryBackend().close()
# This hack is to avoid Python issue #1856.
for thread in threading.enumerate():
if thread is not threading.currentThread():
log.debug('Waiting for thread %s to finish before exit', thread)
thread.join()
def close_application(self, widget, event=None, data=None):
"""Termination"""
if self.rendering_thread:
self.rendering_thread.quit = True
self.rendering_thread.join()
if os.path.isdir(self.tmp_dir):
try:
shutil.rmtree(self.tmp_dir)
except:
# ============= Start python-poppler for Windows bug workaround ============
# python-poppler does not "release" the file and only the files of previous sessions can be deleted
# Get the list of all pdf-shuffler temporary dirs
temp_dir_root = os.path.split(self.tmp_dir)[0]
shuffler_dirs = glob.glob(temp_dir_root +
"/tmp??????pdfshuffler")
# delete if possible
for directory in shuffler_dirs:
try:
shutil.rmtree(directory)
except:
pass
# ============= End python-poppler for Windows bug workaround ==============
if gtk.main_level():
gtk.main_quit()
else:
sys.exit(0)
return False
def quit_cb (self, *args):
self.w.hide()
if (self.gsd.grid
and self.gsd.grid.is_changed()
and (not self.won)):
self.save_game(self)
if gtk.main_level() > 1:
# If we are in an embedded mainloop, that means that one
# of our "swallowed" dialogs is active, in which case we
# have to quit that mainloop before we can quit
# properly.
if self.swallower.running:
d = self.swallower.running
d.response(gtk.RESPONSE_DELETE_EVENT)
gtk.main_quit() # Quit the embedded mainloop
gobject.idle_add(self.quit_cb, 100) # Call ourselves again
# to quit the main
# mainloop
return
# make sure we really go away before doing our saving --
# otherwise we appear sluggish.
while gtk.events_pending():
gtk.main_iteration()
self.stop_worker_thread()
# allow KeyboardInterrupts, which calls quit_cb outside the main loop
try:
gtk.main_quit()
except RuntimeError:
pass
def terminate_program(self, save_current_file=False):
"""Run clean-up tasks and exit the program."""
self.hide()
if gtk.main_level() > 0:
gtk.main_quit()
if prefs['auto load last file'] and self.filehandler.file_loaded:
prefs['path to last file'] = self.imagehandler.get_real_path()
prefs['page of last file'] = self.imagehandler.get_current_page()
else:
prefs['path to last file'] = ''
prefs['page of last file'] = 1
if prefs['hide all'] and self.hide_all_forced and self.fullscreen:
prefs['hide all'] = False
self.write_config_files()
self.filehandler.cleanup()
self.imagehandler.cleanup()
self.thumbnailsidebar.clear()
backend.LibraryBackend().close()
# This hack is to avoid Python issue #1856.
for thread in threading.enumerate():
if thread is not threading.currentThread():
thread.join()
def _DOM_ready(self):
document = self.__webkit.GetDomDocument()
window = self.__webkit.GetDomWindow()
document.addEventListener('DOMNodeInserted', self._DOM_node_inserted,
False)
document.addEventListener('DOMNodeRemoved', self._DOM_node_removed,
False)
document.addEventListener('DOMAttrModified', self._DOM_node_attr_modified,
False)
document.addEventListener('DOMCharacterDataModified', self._DOM_node_data_modified,
False)
#print >> sys.stderr, "URL:", document.URL
#print >> sys.stderr, "Title:", document.title
#print >> sys.stderr, "Cookies:", document.cookie
#print body, dir(body)
#print "INNER:", document.innerHTML
#print "OUTER:", body.outerHTML
#print dir(document)
#print str(document)
# Save results so that we can return it on visit() calls.
self.result = document.title, document.cookie, document.body.outerHTML
self.walker.walk_node(document)
# _DOM_ready may be called before we call gtk.main() -- see
# visit() -- in which case calling mainquit is invalid. We check
# for that here.
if gtk.main_level() > 0:
gtk.mainquit()
def __timeout_callback(self):
debug("Timeout Callback")
if gtk.main_level() > 0:
gtk.mainquit()
# Set a flag so that the main thread knows to raise a
# TimeoutException.
self.timed_out = True
def __call__(self, exctyp, value, tback):
# type: (Type[BaseException], BaseException, Any) -> None
"""Custom sys.excepthook callback which displays a GTK+ dialog"""
# pylint: disable=no-member
dialog = self.make_info_dialog()
while True:
resp = dialog.run()
if resp == 3:
if self.cached_tb is None:
self.cached_tb = analyse(exctyp, value, tback).getvalue()
self.send_report(self.cached_tb)
elif resp == 2:
if self.cached_tb is None:
self.cached_tb = analyse(exctyp, value, tback).getvalue()
details = self.make_details_dialog(dialog, self.cached_tb)
details.run()
details.destroy()
elif resp == 1 and gtk.main_level() > 0:
gtk.main_quit()
# Only the "Details" dialog loops back when closed
if resp != 2:
break
dialog.destroy()
def _dump_recursion_info():
# This is how deeply nested in recursive main-loops we are:
print("gtk depth: %s" % (gtk.main_level()))
import ctypes
class ThreadState(ctypes.Structure):
_fields_ = [("next", ctypes.c_voidp),
("interp", ctypes.c_voidp),
("frame", ctypes.c_voidp),
("recursion_depth", ctypes.c_int)]
ts = ctypes.cast(ctypes.pythonapi.PyThreadState_Get(),
ctypes.POINTER(ThreadState))
# This is Python's count of the recursion depth -- i.e., the thing that
# will eventually trigger the 'Maximum recursion depth exceeded' message.
print("python internal depth: %s" % ts[0].recursion_depth)
import inspect
count = 0
frame = inspect.currentframe()
while frame:
frame = frame.f_back
count += 1
# This is the number of frames in the current stack. It probably only
# counts up to the last call to gtk.main().
print("stack frames: %s" % count)
# The number of NestedMainLoops in progress:
print("NestedMainLoops: %s" % len(NestedMainLoop._stack))
def _gui_excepthook_generic(
exc_type,
exc_value,
exc_traceback,
orig_sys_excepthook,
title,
app_name,
parent,
report_uri_list):
callback_result = _gui_excepthook_additional_callback(
exc_type, exc_value, exc_traceback)
if callback_result:
return
orig_sys_excepthook(exc_type, exc_value, exc_traceback)
if issubclass(exc_type, Exception):
exception_message = "".join(
traceback.format_exception(exc_type, exc_value, exc_traceback))
display_error_message(
title=title,
app_name=app_name,
parent=parent,
details=exception_message,
report_uri_list=report_uri_list)
# Make sure to quit the application since unhandled exceptions can
# mess up the application state.
if gtk.main_level() > 0:
gtk.main_quit()
def __call__(self, exctyp, value, tback):
# type: (Type[BaseException], BaseException, Any) -> None
"""Custom sys.excepthook callback which displays a GTK+ dialog"""
# pylint: disable=no-member
dialog = self.make_info_dialog()
while True:
resp = dialog.run()
if resp == 3:
if self.cached_tb is None:
self.cached_tb = analyse(exctyp, value, tback).getvalue()
self.send_report(self.cached_tb)
elif resp == 2:
if self.cached_tb is None:
self.cached_tb = analyse(exctyp, value, tback).getvalue()
details = self.make_details_dialog(dialog, self.cached_tb)
details.run()
details.destroy()
elif resp == 1 and gtk.main_level() > 0:
gtk.main_quit()
# Only the "Details" dialog loops back when closed
if resp != 2:
break
dialog.destroy()
def _dialog_response_cb(dialog, resp, trace, exctyp, value):
global exception_dialog_active
if resp == RESPONSE_QUIT and gtk.main_level() > 0:
if not quit_confirmation_func:
sys.exit(1) # Exit code is important for IDEs
else:
if quit_confirmation_func():
sys.exit(1) # Exit code is important for IDEs
else:
dialog.destroy()
exception_dialog_active = False
elif resp == RESPONSE_SEARCH:
search_url = ("https://github.com/mypaint/mypaint/search"
"?utf8=%E2%9C%93"
"&q={}+{}"
"&type=Issues").format(quote_plus(exctyp.__name__, "/"),
quote_plus(str(value), "/"))
gtk.show_uri(None, search_url, gtk.gdk.CURRENT_TIME)
if "-" in lib.meta.MYPAINT_VERSION:
dialog.set_response_sensitive(RESPONSE_REPORT, True)
elif resp == RESPONSE_REPORT:
#TRANSLATORS: Crash report template for github, preceding a traceback.
#TRANSLATORS: Please ask users kindly to supply at least an English
#TRANSLATORS: title if they are able.
body = _(u"""\
#### Description
Give this report a short descriptive title.
Use something like
"{feature-that-broke}: {what-went-wrong}"
for the title, if you can.
Then please replace this text
with a longer description of the bug.
Screenshots or videos are great, too!
#### Steps to reproduce
Please tell us what you were doing
when the error message popped up.
If you can provide step-by-step instructions
on how to reproduce the bug,
that's even better.
#### Traceback
""")
body = "\n\n".join([
"".join(textwrap.wrap(p, sys.maxint))
for p in textwrap.dedent(body).split("\n\n")
] + [trace])
report_url = ("https://github.com/mypaint/mypaint/issues/new"
"?title={title}"
"&body={body}").format(
title="",
body=quote_plus(body.encode("utf-8"), "/"),
)
gtk.show_uri(None, report_url, gtk.gdk.CURRENT_TIME)
else:
dialog.destroy()
exception_dialog_active = False
def funcBack(statwin):
#gtk.threads_enter()
#gtk.threads_leave()
import time
print "Went ..."
sys.stdout.write("cp2-0\n")
sys.stdout.flush()
#statwin.grab_remove()
sys.stdout.write("cp2-1: " + ` gtk.main_level() ` + "\n")
sys.stdout.write("cp2-2: " + ` threading.activeCount() ` + "\n")
#gtk.threads_leave()
#gtk.threads_enter()
sys.stdout.write("cp2-3\n")
sys.stdout.flush()
#gtk.block_
#gtk.threads_enter()
win = gtk.MessageDialog(None, gtk.DIALOG_MODAL, \
gtk.MESSAGE_INFO, gtk.BUTTONS_OK, "Hello" )
#gtk.threads_leave()
sys.stdout.write("cp2-3.1\n")
sys.stdout.flush()
#gtk.threads_leave()
sys.stdout.write("cp2-4\n")
sys.stdout.flush()
win.show_all()
win.run()
win.destroy()
win.hide_all()
del win
print "Back!"
def quit_cb (self, *args):
self.w.hide()
if (self.gsd.grid
and self.gsd.grid.is_changed()
and (not self.won)):
self.save_game(self)
if gtk.main_level() > 1:
# If we are in an embedded mainloop, that means that one
# of our "swallowed" dialogs is active, in which case we
# have to quit that mainloop before we can quit
# properly.
if self.swallower.running:
d = self.swallower.running
d.response(gtk.RESPONSE_DELETE_EVENT)
gtk.main_quit() # Quit the embedded mainloop
gobject.idle_add(self.quit_cb, 100) # Call ourselves again
# to quit the main
# mainloop
return
# make sure we really go away before doing our saving --
# otherwise we appear sluggish.
while gtk.events_pending():
gtk.main_iteration()
self.stop_worker_thread()
# allow KeyboardInterrupts, which calls quit_cb outside the main loop
try:
gtk.main_quit()
except RuntimeError:
pass
def _make_window():
window = gtk.Window()
logging.info(dir(gtk))
v=gtk.VBox()
button1=gtk.Button()
button1.set_label("hi")
text1=gtk.Entry()
logging.info(dir(text1))
window.set_title("pyconsole.py")
swin = gtk.ScrolledWindow()
swin.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_ALWAYS)
#window.add(swin)#FileChooserDialog
console = Console(banner="Hello there!",
use_rlcompleter=False,
start_script="from gtk import *\n")
v.add(button1)
v.add(text1)
text1.set_text("hello")
swin.add(console)
v.add(swin)
window.add(v)
#logging.info(dir(button1))
button1.connect("clicked",button1_click,window)
window.set_default_size(500, 400)
window.show_all()
if not gtk.main_level():
window.connect("destroy", gtk.main_quit)
gtk.main()
return console
def funcBack(statwin):
# gtk.threads_enter()
# gtk.threads_leave()
import time
print "Went ..."
sys.stdout.write("cp2-0\n")
sys.stdout.flush()
# statwin.grab_remove()
sys.stdout.write("cp2-1: " + ` gtk.main_level() ` + "\n")
sys.stdout.write("cp2-2: " + ` threading.activeCount() ` + "\n")
# gtk.threads_leave()
# gtk.threads_enter()
sys.stdout.write("cp2-3\n")
sys.stdout.flush()
# gtk.block_
# gtk.threads_enter()
win = gtk.MessageDialog(None, gtk.DIALOG_MODAL, gtk.MESSAGE_INFO, gtk.BUTTONS_OK, "Hello")
# gtk.threads_leave()
sys.stdout.write("cp2-3.1\n")
sys.stdout.flush()
# gtk.threads_leave()
sys.stdout.write("cp2-4\n")
sys.stdout.flush()
win.show_all()
win.run()
win.destroy()
win.hide_all()
del win
print "Back!"
def on_delete_event(self, *args):
self.quit = True
self.hide()
if self.child_pid:
os.kill(self.child_pid, signal.SIGKILL)
if gtk.main_level():
gtk.main_quit()
def destroy(self, *args):
if _debug:
print "FigureManagerGTK.%s" % fn_name()
self.window.destroy()
if Gcf.get_num_fig_managers() == 0 and not matplotlib.is_interactive() and gtk.main_level() >= 1:
gtk.main_quit()
def on_delete_event(self, *args):
self.quit = True
self.hide()
if self.child_pid:
os.kill(self.child_pid, signal.SIGKILL)
if gtk.main_level():
gtk.main_quit()
def terminate_program(self):
"""Run clean-up tasks and exit the program."""
self.hide()
if gtk.main_level() > 0:
gtk.main_quit()
if prefs['auto load last file'] and self.filehandler.file_loaded:
prefs['path to last file'] = self.imagehandler.get_real_path()
prefs['page of last file'] = self.imagehandler.get_current_page()
else:
prefs['path to last file'] = ''
prefs['page of last file'] = 1
if prefs['hide all'] and self.hide_all_forced and self.fullscreen:
prefs['hide all'] = False
self.write_config_files()
self.filehandler.close_file()
if main_dialog._dialog is not None:
main_dialog._dialog.close()
backend.LibraryBackend().close()
# This hack is to avoid Python issue #1856.
for thread in threading.enumerate():
if thread is not threading.currentThread():
log.debug('Waiting for thread %s to finish before exit',
thread)
thread.join()
def _dump_recursion_info():
# This is how deeply nested in recursive main-loops we are:
print("gtk depth: %s" % (gtk.main_level()))
import ctypes
class ThreadState(ctypes.Structure):
_fields_ = [("next", ctypes.c_voidp), ("interp", ctypes.c_voidp),
("frame", ctypes.c_voidp),
("recursion_depth", ctypes.c_int)]
ts = ctypes.cast(ctypes.pythonapi.PyThreadState_Get(),
ctypes.POINTER(ThreadState))
# This is Python's count of the recursion depth -- i.e., the thing that
# will eventually trigger the 'Maximum recursion depth exceeded' message.
print("python internal depth: %s" % ts[0].recursion_depth)
import inspect
count = 0
frame = inspect.currentframe()
while frame:
frame = frame.f_back
count += 1
# This is the number of frames in the current stack. It probably only
# counts up to the last call to gtk.main().
print("stack frames: %s" % count)
# The number of NestedMainLoops in progress:
print("NestedMainLoops: %s" % len(NestedMainLoop._stack))
def destroy(self, *args):
if _debug: print 'FigureManagerGTK.%s' % fn_name()
self.window.destroy()
if Gcf.get_num_fig_managers()==0 and \
not matplotlib.is_interactive() and \
gtk.main_level() >= 1:
gtk.main_quit()
def _on_destroy_window(self, window):
self.remove_window(window)
if not self._windows:
import gtk
logger.debug('Last toplevel destroyed, quit')
if gtk.main_level() > 0:
gtk.main_quit()
def _Run(self):
"""Enter GTK mainloop."""
self._GetNativeApp()
if gtk.main_level() == 0:
# We need to start the mainloop. This means we will also
# have to kill the mainloop when the last figure is closed.
gtk.vv_do_quit = True
gtk.main()
def gtk_main_quit_really():
# We import gtk inside here, rather than at the top of the file, because
# importing gtk has the side-effect of trying to connect to the X server
# (and this process may block, may cause us to later be killed if the X
# server goes away, etc.), and we don't want to impose that on every user
# of wimpiggy.util.
import gtk
for i in xrange(gtk.main_level()):
gtk.main_quit()
def show(mainloop=True):
"""
Show all the figures and enter the gtk main loop
This should be the last line of your script
"""
for manager in Gcf.get_all_fig_managers():
manager.window.show()
if mainloop and gtk.main_level() == 0 and len(Gcf.get_all_fig_managers()) > 0:
gtk.main()
def _Run(self):
"""Enter GTK mainloop."""
self._GetNativeApp()
if gtk.main_level() == 0:
# We need to start the mainloop. This means we will also
# have to kill the mainloop when the last figure is closed.
gtk.vv_do_quit = True
gtk.main()
def _our_mainquit():
# XXX: gtk.main_quit() (which is used for crash()) raises an exception if
# gtk.main_level() == 0; however, all the tests freeze if we use this
# function to stop the reactor. what gives? (I believe this may have been
# a stupid mistake where I forgot to import gtk here... I will remove this
# comment if the tests pass)
import gtk
if gtk.main_level():
gtk.main_quit()
def crash(self):
selectreactor.SelectReactor.crash(self)
import gtk
# mainquit is deprecated in newer versions
if gtk.main_level():
if hasattr(gtk, 'main_quit'):
gtk.main_quit()
else:
gtk.mainquit()
def crash(self):
selectreactor.SelectReactor.crash(self)
import gtk
# mainquit is deprecated in newer versions
if gtk.main_level():
if hasattr(gtk, 'main_quit'):
gtk.main_quit()
else:
gtk.mainquit()
def _our_mainquit():
# XXX: gtk.main_quit() (which is used for crash()) raises an exception if
# gtk.main_level() == 0; however, all the tests freeze if we use this
# function to stop the reactor. what gives? (I believe this may have been
# a stupid mistake where I forgot to import gtk here... I will remove this
# comment if the tests pass)
import gtk
if gtk.main_level():
gtk.main_quit()
def show(self):
self.init_video()
gobject.timeout_add(200, self.run)
#gobject.idle_add(self.run)
gtk.Window.show(self)
if not gtk.main_level():
gtk.quit_add(0, self.drone.stop, True)
gobject.threads_init()
gtk.main()
def show(exctype, value, tb):
if exctype is not KeyboardInterrupt:
dw = DebugWindow()
dw.show_exception(exctype, value, tb)
dw.show_all()
if not gtk.main_level():
def q(window):
gtk.main_quit()
dw.connect('destroy', q)
gtk.main()
def stop(self, widget, event=None):
print "Shutting down GUI\r"
self.posmap.save_map()
# ofile = open("./testdata/task.data", "w")
# pickle.dump(self.tasks, ofile)
# ofile.close()
if gtk.main_level() > 0:
gtk.main_quit()
self.drone.stop(True)
def show(mainloop=True):
"""
Show all the figures and enter the gtk main loop
This should be the last line of your script
"""
for manager in Gcf.get_all_fig_managers():
manager.window.show()
if mainloop and gtk.main_level() == 0:
gtk.main()
def process_clipboard_packet(self, packet):
clipboardlog("process_clipboard_packet(%s) level=%s", packet,
gtk.main_level())
#check for clipboard loops:
from xpra.clipboard.clipboard_base import nesting_check
if not nesting_check():
self.clipboard_enabled = False
self.emit("clipboard-toggled")
return
self.idle_add(self.clipboard_helper.process_clipboard_packet, packet)
def gtk2main():
import pygtk
pygtk.require('2.0')
import gtk
if gtk.main_level()==0:
gtk.gdk.threads_init()
try:
gtk.threads_enter()
gtk.main()
finally:
gtk.threads_leave()
def gui_excepthook(exc_type, exc_value, exc_traceback):
orig_sys_excepthook(exc_type, exc_value, exc_traceback)
if issubclass(exc_type, Exception):
exception_message = "".join(traceback.format_exception(exc_type, exc_value, exc_traceback))
display_exception_message(exception_message, plugin_title=plugin_title,
report_uri_list=report_uri_list, parent=_gui_excepthook_parent)
# Make sure to quit the application since unhandled exceptions can
# mess up the application state.
if gtk.main_level() > 0:
gtk.main_quit()
def show(mainloop=True):
"""
Show all the figures and enter the gtk main loop
This should be the last line of your script
"""
for manager in Gcf.get_all_fig_managers():
manager.window.show()
if mainloop and gtk.main_level() == 0:
if gtk.pygtk_version >= (2,4,0): gtk.main()
else: gtk.mainloop()
def destroy(self, *args):
if _debug:
print "FigureManagerGTK.%s" % fn_name()
self.vbox.destroy()
self.window.destroy()
self.canvas.destroy()
if self.toolbar:
self.toolbar.destroy()
self.__dict__.clear()
if Gcf.get_num_fig_managers() == 0 and not matplotlib.is_interactive() and gtk.main_level() >= 1:
gtk.main_quit()
def gui_excepthook(exc_type, exc_value, exc_traceback):
orig_sys_excepthook(exc_type, exc_value, exc_traceback)
if issubclass(exc_type, Exception):
exception_message = "".join(traceback.format_exception(exc_type, exc_value, exc_traceback))
display_exception_message(
exception_message, plugin_title=plugin_title, report_uri_list=report_uri_list,
parent=_gui_excepthook_parent)
# Make sure to quit the application since unhandled exceptions can
# mess up the application state.
if gtk.main_level() > 0:
gtk.main_quit()
def on_destroy(event):
from hamster.configuration import GconfStore, runtime
config = GconfStore()
# handle config option to stop tracking on shutdown
if config.get_stop_on_shutdown():
last_activity = runtime.storage.get_last_activity()
if last_activity and last_activity['end_time'] is None:
runtime.storage.touch_fact(last_activity)
if gtk.main_level():
gtk.main_quit()
def destroy(self, *args):
if _debug: print 'FigureManagerGTK.%s' % fn_name()
self.vbox.destroy()
self.window.destroy()
self.canvas.destroy()
if self.toolbar:
self.toolbar.destroy()
self.__dict__.clear()
if Gcf.get_num_fig_managers()==0 and \
not matplotlib.is_interactive() and \
gtk.main_level() >= 1:
gtk.main_quit()
def destroy(self, *args):
if _debug: print 'FigureManagerGTK.%s' % fn_name()
self.vbox.destroy()
self.window.destroy()
self.canvas.destroy()
if self.toolbar:
self.toolbar.destroy()
self.__dict__.clear() #Is this needed? Other backends don't have it.
if Gcf.get_num_fig_managers()==0 and \
not matplotlib.is_interactive() and \
gtk.main_level() >= 1:
gtk.main_quit()
def close_application(self, widget, event=None, data=None):
"""Termination"""
if self.rendering_thread:
self.rendering_thread.quit = True
self.rendering_thread.join()
if os.path.isdir(self.tmp_dir):
shutil.rmtree(self.tmp_dir)
if gtk.main_level():
gtk.main_quit()
else:
sys.exit(0)
return False
def __init__(self):
gtk.Window.__init__(self)
self.set_title('low-level')
if sys.platform != 'win32':
self.set_resize_mode(gtk.RESIZE_IMMEDIATE)
self.set_reallocate_redraws(True)
self.connect('delete_event', gtk.main_quit)
# VBox to hold everything.
vbox = gtk.VBox()
self.add(vbox)
# Query the OpenGL extension version.
print "OpenGL extension version - %d.%d\n" % gtk.gdkgl.query_version()
# Configure OpenGL framebuffer.
# Try to get a double-buffered framebuffer configuration,
# if not successful then try to get a single-buffered one.
display_mode = (gtk.gdkgl.MODE_RGB |
gtk.gdkgl.MODE_DEPTH |
gtk.gdkgl.MODE_DOUBLE)
try:
glconfig = gtk.gdkgl.Config(mode=display_mode)
except gtk.gdkgl.NoMatches:
display_mode &= ~gtk.gdkgl.MODE_DOUBLE
glconfig = gtk.gdkgl.Config(mode=display_mode)
print "is RGBA:", glconfig.is_rgba()
print "is double-buffered:", glconfig.is_double_buffered()
print "is stereo:", glconfig.is_stereo()
print "has alpha:", glconfig.has_alpha()
print "has depth buffer:", glconfig.has_depth_buffer()
print "has stencil buffer:", glconfig.has_stencil_buffer()
print "has accumulation buffer:", glconfig.has_accum_buffer()
print
# LowLevelDrawingArea
drawing_area = LowLevelDrawingArea(glconfig)
drawing_area.set_size_request(200, 200)
vbox.pack_start(drawing_area)
# Unrealize drawing_area on quit.
gtk.quit_add(gtk.main_level()+1, self._on_quit, drawing_area)
# A quit button.
button = gtk.Button('Quit')
# Destroy window on quit explicitly.
button.connect('clicked', gtk.main_quit)
vbox.pack_start(button, expand=False)
def run(self):
self._setup_folder_view()
self.show_all()
self._name_entry.grab_focus()
# Select the current folder.
if self._active_iter:
self._folder_tree.get_selection().select_iter(self._active_iter)
self._folder_tree.set_cursor(self._tree_model.get_path(self._active_iter))
self._loop_level = gtk.main_level() + 1
gtk.main()
return self._response
def close_application(self, widget, event=None, data=None):
"""Termination"""
if self.rendering_thread:
self.rendering_thread.quit = True
self.rendering_thread.join()
if os.path.isdir(self.tmp_dir):
shutil.rmtree(self.tmp_dir)
if gtk.main_level():
gtk.main_quit()
else:
sys.exit(0)
return False
def stop_gtk():
# shutdown twisted correctly
if reactor_required():
from twisted.internet import reactor
if reactor.running:
reactor.callFromThread(reactor.stop)
# Twisted can be imported without the reactor being used
# => check if GTK main loop is running
elif gtk.main_level() > 0:
glib.idle_add(gtk.main_quit)
else:
glib.idle_add(gtk.main_quit)
# Run the GTK loop until no more events are being generated and thus the GUI is fully destroyed
wait_for_gui()
def destroy(self, *args):
if hasattr(self, 'toolbar') and self.toolbar is not None:
self.toolbar.destroy()
if hasattr(self, 'vbox'):
self.vbox.destroy()
if hasattr(self, 'window'):
self.window.destroy()
if hasattr(self, 'canvas'):
self.canvas.destroy()
self.__dict__.clear() #Is this needed? Other backends don't have it.
if Gcf.get_num_fig_managers()==0 and \
not matplotlib.is_interactive() and \
gtk.main_level() >= 1:
gtk.main_quit()
def download_and_execute_application(self, app_name, args):
self.app_name = app_name
self.args = args
progress = ProgressDialog(self)
progress.set_window_title("klik - " + self.app_name)
print gtk.main_level()
# grab recipe on another thread
@threaded
def download_recipe_threaded(progress):
# Get recipe
try:
self.recipe = self.klik.get_recipe(self.app_name)
gtk.gdk.threads_enter()
progress.destroy()
gtk.gdk.threads_leave()
except Exception, inst:
self.error = inst
gtk.gdk.threads_enter()
progress.destroy()
gtk.gdk.threads_leave()
def __init__(self):
if not gobject.signal_lookup("output", ShellCommandJob):
gobject.signal_new("output", ShellCommandJob, \
gobject.SIGNAL_RUN_LAST, gobject.TYPE_NONE, \
[str])
if not gtk.main_level():
gtk.gdk.threads_init() # _DEBE_ llamarse _ANTES_ del gtk.main por temas del GIL.
