def apply_gtk_css(theme):
gtk_version = "%s.%s.%s" % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version())
if Gtk.get_major_version() == 3 and Gtk.get_minor_version() >= 22:
print("Gtk version is " + gtk_version +
", Flowblade theme is available.")
else:
print("Gtk version is " + gtk_version +
", Flowblade theme only available for Gtk >= 3.22")
editorpersistance.prefs.theme = appconsts.LIGHT_THEME
editorpersistance.save()
return False
provider = Gtk.CssProvider.new()
display = Gdk.Display.get_default()
screen = display.get_default_screen()
Gtk.StyleContext.add_provider_for_screen(
screen, provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION)
if theme == appconsts.FLOWBLADE_THEME:
css_path = "/res/css/gtk-flowblade-dark.css"
elif theme == appconsts.FLOWBLADE_THEME_NEUTRAL:
css_path = "/res/css3/gtk-flowblade-dark.css"
else: # appconsts.FLOWBLADE_THEME_GRAY
css_path = "/res/css2/gtk-flowblade-dark.css"
provider.load_from_path(respaths.ROOT_PATH + css_path)
return True
def send_bugreport(self):
"""
Return None if successful. Return the urllib2 execption if failure.
"""
try:
windowsversion = str(sys.getwindowsversion())
except AttributeError:
windowsversion = "(not running ms windows)"
buf = self.g_tw.get_buffer()
description = buf.get_text(buf.get_start_iter(), buf.get_end_iter(),
False)
data = urllib.urlencode({
'email': self.g_email.get_text(),
'version': buildinfo.VERSION_STRING,
'revision_id': buildinfo.REVISION_ID,
#'pygtk_version': "pygi",
'gtk': "(%s.%s.%s)" % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version()),
'sys.version': sys.version,
'sys.platform': sys.platform,
'windowsversion': windowsversion,
'short_description': self.g_description.get_text(),
'description': description,
'traceback': self.m_error_text,
})
try:
urllib2.urlopen("http://www.solfege.org/crashreport/", data)
except urllib2.HTTPError, e:
print "HTTPError:", e
def _get_sys_information(self):
"""
Get relevant system information.
"""
distribution = "" # print nothing if there's nothing to print
if hasattr(os, "uname"):
distribution = "Distribution: %s\n" % os.uname()[2]
sqlite = "sqlite version: %s (%s) \n" % (sqlite3_version_str,
sqlite3_py_version_str)
return "Gramps version: %s \n"\
"Python version: %s \n"\
"BSDDB version: %s \n"\
"%s"\
"LANG: %s\n"\
"OS: %s\n"\
"%s\n"\
"GTK version : %s\n"\
"gobject version: %s\n"\
"cairo version : %s"\
% (str(VERSION),
str(sys.version).replace('\n',''),
BSDDB_STR,
sqlite,
get_env_var('LANG',''),
platform.system(),
distribution,
'%d.%d.%d' % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version()),
'%d.%d.%d' % GObject.pygobject_version,
cairo.version_info)
def check_gtk_version():
""" Check GTK version """
# Check desired GTK Version
major_needed = int(GTK_VERSION_NEEDED.split(".")[0])
minor_needed = int(GTK_VERSION_NEEDED.split(".")[1])
micro_needed = int(GTK_VERSION_NEEDED.split(".")[2])
# Check system GTK Version
major = Gtk.get_major_version()
minor = Gtk.get_minor_version()
micro = Gtk.get_micro_version()
# Thus will be called from our liveCD that already
# has the latest GTK version. This is here just to
# help testing Thus in our environment.
wrong_gtk_version = False
if major_needed > major:
wrong_gtk_version = True
if major_needed == major and minor_needed > minor:
wrong_gtk_version = True
if major_needed == major and minor_needed == minor and micro_needed > micro:
wrong_gtk_version = True
if wrong_gtk_version:
text = "Detected GTK version {0}.{1}.{2} but version {3} is needed."
text = text.format(major, minor, micro, GTK_VERSION_NEEDED)
logging.info(text)
return False
else:
logging.info("Using GTK v{0}.{1}.{2}".format(major, minor, micro))
return True
def get_platform_info():
from gi.repository import GObject
from gi.repository import Gtk
import yaml
functions = [
platform.machine,
platform.platform,
platform.processor,
platform.python_version,
platform.release,
platform.system,
]
names_values = [(func.__name__, func()) for func in functions]
names_values.extend(
[
(
"GTK",
(
Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version(),
),
),
("Glib", GObject.glib_version),
("PyGObject", GObject.pygobject_version),
("YAML", yaml.__version__),
]
)
vals = ["{}: {}".format(name, val) for name, val in names_values]
return "System info: " + ", ".join(vals)
def print_platform_info():
import platform
from gi.repository import GObject
from gi.repository import Gtk
from gi.repository import Gst
import mutagen
import PIL
functions = [
platform.machine, platform.platform, platform.processor,
platform.python_version, platform.release, platform.system
]
names_values = [(func.__name__, func()) for func in functions]
names_values.extend([
('GTK', (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())),
('Glib', GObject.glib_version),
('PyGObject', GObject.pygobject_version),
('GST', Gst.version_string()),
('Mutagen', mutagen.version),
('PIL', PIL.VERSION),
])
values = ['%s: %s' % (name, val) for name, val in names_values]
logging.info('System info: ' + ', '.join(values))
def about_cb(self, action, parameter):
aboutdialog = Gtk.AboutDialog(modal=True, transient_for=self.win)
aboutdialog.set_program_name(aboutdialog.get_program_name() +
" %s" % VERSION)
_shell = GnomeShellFactory().get_shell()
if _shell is not None:
if _shell.mode == "user":
about_comment = _("GNOME Shell") + " %s" % _shell.version
else:
about_comment = (_("GNOME Shell") + " %s " + _("(%s mode)")) % \
(_shell.version, _shell.mode)
else:
about_comment = _("GNOME Shell is not running")
about_comment += "\n" + _("GTK") + " %d.%d.%d" % \
(Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())
aboutdialog.set_comments(about_comment)
aboutdialog.set_copyright("Copyright © 2011 - 2013 John Stowers.")
aboutdialog.set_logo_icon_name("org.gnome.tweaks")
aboutdialog.set_website("https://wiki.gnome.org/Apps/Tweaks")
aboutdialog.set_website_label(_("Homepage"))
aboutdialog.set_license_type(Gtk.License.GPL_3_0)
AUTHORS = ["John Stowers <*****@*****.**>"]
aboutdialog.set_authors(AUTHORS)
aboutdialog.connect("response", lambda w, r: aboutdialog.destroy())
aboutdialog.show()
def main():
"""
Main function that starts everything
"""
if is_wayland() and gdk_backend().lower() != 'x11' and not is_wayland_compatibility_on():
warn = """
[!]
Looks like you are in Wayland session
Please run Ulauncher with env var
GDK_BACKEND set to 'x11' like this:
GDK_BACKEND=x11 ulauncher
"""
print(warn, file=sys.stderr)
sys.exit(1)
# start DBus loop
DBusGMainLoop(set_as_default=True)
bus = dbus.SessionBus()
instance = bus.request_name(DBUS_SERVICE)
if instance != dbus.bus.REQUEST_NAME_REPLY_PRIMARY_OWNER:
toggle_window = dbus.SessionBus().get_object(DBUS_SERVICE, DBUS_PATH).get_dbus_method("toggle_window")
toggle_window()
return
_create_dirs()
options = get_options()
setup_logging(options)
logger = logging.getLogger('ulauncher')
logger.info('Ulauncher version %s' % get_version())
logger.info("GTK+ %s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()))
logger.info("Is Wayland: %s" % is_wayland())
logger.info("Wayland compatibility: %s" % ('on' if is_wayland_compatibility_on() else 'off'))
# log uncaught exceptions
def except_hook(exctype, value, tb):
logger.error("Uncaught exception", exc_info=(exctype, value, tb))
sys.excepthook = except_hook
window = UlauncherWindow.get_instance()
UlauncherDbusService(window)
if not options.hide_window:
window.show()
if Settings.get_instance().get_property('show-indicator-icon'):
AppIndicator.get_instance().show()
# workaround to make Ctrl+C quiting the app
signal_handler = SignalHandler(window)
gtk_thread = run_async(Gtk.main)()
try:
while gtk_thread.is_alive() and not signal_handler.killed():
time.sleep(0.5)
except KeyboardInterrupt:
logger.warn('On KeyboardInterrupt')
finally:
Gtk.main_quit()
def do_startup(self):
Gtk.Application.do_startup(self)
if self.purge_recent:
items = recent_manager.get_items()
for item in items:
uri = item.get_uri()
if item.get_application_info("pychess"):
recent_manager.remove_item(uri)
self.git_rev = ""
self.initGlade(self.log_viewer)
self.addPerspectives()
self.handleArgs(self.chess_file)
create_task(checkversion())
self.loaded_cids = {}
self.saved_cids = {}
self.terminated_cids = {}
log.info("PyChess %s %s git %s" % (VERSION_NAME, VERSION, self.git_rev))
log.info("Command line args: '%s'" % self.chess_file)
log.info("Platform: %s" % platform.platform())
log.info("Python version: %s.%s.%s" % sys.version_info[0:3])
log.info("Pyglib version: %s.%s.%s" % GLib.pyglib_version)
log.info("Gtk version: %s.%s.%s" % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version()))
def __init__(self, config_file=None):
super(KingPhisherClientApplication, self).__init__()
self.logger = logging.getLogger('KingPhisher.Client.Application')
# log version information for debugging purposes
self.logger.debug("gi.repository GLib version: {0}".format('.'.join(
map(str, GLib.glib_version))))
self.logger.debug("gi.repository GObject version: {0}".format('.'.join(
map(str, GObject.pygobject_version))))
self.logger.debug("gi.repository Gtk version: {0}.{1}.{2}".format(
Gtk.get_major_version(), Gtk.get_minor_version(),
Gtk.get_micro_version()))
if tools.has_vte:
self.logger.debug("gi.repository VTE version: {0}".format(
tools.Vte._version))
if graphs.has_matplotlib:
self.logger.debug("matplotlib version: {0}".format(
graphs.matplotlib.__version__))
self.set_property('application-id', 'org.king-phisher.client')
self.set_property('register-session', True)
self.config_file = (config_file or CONFIG_FILE_PATH)
"""The file containing the King Phisher client configuration."""
self.config = None
"""The main King Phisher client configuration."""
try:
self.load_config(load_defaults=True)
except IOError:
self.logger.critical('failed to load the client configuration')
raise
def __init__(self, app):
"""Create the necessary objects and settings.
Args:
app: The main vimiv application to interact with.
"""
datadir = os.path.join(get_user_data_dir(), "vimiv")
os.makedirs(datadir, exist_ok=True)
self._filename = os.path.join(datadir, "vimiv.log")
self._terminal = sys.stderr
# Redirect stderr in debug mode so it is written to the log file as well
if app.debug:
sys.stderr = self
# Create a new log file at startup
with open(self._filename, "w") as f:
f.write("Vimiv log written to " +
self._filename.replace(os.getenv("HOME"), "~") + "\n")
self._write_separator()
# Header containing version and Gtk version
self.write_message("Version", app["information"].get_version())
self.write_message("Python", sys.version.split()[0])
gtk_version = str(Gtk.get_major_version()) + "." \
+ str(Gtk.get_minor_version()) + "." \
+ str(Gtk.get_micro_version())
self.write_message("GTK", gtk_version)
self._write_separator()
# Start time
self.write_message("Started", "time")
def _get_sys_information(self):
"""
Get relevant system information.
"""
distribution = "" # print nothing if there's nothing to print
if hasattr(os, "uname"):
distribution = "Distribution: %s\n" % os.uname()[2]
sqlite = "sqlite version: %s (%s) \n" % (sqlite3_version_str,
sqlite3_py_version_str)
return "Gramps version: %s \n"\
"Python version: %s \n"\
"BSDDB version: %s \n"\
"%s"\
"LANG: %s\n"\
"OS: %s\n"\
"%s\n"\
"GTK version : %s\n"\
"gobject version: %s\n"\
"cairo version : %s"\
% (str(VERSION),
str(sys.version).replace('\n',''),
BSDDB_STR,
sqlite,
get_env_var('LANG',''),
platform.system(),
distribution,
'%d.%d.%d' % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version()),
'%d.%d.%d' % GObject.pygobject_version,
cairo.version_info)
def _get_sys_information(self):
"""
Get relevant system information.
"""
if hasattr(os, "uname"):
operatingsystem = os.uname()[0]
distribution = os.uname()[2]
else:
operatingsystem = sys.platform
distribution = " "
return "Python version: %s \n"\
"BSDDB version: %s \n"\
"sqlite version: %s (%s) \n"\
"Gramps version: %s \n"\
"LANG: %s\n"\
"OS: %s\n"\
"Distribution: %s\n\n"\
"GTK version : %s\n"\
"gobject version: %s\n"\
"cairo version : %s"\
% (str(sys.version).replace('\n',''),
BSDDB_STR,
sqlite3_version_str,
sqlite3_py_version_str,
str(VERSION),
get_env_var('LANG',''),
operatingsystem,
distribution,
'%d.%d.%d' % (Gtk.get_major_version(),
Gtk.get_minor_version(), Gtk.get_micro_version()),
'%d.%d.%d' % GObject.pygobject_version,
cairo.version_info)
def main(root_path, filename):
gtk_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())
print "GTK+ version:", gtk_version
editorstate.gtk_version = gtk_version
try:
editorstate.mlt_version = mlt.LIBMLT_VERSION
except:
editorstate.mlt_version = "0.0.99" # magic string for "not found"
# Create user folders if need and determine if were using xdg or dotfile userf folders.
userfolders.init()
# Set paths.
respaths.set_paths(root_path)
# Load editor prefs and list of recent projects
editorpersistance.load()
# Init translations module with translations data
translations.init_languages()
translations.load_filters_translations()
mlttransitions.init_module()
# Init gtk threads
Gdk.threads_init()
Gdk.threads_enter()
# Themes
if editorpersistance.prefs.theme != appconsts.LIGHT_THEME:
Gtk.Settings.get_default().set_property("gtk-application-prefer-dark-theme", True)
if editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME:
gui.apply_gtk_css()
repo = mlt.Factory().init()
processutils.prepare_mlt_repo(repo)
# Set numeric locale to use "." as radix, MLT initilizes this to OS locale and this causes bugs
locale.setlocale(locale.LC_NUMERIC, 'C')
# Check for codecs and formats on the system
mltenv.check_available_features(repo)
renderconsumer.load_render_profiles()
# Load filter and compositor descriptions from xml files.
mltfilters.load_filters_xml(mltenv.services)
mlttransitions.load_compositors_xml(mltenv.transitions)
# Create list of available mlt profiles
mltprofiles.load_profile_list()
appconsts.SAVEFILE_VERSION = projectdata.SAVEFILE_VERSION
global linker_window
linker_window = MediaLinkerWindow()
if filename != NO_PROJECT_AT_LAUNCH:
linker_window.load_project(filename)
Gtk.main()
Gdk.threads_leave()
def main(root_path, filename):
gtk_version = "%s.%s.%s" % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version())
print "GTK+ version:", gtk_version
editorstate.gtk_version = gtk_version
try:
editorstate.mlt_version = mlt.LIBMLT_VERSION
except:
editorstate.mlt_version = "0.0.99" # magic string for "not found"
# Set paths.
respaths.set_paths(root_path)
# Load editor prefs and list of recent projects
editorpersistance.load()
# Init translations module with translations data
translations.init_languages()
translations.load_filters_translations()
mlttransitions.init_module()
# Init gtk threads
Gdk.threads_init()
Gdk.threads_enter()
# Themes
if editorpersistance.prefs.theme != appconsts.LIGHT_THEME:
Gtk.Settings.get_default().set_property(
"gtk-application-prefer-dark-theme", True)
if editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME:
gui.apply_gtk_css()
repo = mlt.Factory().init()
processutils.prepare_mlt_repo(repo)
# Set numeric locale to use "." as radix, MLT initilizes this to OS locale and this causes bugs
locale.setlocale(locale.LC_NUMERIC, 'C')
# Check for codecs and formats on the system
mltenv.check_available_features(repo)
renderconsumer.load_render_profiles()
# Load filter and compositor descriptions from xml files.
mltfilters.load_filters_xml(mltenv.services)
mlttransitions.load_compositors_xml(mltenv.transitions)
# Create list of available mlt profiles
mltprofiles.load_profile_list()
appconsts.SAVEFILE_VERSION = projectdata.SAVEFILE_VERSION
global linker_window
linker_window = MediaLinkerWindow()
if filename != NO_PROJECT_AT_LAUNCH:
linker_window.load_project(filename)
Gtk.main()
Gdk.threads_leave()
def main(root_path, filename):
# This the main for launched process, this is reached via 'flowblademediaimport' laucher file
gtk_version = "%s.%s.%s" % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version())
print("GTK+ version:", gtk_version)
editorstate.gtk_version = gtk_version
try:
editorstate.mlt_version = mlt.LIBMLT_VERSION
except:
editorstate.mlt_version = "0.0.99" # magic string for "not found"
# Read the XDG_* variables etc.
userfolders.init()
# Set paths.
respaths.set_paths(root_path)
# Load editor prefs and list of recent projects
editorpersistance.load()
# Init translations module with translations data
translations.init_languages()
translations.load_filters_translations()
mlttransitions.init_module()
# Init gtk threads
Gdk.threads_init()
Gdk.threads_enter()
# Themes
if editorpersistance.prefs.theme != appconsts.LIGHT_THEME:
Gtk.Settings.get_default().set_property(
"gtk-application-prefer-dark-theme", True)
if editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME \
or editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME_GRAY \
or editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME_NEUTRAL:
gui.apply_gtk_css(editorpersistance.prefs.theme)
repo = mlt.Factory().init()
processutils.prepare_mlt_repo(repo)
# Set numeric locale to use "." as radix, MLT initilizes this to OS locale and this causes bugs
locale.setlocale(locale.LC_NUMERIC, 'C')
# Check for codecs and formats on the system
mltenv.check_available_features(repo)
renderconsumer.load_render_profiles()
# Load filter and compositor descriptions from xml files.
mltfilters.load_filters_xml(mltenv.services)
mlttransitions.load_compositors_xml(mltenv.transitions)
# Create list of available mlt profiles
mltprofiles.load_profile_list()
GLib.idle_add(_do_assets_write, filename)
Gtk.main()
Gdk.threads_leave()
def check_gtk_version():
""" Check GTK version """
# Check desired GTK Version
major_needed = int(GTK_VERSION_NEEDED.split(".")[0])
minor_needed = int(GTK_VERSION_NEEDED.split(".")[1])
micro_needed = int(GTK_VERSION_NEEDED.split(".")[2])
# Check system GTK Version
major = Gtk.get_major_version()
minor = Gtk.get_minor_version()
micro = Gtk.get_micro_version()
# Cnchi will be called from our liveCD that already
# has the latest GTK version. This is here just to
# help testing Cnchi in our environment.
wrong_gtk_version = False
if major_needed > major:
wrong_gtk_version = True
if major_needed == major and minor_needed > minor:
wrong_gtk_version = True
if major_needed == major and minor_needed == minor and micro_needed > micro:
wrong_gtk_version = True
if wrong_gtk_version:
text = "Detected GTK version {0}.{1}.{2} but version>={3} is needed."
text = text.format(major, minor, micro, GTK_VERSION_NEEDED)
logging.info(text)
return False
else:
logging.info("Using GTK v{0}.{1}.{2}".format(major, minor, micro))
return True
def get_libs_version_string():
"""Get a string describing the versions of important libs.
>>> type(get_libs_version_string()) == str
True
"""
versions = [
("Python", "{major}.{minor}.{micro}".format(
major = sys.version_info.major,
minor = sys.version_info.minor,
micro = sys.version_info.micro,
)),
("GTK", "{major}.{minor}.{micro}".format(
major = Gtk.get_major_version(),
minor = Gtk.get_minor_version(),
micro = Gtk.get_micro_version(),
)),
("GdkPixbuf", GdkPixbuf.PIXBUF_VERSION),
("Cairo", cairo.cairo_version_string()), # NOT cairo.version
("GLib", "{major}.{minor}.{micro}".format(
major = GLib.MAJOR_VERSION,
minor = GLib.MINOR_VERSION,
micro = GLib.MICRO_VERSION,
)),
]
return ", ".join([" ".join(t) for t in versions])
def do_startup(self):
Gtk.Application.do_startup(self)
if self.purge_recent:
items = recent_manager.get_items()
for item in items:
uri = item.get_uri()
if item.get_application_info("pychess"):
recent_manager.remove_item(uri)
self.git_rev = ""
self.initGlade(self.log_viewer)
self.addPerspectives()
self.handleArgs(self.chess_file)
if self.version_check:
create_task(checkversion())
self.loaded_cids = {}
self.saved_cids = {}
self.terminated_cids = {}
log.info("PyChess %s %s git %s" %
(VERSION_NAME, VERSION, self.git_rev))
log.info("Command line args: '%s'" % self.chess_file)
log.info("Platform: %s" % platform.platform())
log.info("Python version: %s.%s.%s" % sys.version_info[0:3])
log.info("Pyglib version: %s.%s.%s" % GLib.pyglib_version)
log.info("Gtk version: %s.%s.%s" %
(Gtk.get_major_version(), Gtk.get_minor_version(),
Gtk.get_micro_version()))
def _get_sys_information(self):
"""
Get relevant system information.
"""
if hasattr(os, "uname"):
operatingsystem = os.uname()[0]
distribution = os.uname()[2]
else:
operatingsystem = sys.platform
distribution = " "
return "Python version: %s \n"\
"BSDDB version: %s \n"\
"Gramps version: %s \n"\
"LANG: %s\n"\
"OS: %s\n"\
"Distribution: %s\n\n"\
"GTK version : %s\n"\
"gobject version: %s\n"\
"cairo version : %s"\
% (str(sys.version).replace('\n',''),
BSDDB_STR,
str(VERSION),
get_env_var('LANG',''),
operatingsystem,
distribution,
'%d.%d.%d' % (Gtk.get_major_version(),
Gtk.get_minor_version(), Gtk.get_micro_version()),
'%d.%d.%d' % GObject.pygobject_version,
cairo.version_info)
def __init__(self, config_file=None, use_plugins=True, use_style=True):
super(KingPhisherClientApplication, self).__init__()
if use_style:
gtk_version = (Gtk.get_major_version(), Gtk.get_minor_version())
if gtk_version > (3, 18):
self._theme_file = 'theme.v2.css'
else:
self._theme_file = 'theme.v1.css'
else:
self._theme_file = DISABLED
self.logger = logging.getLogger('KingPhisher.Client.Application')
# log version information for debugging purposes
self.logger.debug("gi.repository GLib version: {0}".format('.'.join(
map(str, GLib.glib_version))))
self.logger.debug("gi.repository GObject version: {0}".format('.'.join(
map(str, GObject.pygobject_version))))
self.logger.debug("gi.repository Gtk version: {0}.{1}.{2}".format(
Gtk.get_major_version(), Gtk.get_minor_version(),
Gtk.get_micro_version()))
if rpc_terminal.has_vte:
self.logger.debug("gi.repository VTE version: {0}".format(
rpc_terminal.Vte._version))
if graphs.has_matplotlib:
self.logger.debug("matplotlib version: {0}".format(
graphs.matplotlib.__version__))
self.set_property('application-id', 'org.king-phisher.client')
self.set_property('register-session', True)
self.config_file = config_file or os.path.join(USER_DATA_PATH,
'config.json')
"""The file containing the King Phisher client configuration."""
if not os.path.isfile(self.config_file):
self._create_config()
self.config = None
"""The primary King Phisher client configuration."""
self.main_window = None
"""The primary top-level :py:class:`~.MainAppWindow` instance."""
self.rpc = None
"""The :py:class:`~.KingPhisherRPCClient` instance for the application."""
self._ssh_forwarder = None
"""The SSH forwarder responsible for tunneling RPC communications."""
self.style_provider = None
try:
self.emit('config-load', True)
except IOError:
self.logger.critical('failed to load the client configuration')
raise
self.connect('window-added', self.signal_window_added)
self.actions = {}
self._create_actions()
if not use_plugins:
self.logger.info('disabling all plugins')
self.config['plugins.enabled'] = []
self.plugin_manager = plugins.ClientPluginManager([
os.path.join(USER_DATA_PATH, 'plugins'),
find.find_data_directory('plugins')
], self)
if use_plugins:
self.plugin_manager.load_all()
def _init_gtk():
import gi
gi.require_version('GLib', '2.0')
gi.require_version('Gio', '2.0')
gi.require_version('Gtk', '3.0')
gi.require_version('Gdk', '3.0')
gi.require_version('GObject', '2.0')
gi.require_version('Pango', '1.0')
from gi.repository import Gtk
gtk_ver = '%s.%s.%s' % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version())
if V(gtk_ver) < V(_MIN_GTK_VER):
print('Gajim needs GTK >= %s to run. '
'Quitting...' % _MIN_GTK_VER)
sys.exit(1)
from gajim.gtk import exception
exception.init()
i18n.initialize_direction_mark()
from gajim.application import GajimApplication
# Fix bug in 3.24.1 with flickering tooltips
if sys.platform in ('darwin', 'win32'):
settings = Gtk.Settings.get_default()
settings.set_property('gtk-cursor-theme-size', 16)
application = GajimApplication()
_install_sginal_handlers(application)
application.run(sys.argv)
def get_libs_version_string():
"""Get a string describing the versions of important libs.
>>> type(get_libs_version_string()) == str
True
"""
versions = [
("Python", "{major}.{minor}.{micro}".format(
major=sys.version_info.major,
minor=sys.version_info.minor,
micro=sys.version_info.micro,
)),
("GTK", "{major}.{minor}.{micro}".format(
major=Gtk.get_major_version(),
minor=Gtk.get_minor_version(),
micro=Gtk.get_micro_version(),
)),
("GdkPixbuf", GdkPixbuf.PIXBUF_VERSION),
("Cairo", cairo.cairo_version_string()), # NOT cairo.version
("GLib", "{major}.{minor}.{micro}".format(
major=GLib.MAJOR_VERSION,
minor=GLib.MINOR_VERSION,
micro=GLib.MICRO_VERSION,
)),
]
return ", ".join([" ".join(t) for t in versions])
def _init_gtk():
import gi
gi.require_version('GLib', '2.0')
gi.require_version('Gio', '2.0')
gi.require_version('Gtk', '3.0')
gi.require_version('Gdk', '3.0')
gi.require_version('GObject', '2.0')
gi.require_version('Pango', '1.0')
from gi.repository import Gtk
gtk_ver = '%s.%s.%s' % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version())
if V(gtk_ver) < V(_MIN_GTK_VER):
print('Gajim needs GTK+ >= %s to run. '
'Quitting...' % _MIN_GTK_VER)
sys.exit(1)
from gajim import gtkexcepthook
gtkexcepthook.init()
i18n.initialize_direction_mark()
from gajim.application import GajimApplication
application = GajimApplication()
_install_sginal_handlers(application)
application.run(sys.argv)
def main(root_path, force_launch=False):
init_dirs_if_needed()
gtk_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())
editorstate.gtk_version = gtk_version
try:
editorstate.mlt_version = mlt.LIBMLT_VERSION
except:
editorstate.mlt_version = "0.0.99" # magic string for "not found"
# Set paths.
respaths.set_paths(root_path)
# Load editor prefs and list of recent projects
editorpersistance.load()
# Init translations module with translations data
translations.init_languages()
translations.load_filters_translations()
mlttransitions.init_module()
# Init gtk threads
Gdk.threads_init()
Gdk.threads_enter()
repo = mlt.Factory().init()
# Set numeric locale to use "." as radix, MLT initilizes this to OS locale and this causes bugs
locale.setlocale(locale.LC_NUMERIC, 'C')
# Check for codecs and formats on the system
mltenv.check_available_features(repo)
renderconsumer.load_render_profiles()
# Load filter and compositor descriptions from xml files.
mltfilters.load_filters_xml(mltenv.services)
mlttransitions.load_compositors_xml(mltenv.transitions)
# Create list of available mlt profiles
mltprofiles.load_profile_list()
global render_queue
render_queue = RenderQueue()
render_queue.load_render_items()
global batch_window
batch_window = BatchRenderWindow()
if render_queue.error_status != None:
primary_txt = _("Error loading render queue items!")
secondary_txt = _("Message:\n") + render_queue.get_error_status_message()
dialogutils.warning_message(primary_txt, secondary_txt, batch_window.window)
DBusGMainLoop(set_as_default=True)
global _dbus_service
_dbus_service = BatchRenderDBUSService()
Gtk.main()
Gdk.threads_leave()
def gtk_version_newer_than(major=3, minor=0, micro=0):
_major = Gtk.get_major_version()
_minor = Gtk.get_minor_version()
_micro = Gtk.get_micro_version()
return (_major > major) or \
(_major == major and _minor > minor) or \
(_major == major and _minor == minor and _micro >= micro)
def get_issue_text(self, traceback_text):
gtk_ver = '%i.%i.%i' % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version())
gobject_ver = '.'.join(map(str, GObject.pygobject_version))
return ISSUE_TEXT.format(get_os_info(), gtk_ver, gobject_ver,
nbxmpp.__version__, gajim_version,
traceback_text)
def format_exception_details(exc_type, exc_value, exc_traceback, error_uid=None):
"""
Format exception details to be show to a human. This should include enough
information about the type of error that occurred and the system on which
it was triggered to allow someone to attempt to debug and fix it. The first
three parameters to this function directly correspond to the values
returned from the :py:func:`sys.exc_info` function.
:param exc_type: The type of the exception.
:param exc_value: The exception instance.
:param exc_traceback: The traceback object corresponding to the exception.
:param error_uid: A unique identifier for this exception.
:type error_uid: str, :py:class:`uuid.UUID`
:return: A formatted message containing the details about the exception and environment.
:rtype: str
"""
if isinstance(error_uid, uuid.UUID):
error_uid = str(error_uid)
elif error_uid is None:
error_uid = 'N/A'
elif not isinstance(error_uid, str):
raise TypeError('error_uid must be an instance of either str, uuid.UUID or None')
pversion = 'UNKNOWN'
if its.on_linux:
pversion = 'Linux: ' + ' '.join(platform.linux_distribution())
elif its.on_windows:
pversion = 'Windows: ' + ' '.join(platform.win32_ver())
if its.frozen:
pversion += ' (Frozen=True)'
else:
pversion += ' (Frozen=False)'
exc_name = format_exception_name(exc_type)
rpc_error_details = 'N/A (Not a remote RPC error)'
if isinstance(exc_value, advancedhttpserver.RPCError) and exc_value.is_remote_exception:
rpc_error_details = "Name: {0}".format(exc_value.remote_exception['name'])
if exc_value.remote_exception.get('message'):
rpc_error_details += " Message: '{0}'".format(exc_value.remote_exception['message'])
current_tid = threading.current_thread().ident
thread_info = (
"{0: >4}{1} (alive={2} daemon={3})".format(('=> ' if thread.ident == current_tid else ''), thread.name, thread.is_alive(), thread.daemon) for thread in threading.enumerate()
)
thread_info = '\n'.join(thread_info)
details = EXCEPTION_DETAILS_TEMPLATE.format(
error_details=repr(exc_value),
error_type=exc_name,
error_uid=error_uid,
rpc_error_details=rpc_error_details,
king_phisher_version=version.version,
platform_version=pversion,
python_version="{0}.{1}.{2}".format(*sys.version_info),
gtk_version="{0}.{1}.{2}".format(Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()),
stack_trace=''.join(traceback.format_exception(exc_type, exc_value, exc_traceback)),
thread_info=thread_info,
timezone=tzlocal.get_localzone().zone
)
details = details.strip() + '\n'
return details
def format_exception_details(exc_type, exc_value, exc_traceback, error_uid=None):
"""
Format exception details to be show to a human. This should include enough
information about the type of error that occurred and the system on which
it was triggered to allow someone to attempt to debug and fix it. The first
three parameters to this function directly correspond to the values
returned from the :py:func:`sys.exc_info` function.
:param exc_type: The type of the exception.
:param exc_value: The exception instance.
:param exc_traceback: The traceback object corresponding to the exception.
:param error_uid: A unique identifier for this exception.
:type error_uid: str, :py:class:`uuid.UUID`
:return: A formatted message containing the details about the exception and environment.
:rtype: str
"""
if isinstance(error_uid, uuid.UUID):
error_uid = str(error_uid)
elif error_uid is None:
error_uid = 'N/A'
elif not isinstance(error_uid, str):
raise TypeError('error_uid must be an instance of either str, uuid.UUID or None')
pversion = 'UNKNOWN'
if its.on_linux:
pversion = 'Linux: ' + ' '.join(platform.linux_distribution())
elif its.on_windows:
pversion = 'Windows: ' + ' '.join(platform.win32_ver())
if its.frozen:
pversion += ' (Frozen=True)'
else:
pversion += ' (Frozen=False)'
exc_name = format_exception_name(exc_type)
rpc_error_details = 'N/A (Not a remote RPC error)'
if isinstance(exc_value, advancedhttpserver.RPCError) and exc_value.is_remote_exception:
rpc_error_details = "Name: {0}".format(exc_value.remote_exception['name'])
if exc_value.remote_exception.get('message'):
rpc_error_details += " Message: '{0}'".format(exc_value.remote_exception['message'])
current_tid = threading.current_thread().ident
thread_info = (
"{0: >4}{1} (alive={2} daemon={3})".format(('=> ' if thread.ident == current_tid else ''), thread.name, thread.is_alive(), thread.daemon) for thread in threading.enumerate()
)
thread_info = '\n'.join(thread_info)
details = EXCEPTION_DETAILS_TEMPLATE.format(
error_details=repr(exc_value),
error_type=exc_name,
error_uid=error_uid,
rpc_error_details=rpc_error_details,
king_phisher_version=version.version,
platform_version=pversion,
python_version="{0}.{1}.{2}".format(*sys.version_info),
gtk_version="{0}.{1}.{2}".format(Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()),
stack_trace=''.join(traceback.format_exception(exc_type, exc_value, exc_traceback)),
thread_info=thread_info,
timezone=tzlocal.get_localzone().zone
)
details = details.strip() + '\n'
return details
def main(argv=sys.argv[1:]):
""" Entry point of pympress. Parse command line arguments, instantiate the UI, and start the main loop.
"""
signal.signal(signal.SIGINT, signal.SIG_DFL)
# prefere X11 on posix systems because Wayland still has some shortcomings for us,
# specifically libVLC and the ability to disable screensavers
if util.IS_POSIX:
Gdk.set_allowed_backends('x11,*')
Gtk.init(argv)
pympress_meta = util.get_pympress_meta()['version']
logger.info(' '.join([
'Pympress:', pympress_meta, '; Python:',
platform.python_version(), '; OS:',
platform.system(),
platform.release(),
platform.version(), '; Gtk {}.{}.{}'.format(Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version()),
'; GLib {}.{}.{}'.format(GLib.MAJOR_VERSION, GLib.MINOR_VERSION,
GLib.MICRO_VERSION), '; Poppler',
document.Poppler.get_version(),
document.Poppler.get_backend().value_nick, '; Cairo',
ui.cairo.cairo_version_string(), ', pycairo', ui.cairo.version,
'; Media:',
extras.Media.backend_version()
]))
try:
opts, args = getopt.getopt(argv, "hn:t:",
["help", "notes=", "talk-time=", "log="])
opts = dict(opts)
except getopt.GetoptError:
usage()
sys.exit(2)
ett, log_level, notes_pos = parse_opts(opts)
logger.setLevel(log_level)
# Create windows
gui = ui.UI()
# Connect proper exit function to interrupt
signal.signal(signal.SIGINT, gui.save_and_quit)
# pass command line args
if ett:
gui.est_time.set_time(ett)
gui.swap_document(os.path.abspath(args[0])) if args else gui.pick_file()
if notes_pos is not None:
gui.change_notes_pos(notes_pos, force_change=True)
gui.run()
def main():
"""
Main function that starts everything
"""
# start DBus loop
DBusGMainLoop(set_as_default=True)
bus = dbus.SessionBus()
instance = bus.request_name(DBUS_SERVICE)
if instance != dbus.bus.REQUEST_NAME_REPLY_PRIMARY_OWNER:
print(
"DBus name already taken. Ulauncher is probably backgrounded. Did you mean `ulauncher-toggle`?",
file=sys.stderr)
toggle_window = dbus.SessionBus().get_object(
DBUS_SERVICE, DBUS_PATH).get_dbus_method("toggle_window")
toggle_window()
return
_create_dirs()
options = get_options()
setup_logging(options)
logger = logging.getLogger('ulauncher')
logger.info('Ulauncher version %s', get_version())
logger.info('Extension API version %s', api_version)
logger.info("GTK+ %s.%s.%s", Gtk.get_major_version(),
Gtk.get_minor_version(), Gtk.get_micro_version())
logger.info("Is Wayland: %s", is_wayland())
logger.info("Wayland compatibility: %s",
('on' if is_wayland_compatibility_on() else 'off'))
# log uncaught exceptions
def except_hook(exctype, value, tb):
logger.error("Uncaught exception", exc_info=(exctype, value, tb))
sys.excepthook = except_hook
window = UlauncherWindow.get_instance()
UlauncherDbusService(window)
if not options.hide_window:
window.show()
if Settings.get_instance().get_property('show-indicator-icon'):
AppIndicator.get_instance().show()
# workaround to make Ctrl+C quitting the app
signal_handler = SignalHandler(window)
gtk_thread = run_async(Gtk.main)()
try:
while gtk_thread.is_alive() and not signal_handler.killed():
time.sleep(0.5)
except KeyboardInterrupt:
logger.warning('On KeyboardInterrupt')
finally:
Gtk.main_quit()
def backend_gtk3agg_internal_check(x):
try:
from gi.repository import Gtk, Gdk, GObject
except ImportError:
return (False, "Requires pygobject to be installed.")
if sys.version_info[0] >= 3:
return (False, "gtk3agg does not work on Python 3")
return (True, "version %s.%s.%s" % (Gtk.get_major_version(), Gtk.get_micro_version(), Gtk.get_minor_version()))
def main(root_path, filename):
# This the main for launched process, this is reached via 'flowblademediaimport' laucher file
gtk_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())
print "GTK+ version:", gtk_version
editorstate.gtk_version = gtk_version
try:
editorstate.mlt_version = mlt.LIBMLT_VERSION
except:
editorstate.mlt_version = "0.0.99" # magic string for "not found"
# Read the XDG_* variables etc.
userfolders.init()
# Set paths.
respaths.set_paths(root_path)
# Load editor prefs and list of recent projects
editorpersistance.load()
# Init translations module with translations data
translations.init_languages()
translations.load_filters_translations()
mlttransitions.init_module()
# Init gtk threads
Gdk.threads_init()
Gdk.threads_enter()
# Themes
if editorpersistance.prefs.theme != appconsts.LIGHT_THEME:
Gtk.Settings.get_default().set_property("gtk-application-prefer-dark-theme", True)
if editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME:
gui.apply_gtk_css()
repo = mlt.Factory().init()
processutils.prepare_mlt_repo(repo)
# Set numeric locale to use "." as radix, MLT initilizes this to OS locale and this causes bugs
locale.setlocale(locale.LC_NUMERIC, 'C')
# Check for codecs and formats on the system
mltenv.check_available_features(repo)
renderconsumer.load_render_profiles()
# Load filter and compositor descriptions from xml files.
mltfilters.load_filters_xml(mltenv.services)
mlttransitions.load_compositors_xml(mltenv.transitions)
# Create list of available mlt profiles
mltprofiles.load_profile_list()
GLib.idle_add(_do_assets_write, filename)
Gtk.main()
Gdk.threads_leave()
def interact(self):
exc_type, exc_value, exc_traceback = self.exc_info
pversion = 'UNKNOWN'
if its.on_linux:
pversion = 'Linux: ' + ' '.join(platform.linux_distribution())
elif its.on_windows:
pversion = 'Windows: ' + ' '.join(platform.win32_ver())
if its.frozen:
pversion += ' (Frozen=True)'
else:
pversion += ' (Frozen=False)'
exc_name = "{0}.{1}".format(exc_type.__module__, exc_type.__name__)
rpc_error_details = 'N/A (Not a remote RPC error)'
if isinstance(
exc_value,
advancedhttpserver.RPCError) and exc_value.is_remote_exception:
rpc_error_details = "Name: {0}".format(
exc_value.remote_exception['name'])
if exc_value.remote_exception.get('message'):
rpc_error_details += " Message: '{0}'".format(
exc_value.remote_exception['message'])
current_tid = threading.current_thread().ident
thread_info = ("{0: >4}{1} (alive={2} daemon={3})".format(
('=> ' if thread.ident == current_tid else ''), thread.name,
thread.is_alive(), thread.daemon)
for thread in threading.enumerate())
thread_info = '\n'.join(thread_info)
details = EXCEPTION_DETAILS_TEMPLATE.format(
error_details=repr(exc_value),
error_type=exc_name,
error_uid=(self.error_uid or 'N/A'),
rpc_error_details=rpc_error_details,
king_phisher_version=version.version,
platform_version=pversion,
python_version="{0}.{1}.{2}".format(*sys.version_info),
gtk_version="{0}.{1}.{2}".format(Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version()),
stack_trace=''.join(
traceback.format_exception(exc_type, exc_value,
exc_traceback)),
thread_info=thread_info,
timezone=tzlocal.get_localzone().zone)
details = details.strip() + '\n'
if exc_name.startswith('king_phisher.third_party.'):
exc_name = exc_name[25:]
self.error_description.set_text("Error type: {0}".format(exc_name))
self.error_details.get_buffer().set_text(details)
self.dialog.show_all()
self.dialog.run()
self.dialog.destroy()
return
def _check_gui(self):
if int(self.config.get("gui", "", "gtk_major", "0")) == int(Gtk.get_major_version()) \
and int(self.config.get("gui", "", "gtk_minor", "0")) == int(Gtk.get_minor_version()) \
and int(self.config.get("gui", "", "gtk_micro", "0")) == int(Gtk.get_micro_version()):
log.debug("Рабочая версия GTK.")
IGUI.ResourceChecker(self)
return
log.critical("Warning: GTK version mistmatch!")
log.critical("Current GTK version is: {0}.{1}.{2}".format(
Gtk.get_major_version(), Gtk.get_minor_version(),
Gtk.get_micro_version()))
log.critical("Need GTK version is: {0}.{1}.{2}".format(
self.config.get("gui", "", "gtk_major", "0"),
self.config.get("gui", "", "gtk_minor", "0"),
self.config.get("gui", "", "gtk_micro", "0")))
self.quit()
def run(self, etype, evalue, etraceback):
text = "".join(traceback.format_exception(etype, evalue, etraceback))
gtk_version = "%s.%s.%s" % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version())
info = "\n\nPlatform: %s\nPython: %s\nGTK+:%s\n\n" % (
platform.platform(), platform.python_version(), gtk_version)
self._textview.get_buffer().set_text(text)
clipboard = Gtk.Clipboard.get_for_display(Gdk.Display.get_default(),
Gdk.SELECTION_CLIPBOARD)
clipboard.set_text(text + info, -1)
Gtk.MessageDialog.run(self)
def backend_gtk3cairo_internal_check(x):
try:
import cairo
except ImportError:
return (False, "Requires cairo to be installed.")
try:
from gi.repository import Gtk, Gdk, GObject
except ImportError:
return (False, "Requires pygobject to be installed.")
return (True, "version %s.%s.%s" % (Gtk.get_major_version(), Gtk.get_micro_version(), Gtk.get_minor_version()))
def about(self2):
dialog = Gtk.AboutDialog()
dialog.set_name(pedconfig.conf.progname + " - Python Editor ")
dialog.set_version(str(pedconfig.conf.version))
gver = (Gtk.get_major_version(), \
Gtk.get_minor_version(), \
Gtk.get_micro_version())
dialog.set_position(Gtk.WindowPosition.CENTER)
dialog.set_transient_for(pedconfig.conf.pedwin.mywin)
#"\nRunning PyGObject %d.%d.%d" % GObject.pygobject_version +\
ddd = os.path.join(os.path.dirname(__file__), "../", "../")
# GLib.pyglib_version
vvv = gi.version_info
comm = "Python based easily configurable editor\n"\
"with time accounting module, spell "\
"check \n and macro recording.\n"\
"\nRunning PyGtk %d.%d.%d" % vvv +\
"\non GTK %d.%d.%d\n" % gver +\
"\nRunning Python %s" % platform.python_version() +\
"\non %s %s\n" % (platform.system(), platform.release()) +\
"\nPyedPro Build Date: %s\n" % pedconfig.conf.build_date +\
"Exe Path:\n%s\n" % os.path.realpath(ddd)
dialog.set_comments(comm)
dialog.set_copyright(pedconfig.conf.progname + " Created by Peter Glen.\n"
"Project is in the Public Domain.")
dialog.set_program_name(pedconfig.conf.progname)
img_dir = os.path.join(os.path.dirname(__file__), 'images')
#img_path = os.path.join(img_dir, 'gtk-logo-rgb.gif')
img_path = os.path.join(img_dir, 'pyedpro.png')
try:
pixbuf = GdkPixbuf.Pixbuf.new_from_file(img_path)
#print "loaded pixbuf"
dialog.set_logo(pixbuf)
except:
print("Cannot load logo for about dialog", img_path)
print(sys.exc_info())
#dialog.set_website("")
## Close dialog on user response
dialog.connect("response", lambda d, r: d.destroy())
dialog.connect("key-press-event", about_key)
dialog.show()
def single_render_main(root_path):
# called from .../launch/flowbladesinglerender script
gtk_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())
editorstate.gtk_version = gtk_version
try:
editorstate.mlt_version = mlt.LIBMLT_VERSION
except:
editorstate.mlt_version = "0.0.99" # magic string for "not found"
# Set paths.
respaths.set_paths(root_path)
# Load editor prefs and list of recent projects
editorpersistance.load()
# Init translations module with translations data
translations.init_languages()
translations.load_filters_translations()
mlttransitions.init_module()
# Init gtk threads
Gdk.threads_init()
Gdk.threads_enter()
# Request dark them if so desired
if editorpersistance.prefs.dark_theme == True:
Gtk.Settings.get_default().set_property("gtk-application-prefer-dark-theme", True)
repo = mlt.Factory().init()
# Set numeric locale to use "." as radix, MLT initilizes this to OS locale and this causes bugs
locale.setlocale(locale.LC_NUMERIC, 'C')
# Check for codecs and formats on the system
mltenv.check_available_features(repo)
renderconsumer.load_render_profiles()
# Load filter and compositor descriptions from xml files.
mltfilters.load_filters_xml(mltenv.services)
mlttransitions.load_compositors_xml(mltenv.transitions)
# Create list of available mlt profiles
mltprofiles.load_profile_list()
global single_render_window
single_render_window = SingleRenderWindow()
global single_render_thread
single_render_thread = SingleRenderThread()
single_render_thread.start()
Gtk.main()
Gdk.threads_leave()
def get_issue_text(traceback_text):
gtk_ver = '%i.%i.%i' % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version())
gobject_ver = '.'.join(map(str, GObject.pygobject_version))
glib_ver = '.'.join(
map(str,
[GLib.MAJOR_VERSION, GLib.MINOR_VERSION, GLib.MICRO_VERSION]))
return ISSUE_TEXT.format(get_os_info(), gtk_ver, gobject_ver, glib_ver,
nbxmpp.__version__, gajim.__version__,
traceback_text)
def __init__(self):
Gtk.Window.__init__(self, title='Hello, world!')
self.set_default_size(250, 100)
text = 'Gtk v' + str(Gtk.get_major_version()) + '.' \
+ str(Gtk.get_minor_version()) + '.' + str(Gtk.get_micro_version()) \
+ ' is installed and\nworking correctly' \
+ '\n\nClick here to close the window'
self.button = Gtk.Button(label=text)
self.button.connect('clicked', self.on_button_clicked)
self.add(self.button)
def run(self, etype, evalue, etraceback):
text = "".join(traceback.format_exception(etype, evalue, etraceback))
gtk_version = "%s.%s.%s" % (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version())
info = "\n\nPlatform: %s\nPython: %s\nGTK+:%s\n\n" % (platform.platform(),
platform.python_version(),
gtk_version)
self._textview.get_buffer().set_text(text)
clipboard = Gtk.Clipboard.get_for_display(Gdk.Display.get_default(),
Gdk.SELECTION_CLIPBOARD)
clipboard.set_text(text+info, -1)
Gtk.MessageDialog.run(self)
def main():
"""
Main function that starts everything
"""
# start DBus loop
DBusGMainLoop(set_as_default=True)
bus = dbus.SessionBus()
instance = bus.request_name(DBUS_SERVICE)
if instance != dbus.bus.REQUEST_NAME_REPLY_PRIMARY_OWNER:
print("Ulauncher is already running")
show_window = dbus.SessionBus().get_object(
DBUS_SERVICE, DBUS_PATH).get_dbus_method("show_window")
show_window()
return
_create_dirs()
options = get_options()
setup_logging(options)
logger = logging.getLogger('ulauncher')
logger.info('Ulauncher version %s' % get_version())
logger.info("GTK+ %s.%s.%s" %
(Gtk.get_major_version(), Gtk.get_minor_version(),
Gtk.get_micro_version()))
# log uncaught exceptions
def except_hook(exctype, value, tb):
logger.error("Uncaught exception", exc_info=(exctype, value, tb))
sys.excepthook = except_hook
window = UlauncherWindow.get_instance()
UlauncherDbusService(window)
if not options.hide_window:
window.show()
if Settings.get_instance().get_property('show-indicator-icon'):
AppIndicator.get_instance().show()
# workaround to make Ctrl+C quiting the app
app_killer = GracefulAppKiller()
gtk_thread = run_async(Gtk.main)()
try:
while gtk_thread.is_alive() and not app_killer.killed():
time.sleep(0.5)
except KeyboardInterrupt:
logger.warn('On KeyboardInterrupt')
finally:
Gtk.main_quit()
def main(strarr):
if(pyedlib.pedconfig.conf.verbose):
print("pydepro running on", "'" + os.name + "'", \
"GTK", Gtk._version, "PyGtk", \
"%d.%d.%d" % (Gtk.get_major_version(), \
Gtk.get_minor_version(), \
Gtk.get_micro_version()))
signal.signal(signal.SIGTERM, terminate)
mainwin = pyedlib.pedwin.EdMainWindow(None, None, strarr)
pyedlib.pedconfig.conf.pedwin = mainwin
Gtk.main()
def apply_gtk_css():
gtk_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())
if Gtk.get_major_version() == 3 and Gtk.get_minor_version() == 22:
print "Gtk version is " + gtk_version + ", Flowblade theme is available."
else:
print "Gtk version is " + gtk_version + ", Flowblade theme only available for Gtk 3.22"
return
provider = Gtk.CssProvider.new()
display = Gdk.Display.get_default()
screen = display.get_default_screen()
Gtk.StyleContext.add_provider_for_screen (screen, provider, Gtk.STYLE_PROVIDER_PRIORITY_USER)
provider.load_from_path(respaths.ROOT_PATH + "/res/css/gtk-dark-fix.css")
def _insert_library_versions(self):
"""Insert version numbers of libraries."""
dotjoin = lambda seq: ".".join(map(str, seq))
python_version = dotjoin(sys.version_info[:3])
gtk_version = dotjoin((Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version()))
pygobject_version = dotjoin(GObject.pygobject_version)
gst_version = gaupol.util.get_gst_version()
self._insert_text("Python: {}\n".format(python_version))
self._insert_text("GTK+: {}\n".format(gtk_version))
self._insert_text("PyGObject: {}\n".format(pygobject_version))
self._insert_text("GStreamer: {}\n\n".format(gst_version))
def __init_dialogs(self):
dialog = self.get_object("aboutdialog")
try:
with open('doc/LICENSE') as lfile:
dialog.set_license(lfile.read().replace('\x0c', ''))
except IOError:
dialog.set_license("License file is missing")
dialog = self.get_object("infodialog")
python = '.'.join(map(str, sys.version_info[:3]))
gtk = '{}.{}.{}'.format(Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version())
text = "You are using <b>Python v{}</b> and <b>GTK v{}</b>".format(python, gtk)
dialog.set_markup(text)
def main(root_path, force_launch=False):
gtk_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())
print "GTK+ version:", gtk_version
editorstate.gtk_version = gtk_version
try:
editorstate.mlt_version = mlt.LIBMLT_VERSION
except:
editorstate.mlt_version = "0.0.99" # magic string for "not found"
# Set paths.
respaths.set_paths(root_path)
# Load editor prefs and list of recent projects
editorpersistance.load()
# Init translations module with translations data
translations.init_languages()
translations.load_filters_translations()
mlttransitions.init_module()
# Init gtk threads
Gdk.threads_init()
Gdk.threads_enter()
repo = mlt.Factory().init()
# Set numeric locale to use "." as radix, MLT initilizes this to OS locale and this causes bugs
locale.setlocale(locale.LC_NUMERIC, 'C')
# Check for codecs and formats on the system
mltenv.check_available_features(repo)
renderconsumer.load_render_profiles()
# Load filter and compositor descriptions from xml files.
mltfilters.load_filters_xml(mltenv.services)
mlttransitions.load_compositors_xml(mltenv.transitions)
# Create list of available mlt profiles
mltprofiles.load_profile_list()
appconsts.SAVEFILE_VERSION = projectdata.SAVEFILE_VERSION
global linker_window
linker_window = MediaLinkerWindow()
Gtk.main()
Gdk.threads_leave()
def apply_gtk_css():
gtk_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())
if Gtk.get_major_version() == 3 and Gtk.get_minor_version() >= 22:
print "Gtk version is " + gtk_version + ", Flowblade theme is available."
else:
print "Gtk version is " + gtk_version + ", Flowblade theme only available for Gtk >= 3.22"
editorpersistance.prefs.theme = appconsts.LIGHT_THEME
editorpersistance.save()
return False
provider = Gtk.CssProvider.new()
display = Gdk.Display.get_default()
screen = display.get_default_screen()
Gtk.StyleContext.add_provider_for_screen (screen, provider, Gtk.STYLE_PROVIDER_PRIORITY_USER)
provider.load_from_path(respaths.ROOT_PATH + "/res/css/gtk-flowblade-dark.css")
return True
def get_platform_info():
from gi.repository import GObject
from gi.repository import Gtk
import yaml
functions = [
platform.machine, platform.platform, platform.processor,
platform.python_version, platform.release, platform.system
]
names_values = [(func.__name__, func()) for func in functions]
names_values.extend([
('GTK', (Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version())),
('Glib', GObject.glib_version),
('PyGObject', GObject.pygobject_version),
('YAML', yaml.__version__),
])
vals = ['%s: %s' % (name, val) for name, val in names_values]
return 'System info: ' + ', '.join(vals)
def _insert_dependencies(self):
"""Insert version numbers of selected dependencies."""
dotjoin = lambda x: ".".join(map(str, x))
chardet_version = aeidon.util.get_chardet_version()
enchant_version = aeidon.util.get_enchant_version()
gst_version = gaupol.util.get_gst_version()
gtk_version = dotjoin((
Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version(),
))
pygobject_version = dotjoin(GObject.pygobject_version)
python_version = dotjoin(sys.version_info[:3])
self._insert_text("aeidon: {}\n".format(aeidon.__version__))
self._insert_text("chardet: {}\n".format(chardet_version))
self._insert_text("enchant: {}\n".format(enchant_version))
self._insert_text("gaupol: {}\n".format(gaupol.__version__))
self._insert_text("gstreamer: {}\n".format(gst_version))
self._insert_text("gtk+: {}\n".format(gtk_version))
self._insert_text("pygobject: {}\n".format(pygobject_version))
self._insert_text("python: {}\n".format(python_version))
def install_compat():
from gi.repository import Gtk
from gi.repository import Gdk
from gi.repository import GdkPixbuf
sys.modules['gtk'] = Gtk
sys.modules['gtk.gdk'] = Gdk
Gtk.gdk = Gdk
Gtk.keysyms = Gdk
Gdk.Pixbuf = GdkPixbuf.Pixbuf
def pixbuf_new_from_file(filename):
return GdkPixbuf.Pixbuf()
Gdk.pixbuf_new_from_file = pixbuf_new_from_file
Gtk.gtk_version = (Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version())
Gtk.widget_get_default_direction = Gtk.Widget.get_default_direction
class GenericCellRenderer(Gtk.CellRenderer):
pass
Gtk.GenericCellRenderer = GenericCellRenderer
# Enums
Gtk.ICON_SIZE_MENU = Gtk.IconSize.MENU
Gtk.JUSTIFY_LEFT = Gtk.Justification.LEFT
Gtk.JUSTIFY_RIGHT = Gtk.Justification.RIGHT
Gtk.POS_RIGHT = Gtk.PositionType.RIGHT
Gtk.POLICY_AUTOMATIC = Gtk.PolicyType.AUTOMATIC
Gtk.POLICY_ALWAYS = Gtk.PolicyType.ALWAYS
Gtk.SELECTION_BROWSE = Gtk.SelectionMode.BROWSE
Gtk.SELECTION_NONE = Gtk.SelectionMode.NONE
Gtk.SORT_ASCENDING = Gtk.SortType.ASCENDING
Gtk.SHADOW_ETCHED_IN = Gtk.ShadowType.ETCHED_IN
Gtk.STATE_NORMAL = Gtk.StateType.NORMAL
Gdk.BUTTON_PRESS = Gdk.EventType.BUTTON_PRESS
Gtk.TEXT_DIR_RTL = Gtk.TextDirection.RTL
def check_gtk_version():
""" Check GTK version """
# Check desired GTK Version
major_needed = int(_gtk_version_needed.split(".")[0])
minor_needed = int(_gtk_version_needed.split(".")[1])
micro_needed = int(_gtk_version_needed.split(".")[2])
# Check system GTK Version
major = Gtk.get_major_version()
minor = Gtk.get_minor_version()
micro = Gtk.get_micro_version()
# Thus will be called from our liveCD that already has the latest GTK version
# This is here just to help testing Thus in our environment.
if major_needed > major or (major_needed == major and minor_needed > minor) or \
(major_needed == major and minor_needed == minor and micro_needed > micro):
print("Detected GTK %d.%d.%d but %s is needed. Can't run this installer." %
(major, minor, micro, _gtk_version_needed))
return False
else:
print("Using GTK v%d.%d.%d" % (major, minor, micro))
return True
def init(core):
"Do init specific for this widget toolkit"
# mapping between the real widget and the wal widget
core['avccd'].widget_map = { \
Gtk.Button: core['Button'], \
Gtk.Calendar: core['Calendar'], \
Gtk.CheckButton: core['ToggleButton'], \
Gtk.ComboBoxText: core['ComboBox'],\
Gtk.ColorChooserWidget: core['ColorChooser'],\
Gtk.Entry: core['Entry'], \
Gtk.Label: core['Label'], \
Gtk.ProgressBar: core['ProgressBar'], \
Gtk.RadioButton: core['RadioButton'], \
Gtk.HScale: core['Slider'], \
Gtk.SpinButton: core['SpinButton'], \
Gtk.Statusbar: core['StatusBar'], \
Gtk.TextView: core['TextView'], \
Gtk.ToggleButton: core['ToggleButton'], \
Gtk.TreeView: core['listtreeview'], \
Gtk.VScale: core['Slider']}
# get toolkit version
core['avccd'].toolkit_version = str(Gtk.get_major_version()) + '.' + \
str(Gtk.get_minor_version()) + '.' + str(Gtk.get_micro_version())
def threads_init():
"""
For applications that wish to use Python threads to interact with the GNOME platform,
GObject.threads_init() must be called prior to running or creating threads and starting
main loops (see notes below for PyGObject 3.10 and greater). Generally, this should be done
in the first stages of an applications main entry point or right after importing GObject.
For multi-threaded GUI applications Gdk.threads_init() must also be called prior to running
Gtk.main() or Gio/Gtk.Application.run().
"""
minor = Gtk.get_minor_version()
micro = Gtk.get_micro_version()
if minor == 10 and micro < 2:
# Unfortunately these versions of PyGObject suffer a bug
# which require a workaround to get threading working properly.
# Workaround: Force GIL creation
import threading
threading.Thread(target=lambda: None).start()
# Since version 3.10.2, calling threads_init is no longer needed.
# See: https://wiki.gnome.org/PyGObject/Threading
if minor < 10 or (minor == 10 and micro < 2):
GObject.threads_init()
try:
# :raises ValueError: If module/version is already loaded, already
# required, or unavailable.
gi.require_version("Gtk", "3.0")
except ValueError as e:
# in this case we want to re-raise as ImportError so the
# auto-backend selection logic correctly skips.
raise ImportError from e
from gi.repository import GLib, GObject, Gtk, Gdk
_log = logging.getLogger(__name__)
backend_version = "%s.%s.%s" % (
Gtk.get_major_version(), Gtk.get_micro_version(), Gtk.get_minor_version())
# the true dots per inch on the screen; should be display dependent
# see http://groups.google.com/groups?q=screen+dpi+x11&hl=en&lr=&ie=UTF-8&oe=UTF-8&safe=off&selm=7077.26e81ad5%40swift.cs.tcd.ie&rnum=5 for some info about screen dpi
PIXELS_PER_INCH = 96
try:
cursord = {
cursors.MOVE : Gdk.Cursor.new(Gdk.CursorType.FLEUR),
cursors.HAND : Gdk.Cursor.new(Gdk.CursorType.HAND2),
cursors.POINTER : Gdk.Cursor.new(Gdk.CursorType.LEFT_PTR),
cursors.SELECT_REGION : Gdk.Cursor.new(Gdk.CursorType.TCROSS),
cursors.WAIT : Gdk.Cursor.new(Gdk.CursorType.WATCH),
}
except TypeError as exc:
# Happens when running headless. Convert to ImportError to cooperate with
def show_settings():
"""
Shows settings of all of the major components.
"""
py_str = '%d.%d.%d' % sys.version_info[:3]
try:
from gi.repository import Gtk
try:
gtkver_str = '%d.%d.%d' % (Gtk.get_major_version(),
Gtk.get_minor_version(), Gtk.get_micro_version())
except : # any failure to 'get' the version
gtkver_str = 'unknown version'
except ImportError:
gtkver_str = 'not found'
# no DISPLAY is a RuntimeError in an older pygtk (e.g. 2.17 in Fedora 14)
except RuntimeError:
gtkver_str = 'DISPLAY not set'
#exept TypeError: To handle back formatting on version split
try:
from gi.repository import GObject
try:
pygobjectver_str = '%d.%d.%d' % GObject.pygobject_version
except :# any failure to 'get' the version
pygobjectver_str = 'unknown version'
except ImportError:
pygobjectver_str = 'not found'
try:
from gi.repository import Pango
try:
pangover_str = Pango.version_string()
except :# any failure to 'get' the version
pangover_str = 'unknown version'
except ImportError:
pangover_str = 'not found'
try:
import cairo
try:
pycairover_str = '%d.%d.%d' % cairo.version_info
cairover_str = cairo.cairo_version_string()
except :# any failure to 'get' the version
pycairover_str = 'unknown version'
cairover_str = 'unknown version'
except ImportError:
pycairover_str = 'not found'
cairover_str = 'not found'
try:
from gi import Repository
repository = Repository.get_default()
if repository.enumerate_versions("OsmGpsMap"):
from gi.repository import OsmGpsMap as osmgpsmap
try:
osmgpsmap_str = osmgpsmap._version
except :# any failure to 'get' the version
osmgpsmap_str = 'unknown version'
else:
osmgpsmap_str = 'not found'
except ImportError:
osmgpsmap_str = 'not found'
try:
from gi import Repository
repository = Repository.get_default()
if repository.enumerate_versions("GExiv2"):
from gi.repository import GExiv2
try:
gexiv2_str = GExiv2._version
except: # any failure to 'get' the version
gexiv2_str = 'unknown version'
else:
gexiv2_str = 'not found'
except ImportError:
gexiv2_str = 'not found'
try:
import PyICU
try:
pyicu_str = PyICU.VERSION
icu_str = PyICU.ICU_VERSION
except: # any failure to 'get' the version
pyicu_str = 'unknown version'
icu_str = 'unknown version'
except ImportError:
pyicu_str = 'not found'
icu_str = 'not found'
try:
import bsddb3 as bsddb
bsddb_str = bsddb.__version__
bsddb_db_str = str(bsddb.db.version()).replace(', ', '.')\
.replace('(', '').replace(')', '')
except:
bsddb_str = 'not found'
bsddb_db_str = 'not found'
try:
from .gen.const import VERSION
gramps_str = VERSION
except:
gramps_str = 'not found'
if hasattr(os, "uname"):
kernel = os.uname()[2]
else:
kernel = None
lang_str = get_env_var('LANG','not set')
language_str = get_env_var('LANGUAGE','not set')
grampsi18n_str = get_env_var('GRAMPSI18N','not set')
grampshome_str = get_env_var('GRAMPSHOME','not set')
grampsdir_str = get_env_var('GRAMPSDIR','not set')
try:
dotversion_str = Popen(['dot', '-V'], stderr=PIPE).communicate(input=None)[1]
if isinstance(dotversion_str, bytes) and sys.stdin.encoding:
dotversion_str = dotversion_str.decode(sys.stdin.encoding)
if dotversion_str:
dotversion_str = dotversion_str.replace('\n','')[23:27]
except:
dotversion_str = 'Graphviz not in system PATH'
try:
if win():
gsversion_str = Popen(['gswin32c', '--version'], stdout=PIPE).communicate(input=None)[0]
else:
gsversion_str = Popen(['gs', '--version'], stdout=PIPE).communicate(input=None)[0]
if isinstance(gsversion_str, bytes) and sys.stdin.encoding:
gsversion_str = gsversion_str.decode(sys.stdin.encoding)
if gsversion_str:
gsversion_str = gsversion_str.replace('\n', '')
except:
gsversion_str = 'Ghostscript not in system PATH'
os_path = get_env_var('PATH','not set')
os_path = os_path.split(os.pathsep)
print ("Gramps Settings:")
print ("----------------")
print (' python : %s' % py_str)
print (' gramps : %s' % gramps_str)
print (' gtk++ : %s' % gtkver_str)
print (' pygobject : %s' % pygobjectver_str)
print (' pango : %s' % pangover_str)
print (' bsddb : %s' % bsddb_str)
print (' bsddb.db : %s' % bsddb_db_str)
print (' cairo : %s' % cairover_str)
print (' pycairo : %s' % pycairover_str)
print (' osmgpsmap : %s' % osmgpsmap_str)
print (' GExiv2 : %s' % gexiv2_str)
print (' ICU : %s' % icu_str)
print (' PyICU : %s' % pyicu_str)
print (' o.s. : %s' % sys.platform)
if kernel:
print (' kernel : %s' % kernel)
print ('')
print ("Environment settings:")
print ("---------------------")
print (' LANG : %s' % lang_str)
print (' LANGUAGE : %s' % language_str)
print (' GRAMPSI18N: %s' % grampsi18n_str)
print (' GRAMPSHOME: %s' % grampshome_str)
print (' GRAMPSDIR : %s' % grampsdir_str)
print (' PYTHONPATH:')
for folder in sys.path:
print (" ", folder)
print ('')
print ("Non-python dependencies:")
print ("------------------------")
print (' Graphviz : %s' % dotversion_str)
print (' Ghostscr. : %s' % gsversion_str)
print ('')
print ("System PATH env variable:")
print ("-------------------------")
for folder in os_path:
print (" ", folder)
print ('')
def __init__(self, config_file=None, use_plugins=True, use_style=True):
super(KingPhisherClientApplication, self).__init__()
if use_style:
self._theme_file = 'theme.css'
else:
self._theme_file = DISABLED
self.logger = logging.getLogger('KingPhisher.Client.Application')
# log version information for debugging purposes
self.logger.debug("gi.repository GLib version: {0}".format('.'.join(map(str, GLib.glib_version))))
self.logger.debug("gi.repository GObject version: {0}".format('.'.join(map(str, GObject.pygobject_version))))
self.logger.debug("gi.repository Gtk version: {0}.{1}.{2}".format(Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()))
if rpc_terminal.has_vte:
self.logger.debug("gi.repository VTE version: {0}".format(rpc_terminal.Vte._version))
if graphs.has_matplotlib:
self.logger.debug("matplotlib version: {0}".format(graphs.matplotlib.__version__))
self.set_property('application-id', 'org.king-phisher.client')
self.set_property('register-session', True)
self.config_file = config_file or os.path.join(USER_DATA_PATH, 'config.json')
"""The file containing the King Phisher client configuration."""
if not os.path.isfile(self.config_file):
self._create_config()
self.config = None
"""The primary King Phisher client configuration."""
self.main_window = None
"""The primary top-level :py:class:`~.MainAppWindow` instance."""
self.rpc = None
"""The :py:class:`~.KingPhisherRPCClient` instance for the application."""
self._ssh_forwarder = None
"""The SSH forwarder responsible for tunneling RPC communications."""
self.style_provider = None
try:
self.emit('config-load', True)
except IOError:
self.logger.critical('failed to load the client configuration')
raise
self.connect('window-added', self.signal_window_added)
self.actions = {}
self._create_actions()
if not use_plugins:
self.logger.info('disabling all plugins')
self.config['plugins.enabled'] = []
self.plugin_manager = plugins.ClientPluginManager(
[os.path.join(USER_DATA_PATH, 'plugins'), find.find_data_directory('plugins')],
self
)
if use_plugins:
self.plugin_manager.load_all()
from matplotlib._pylab_helpers import Gcf
from matplotlib.backend_bases import RendererBase, GraphicsContextBase, \
FigureManagerBase, FigureCanvasBase, NavigationToolbar2, cursors, TimerBase
from matplotlib.backend_bases import ShowBase
from matplotlib.cbook import is_string_like, is_writable_file_like
from matplotlib.colors import colorConverter
from matplotlib.figure import Figure
from matplotlib.widgets import SubplotTool
from matplotlib import lines
from matplotlib import cbook
from matplotlib import verbose
from matplotlib import rcParams
backend_version = "%s.%s.%s" % (Gtk.get_major_version(), Gtk.get_micro_version(), Gtk.get_minor_version())
_debug = False
#_debug = True
# the true dots per inch on the screen; should be display dependent
# see http://groups.google.com/groups?q=screen+dpi+x11&hl=en&lr=&ie=UTF-8&oe=UTF-8&safe=off&selm=7077.26e81ad5%40swift.cs.tcd.ie&rnum=5 for some info about screen dpi
PIXELS_PER_INCH = 96
cursord = {
cursors.MOVE : Gdk.Cursor.new(Gdk.CursorType.FLEUR),
cursors.HAND : Gdk.Cursor.new(Gdk.CursorType.HAND2),
cursors.POINTER : Gdk.Cursor.new(Gdk.CursorType.LEFT_PTR),
cursors.SELECT_REGION : Gdk.Cursor.new(Gdk.CursorType.TCROSS),
}