def _apply_css(config):
if OSDWindow.css_provider:
Gtk.StyleContext.remove_provider_for_screen(
Gdk.Screen.get_default(), OSDWindow.css_provider)
colors = {}
for x in config['osk_colors'] : colors["osk_%s" % (x,)] = config['osk_colors'][x]
for x in config['osd_colors'] : colors[x] = config['osd_colors'][x]
colors = OSDCssMagic(colors)
try:
css_file = os.path.join(get_share_path(), "osd-styles", config["osd_style"])
css = file(css_file, "r").read()
if ((Gtk.get_major_version(), Gtk.get_minor_version()) > (3, 20)):
css += OSDWindow.CSS_3_20
OSDWindow.css_provider = Gtk.CssProvider()
OSDWindow.css_provider.load_from_data((css % colors).encode("utf-8"))
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(),
OSDWindow.css_provider,
Gtk.STYLE_PROVIDER_PRIORITY_USER)
except GLib.Error, e:
log.error("Failed to apply css with user settings:")
log.error(e)
log.error("Retrying with default values")
OSDWindow.css_provider = Gtk.CssProvider()
css_file = os.path.join(get_share_path(), "osd-styles", "Classic.gtkstyle.css")
css = file(css_file, "r").read()
if ((Gtk.get_major_version(), Gtk.get_minor_version()) > (3, 20)):
css += OSDWindow.CSS_3_20
OSDWindow.css_provider.load_from_data((css % colors).encode("utf-8"))
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(),
OSDWindow.css_provider,
Gtk.STYLE_PROVIDER_PRIORITY_USER)
def init(self):
"""
Init main application
"""
self.__is_fs = False
if Gtk.get_minor_version() > 18:
cssProviderFile = Gio.File.new_for_uri(
'resource:///org/gnome/Lollypop/application.css')
else:
cssProviderFile = Gio.File.new_for_uri(
'resource:///org/gnome/Lollypop/application-legacy.css')
cssProvider = Gtk.CssProvider()
cssProvider.load_from_file(cssProviderFile)
screen = Gdk.Screen.get_default()
styleContext = Gtk.StyleContext()
styleContext.add_provider_for_screen(screen, cssProvider,
Gtk.STYLE_PROVIDER_PRIORITY_USER)
self.settings = Settings.new()
self.db = Database()
self.playlists = Playlists()
# We store cursors for main thread
SqlCursor.add(self.db)
SqlCursor.add(self.playlists)
self.albums = AlbumsDatabase()
self.artists = ArtistsDatabase()
self.genres = GenresDatabase()
self.tracks = TracksDatabase()
self.player = Player()
self.scanner = CollectionScanner()
self.art = Art()
self.art.update_art_size()
if self.settings.get_value('artist-artwork'):
GLib.timeout_add(5000, self.art.cache_artists_info)
if LastFM is not None:
self.lastfm = LastFM()
if not self.settings.get_value('disable-mpris'):
# Ubuntu > 16.04
if Gtk.get_minor_version() > 18:
from lollypop.mpris import MPRIS
# Ubuntu <= 16.04, Debian Jessie, ElementaryOS
else:
from lollypop.mpris_legacy import MPRIS
MPRIS(self)
if not self.settings.get_value('disable-notifications'):
from lollypop.notification import NotificationManager
self.notify = NotificationManager()
settings = Gtk.Settings.get_default()
dark = self.settings.get_value('dark-ui')
settings.set_property('gtk-application-prefer-dark-theme', dark)
self.add_action(self.settings.create_action('playback'))
self.add_action(self.settings.create_action('shuffle'))
self.db.upgrade()
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 __init__(self, parent):
self.ui = Gtk.Builder()
self.ui.add_from_resource('/org/gnome/Music/PlaylistDialog.ui')
self.dialog_box = self.ui.get_object('dialog1')
self.dialog_box.set_transient_for(parent)
self.view = self.ui.get_object('treeview1')
self.selection = self.ui.get_object('treeview-selection1')
self._add_list_renderers()
self.view.connect('row-activated', self._on_item_activated)
self.model = self.ui.get_object('liststore1')
playlist_names = playlist.get_playlists()
self.populate(playlist_names)
self.title_bar = self.ui.get_object('headerbar1')
if Gtk.get_minor_version() > 8:
self.dialog_box.set_titlebar(self.title_bar)
else:
self.dialog_box.get_content_area().add(self.title_bar)
self.dialog_box.get_content_area().reorder_child(self.title_bar, 0)
self._cancel_button = self.ui.get_object('cancel-button')
self._select_button = self.ui.get_object('select-button')
self._cancel_button.connect('clicked', self._on_cancel_button_clicked)
self._select_button.connect('clicked', self._on_selection)
def get_workarea_dimensions(window=None):
"""
Returns the x-offset, y-offset, width and height of the work area
for a given window or for the default screen if no window is given.
Falls back to the screen dimensions if not available.
:param window: class: `Gtk.Window`, optional
:returns: :class:`CairoRectangleInt`
"""
if window is None:
screen = Gdk.Screen.get_default()
default_monitor = screen.get_primary_monitor()
return screen.get_monitor_workarea(default_monitor)
elif (
Gtk.get_major_version() > 3
or Gtk.get_major_version() == 3
and Gtk.get_minor_version() >= 22
):
# Gdk.Monitor was introduced in Gtk+ 3.22
display = window.get_window().get_display()
work_area = display.get_monitor_at_window(window.get_window()).get_workarea()
else:
screen = window.get_screen()
monitor_nr = screen.get_monitor_at_window(window.get_window())
work_area = screen.get_monitor_workarea(monitor_nr)
return work_area
def do_draw(self, context, background_area, cell_area, start, end, state):
GtkSource.GutterRendererPixbuf.do_draw(
self, context, background_area, cell_area, start, end, state)
if self.is_action:
if Gtk.get_minor_version() < 20:
style_context = get_style(None, "GtkButton.flat.image-button")
style_context.add_class(Gtk.STYLE_CLASS_BUTTON)
style_context.add_class(Gtk.STYLE_CLASS_FLAT)
else:
# TODO: Fix padding and min-height in CSS and use
# draw_style_common
style_context = get_style(None, "button.flat.image-button")
style_context.set_state(renderer_to_gtk_state(state))
x = background_area.x + 1
y = background_area.y + 1
width = background_area.width - 2
height = background_area.height - 2
Gtk.render_background(style_context, context, x, y, width, height)
Gtk.render_frame(style_context, context, x, y, width, height)
pixbuf = self.props.pixbuf
pix_width, pix_height = pixbuf.props.width, pixbuf.props.height
Gtk.render_icon(
style_context, context, pixbuf,
x + (width - pix_width) // 2,
y + (height - pix_height) // 2)
self.draw_chunks(
context, background_area, cell_area, start, end, state)
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):
GObject.GObject.__init__(self)
self._stack_switcher = Gtk.StackSwitcher(
margin_top=2, margin_bottom=2, can_focus=False, halign="center")
self._stack_switcher.show()
self._ui = Gtk.Builder()
self._ui.add_from_resource('/org/gnome/Music/headerbar.ui')
self.header_bar = self._ui.get_object('header-bar')
self._search_button = self._ui.get_object('search-button')
self.dropdown = DropDown()
self.searchbar = Searchbar(self._stack_switcher, self._search_button, self.dropdown)
self.dropdown.initialize_filters(self.searchbar)
self._select_button = self._ui.get_object('select-button')
self._cancel_button = self._ui.get_object('done-button')
self._back_button = self._ui.get_object('back-button')
self._selection_menu = self._ui.get_object('selection-menu')
self._selection_menu_button = self._ui.get_object('selection-menu-button')
self._selection_menu_label = self._ui.get_object('selection-menu-button-label')
self._selection_menu_button.set_relief(Gtk.ReliefStyle.NONE)
if Gtk.get_minor_version() >= 11:
self.header_bar.remove(self._select_button)
self.header_bar.remove(self._cancel_button)
self.header_bar.remove(self._search_button)
self.header_bar.pack_end(self._select_button)
self.header_bar.pack_end(self._cancel_button)
self.header_bar.pack_end(self._search_button)
self._back_button.connect('clicked', self.on_back_button_clicked)
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__(self):
"""
Init toolbar
"""
Gtk.Bin.__init__(self)
InfosController.__init__(self, ArtSize.SMALL)
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/Lollypop/ToolbarInfo.ui')
builder.connect_signals(self)
self._pop_tunein = None
self._pop_info = None
self._timeout_id = None
self._width = 0
self._infobox = builder.get_object('info')
self.add(self._infobox)
self._labels = builder.get_object('nowplaying_labels')
self._title_label = builder.get_object('title')
self._artist_label = builder.get_object('artist')
self._cover_frame = builder.get_object('frame')
self._cover = builder.get_object('cover')
self._cover.set_property('has-tooltip', True)
# Since GTK 3.20, we can set cover full height
if Gtk.get_minor_version() > 18:
self._cover.get_style_context().add_class('toolbar-cover-frame')
else:
self._cover.get_style_context().add_class('small-cover-frame')
self.connect('realize', self._on_realize)
Lp().art.connect('album-artwork-changed', self._update_cover)
Lp().art.connect('radio-artwork-changed', self._update_logo)
def __init__(self, show_menu, show_loved):
"""
Init row widget and show it
@parma show menu as bool
@param show loved as bool
"""
Row.__init__(self, show_loved)
self._grid.insert_column(0)
self._grid.attach(self._indicator, 0, 0, 1, 1)
self.show_all()
button = Gtk.Button.new_from_icon_name('open-menu-symbolic',
Gtk.IconSize.MENU)
button.set_relief(Gtk.ReliefStyle.NONE)
button.get_style_context().add_class('menu-button')
button.get_style_context().add_class('track-menu-button')
button.get_image().set_opacity(0.2)
self._grid.add(button)
# TODO: Remove this test later
if show_menu or Gtk.get_minor_version() > 16:
button.show()
self._show_menu = True
self._row_widget.connect('button-press-event',
self._on_button_press)
button.connect('clicked', self._on_button_clicked)
else:
self._show_menu = False
button.hide()
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 do_startup(self):
Gtk.Application.do_startup(self)
signal.signal(signal.SIGINT, signal.SIG_DFL)
action = Gio.SimpleAction.new("stations", None)
action.connect("activate", self.stations_cb)
self.add_action(action)
action = Gio.SimpleAction.new("preferences", None)
action.connect("activate", self.prefs_cb)
self.add_action(action)
action = Gio.SimpleAction.new("about", None)
action.connect("activate", self.about_cb)
self.add_action(action)
action = Gio.SimpleAction.new("quit", None)
action.connect("activate", self.quit_cb)
self.add_action(action)
if Gtk.get_major_version() > 3 or Gtk.get_minor_version() >= 20:
menu = self.get_app_menu()
it = menu.iterate_item_links(menu.get_n_items() - 1)
assert(it.next())
last_section = it.get_value()
shortcuts_item = Gio.MenuItem.new(_('Keyboard Shortcuts'), 'win.show-help-overlay')
last_section.prepend_item(shortcuts_item)
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 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_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 prepare_content_display(item, textview=None):
if textview is None:
text_view = Gtk.TextView()
else:
text_view = textview
text_view.set_name('storyview') # For CSS
# Border sizes
if Gtk.get_major_version() == 3 and Gtk.get_minor_version() >= 20:
text_view.set_left_margin(12)
text_view.set_right_margin(12)
text_view.set_bottom_margin(5)
text_view.set_top_margin(5)
else:
text_view.set_border_window_size(Gtk.TextWindowType.LEFT, 10)
text_view.set_border_window_size(Gtk.TextWindowType.RIGHT, 12) # Slightly more than left due to scroll bar
text_view.set_border_window_size(Gtk.TextWindowType.TOP, 5)
text_view.set_border_window_size(Gtk.TextWindowType.TOP, 5)
text_view.set_wrap_mode(Gtk.WrapMode.WORD_CHAR)
text_view.set_editable(False)
text_view.set_cursor_visible(False)
text_buffer = Gtk.TextBuffer()
text_view.set_buffer(text_buffer)
if item:
TextFormat.headline(item.title, text_buffer)
TextFormat.description(item.description, text_buffer)
TextFormat.article(item.article, text_buffer)
return text_view
def _build_app_menu(self):
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/Lollypop/app-menu.ui')
menu = builder.get_object('app-menu')
self.set_app_menu(menu)
#TODO: Remove this test later
if Gtk.get_minor_version() > 12:
settingsAction = Gio.SimpleAction.new('settings', None)
settingsAction.connect('activate', self._edit_settings)
self.add_action(settingsAction)
partyAction = Gio.SimpleAction.new('party', None)
partyAction.connect('activate', self._edit_party)
self.add_action(partyAction)
updateAction = Gio.SimpleAction.new('update_db', None)
updateAction.connect('activate', self._update_db)
self.add_action(updateAction)
aboutAction = Gio.SimpleAction.new('about', None)
aboutAction.connect('activate', self._about)
self.add_action(aboutAction)
quitAction = Gio.SimpleAction.new('quit', None)
quitAction.connect('activate', self.quit)
self.add_action(quitAction)
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 _init_window(self):
Gtk.Window.__init__(self, title="Oo-mox GUI")
self.set_default_size(500, 300)
self.set_border_width(6)
win_style_context = self.get_style_context()
css_provider = Gtk.CssProvider()
try:
if Gtk.get_minor_version() == 20:
css_provider.load_from_path(
os.path.join(script_dir, "theme20.css")
)
else:
css_provider.load_from_path(
os.path.join(script_dir, "theme.css")
)
except GLib.Error as e:
print(e)
screen = Gdk.Screen.get_default()
win_style_context.add_provider_for_screen(
screen, css_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
)
self._init_headerbar()
self.box = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=6)
self.add(self.box)
def _setup_app_menu(self):
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/Lollypop/app-menu.ui')
menu = builder.get_object('app-menu')
# TODO: Remove this test later
if Gtk.get_minor_version() > 12:
settingsAction = Gio.SimpleAction.new('settings', None)
settingsAction.connect('activate', self._settings_dialog)
self.add_action(settingsAction)
updateAction = Gio.SimpleAction.new('update_db', None)
updateAction.connect('activate', self._update_db)
self.add_action(updateAction)
fsAction = Gio.SimpleAction.new('fullscreen', None)
fsAction.connect('activate', self._fullscreen)
self.add_action(fsAction)
aboutAction = Gio.SimpleAction.new('about', None)
aboutAction.connect('activate', self._about)
self.add_action(aboutAction)
quitAction = Gio.SimpleAction.new('quit', None)
quitAction.connect('activate', self.quit)
self.add_action(quitAction)
return menu
def _on_row_activated(self, widget, row):
"""
Play searched item when selected
@param widget as Gtk.ListBox
@param row as SearchRow
"""
if Lp().player.is_party() or Lp().player.locked or Lp().player.queued:
if row.is_track():
if Lp().player.locked or Lp().player.queued:
if row.get_id() in Lp().player.get_queue():
Lp().player.del_from_queue(row.get_id())
else:
Lp().player.append_to_queue(row.get_id())
row.destroy()
else:
Lp().player.load(Track(row.get_id()))
elif Gtk.get_minor_version() > 16:
popover = AlbumPopover(row.get_id(), [], [])
popover.set_relative_to(row)
popover.show()
else:
t = Thread(target=self._play_search, args=(row.get_id(),
row.is_track()))
t.daemon = True
t.start()
else:
t = Thread(target=self._play_search, args=(row.get_id(),
row.is_track()))
t.daemon = True
t.start()
def update_preview_carets(self, colorscheme):
css_provider_caret = Gtk.CssProvider()
css_provider_caret.load_from_data((
(Gtk.get_minor_version() >= 20 and """
* {{
caret-color: #{primary_caret_color};
-gtk-secondary-caret-color: #{secondary_caret_color};
-GtkWidget-cursor-aspect-ratio: {caret_aspect_ratio};
}}
""" or """
* {{
-GtkWidget-cursor-color: #{primary_caret_color};
-GtkWidget-secondary-cursor-color: #{secondary_caret_color};
-GtkWidget-cursor-aspect-ratio: {caret_aspect_ratio};
}}
""").format(
primary_caret_color=colorscheme['CARET1_FG'],
secondary_caret_color=colorscheme['CARET2_FG'],
caret_aspect_ratio=colorscheme['CARET_SIZE']
)
).encode('ascii'))
Gtk.StyleContext.add_provider(
self.entry.get_style_context(),
css_provider_caret,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
)
def _override_css_style(self):
css_provider = Gtk.CssProvider()
try:
if Gtk.get_minor_version() >= 20:
css_provider.load_from_path(
os.path.join(script_dir, "theme20.css")
)
else:
css_provider.load_from_path(
os.path.join(script_dir, "theme.css")
)
except GLib.Error as e:
print(e)
for widget in [
self,
self.label,
self.sel_label,
self.entry,
self.button,
self.headerbar,
self.headerbar_button
] + self.get_menu_widgets(self.menubar):
Gtk.StyleContext.add_provider(
widget.get_style_context(),
css_provider,
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION
)
def get_link_at_location(self, view, x, y):
"""
Get the link under a specified x,y coordinate. If no link exists then
None is returned.
"""
# get the offset within the buffer from the x,y coordinates
buff_x, buff_y = view.window_to_buffer_coords(Gtk.TextWindowType.TEXT,
x, y)
# usual API breakage in GTK+3, nothing new...
# see https://bugzilla.gnome.org/768793
if Gtk.get_minor_version() >= 20:
(over_text, iter_at_xy) = view.get_iter_at_location(buff_x, buff_y)
if not over_text:
return None
else:
iter_at_xy = view.get_iter_at_location(buff_x, buff_y)
offset = iter_at_xy.get_offset()
# find the first link that contains the offset
for lnk in self.links:
if offset >= lnk.start and offset <= lnk.end:
return lnk
# no link was found at x,y
return None
def gtk_version():
'''
returns float of the major and minor parts of the GTK version
e.g. return float(3.10)
'''
return float(str(Gtk.get_major_version()) + "." + str(Gtk.get_minor_version()))
def __init__(self):
GObject.GObject.__init__(self)
self._stack_switcher = Gtk.StackSwitcher(margin_top=2, margin_bottom=2, can_focus=False)
self._stack_switcher.show()
self._ui = Gtk.Builder()
self._ui.add_from_resource('/org/gnome/Music/headerbar.ui')
self.header_bar = self._ui.get_object('header-bar')
self._search_button = self._ui.get_object('search-button')
self.searchbar = Searchbar(self._stack_switcher, self._search_button)
self._select_button = self._ui.get_object('select-button')
self._cancel_button = self._ui.get_object('done-button')
self._back_button = self._ui.get_object('back-button')
self._selection_menu = self._ui.get_object('selection-menu')
self._selection_menu_button = self._ui.get_object('selection-menu-button')
self._selection_menu_label = self._ui.get_object('selection-menu-button-label')
self._selection_menu_button.set_relief(Gtk.ReliefStyle.NONE)
if Gtk.Widget.get_default_direction() is Gtk.TextDirection.RTL:
_back_button_image = self._ui.get_object('back-button-image')
_back_button_image.set_property('icon-name', 'go-previous-rtl-symbolic')
if Gtk.get_minor_version() >= 11:
self.header_bar.remove(self._select_button)
self.header_bar.remove(self._cancel_button)
self.header_bar.remove(self._search_button)
self.header_bar.pack_end(self._select_button)
self.header_bar.pack_end(self._cancel_button)
self.header_bar.pack_end(self._search_button)
self._back_button.connect('clicked', self.on_back_button_clicked)
def undock(self, widget):
""" remove the widget from the leaf-notebook
if this was the only widget, remove this leaf from its owner """
gtk_version = (Gtk.get_major_version(), Gtk.get_minor_version())
if gtk_version >= (3, 16):
self.book.detach_tab(widget)
else:
# To not destroy accidentally our panel widget we need to add a reference to it
# https://lazka.github.io/pgi-docs/#Gtk-3.0/classes/Container.html#Gtk.Container.remove
widget._ref()
self.book.remove(widget)
for i, (widget_, title, id) in enumerate(self.panels):
if widget_ == widget:
break
else:
raise KeyError("No %s in %s" % (widget, self))
del self.panels[i]
if self.book.get_n_pages() == 0:
parent = self.get_parent()
while not isinstance(parent, PyDockComposite):
parent = parent.get_parent()
parent.removeComponent(self)
self._del()
return title, id
def shortcuts_dialog():
if Gtk.get_major_version() >= 3 and Gtk.get_minor_version() >= 20:
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/TwoFactorAuth/shortcuts.ui')
shortcuts = builder.get_object("shortcuts")
return shortcuts
return None
def dark_mode_toggled(self, widget, data=None):
if widget.get_active():
# Dark Mode is on
# Hack for f*****g unico-shit
if Gtk.get_minor_version() == 4:
css = open(helpers.get_media_path('style_dark_old.css'), 'rb')
else:
css = open(helpers.get_media_path('style_dark.css'), 'rb')
css_data = css.read()
css.close()
self.style_provider.load_from_data(css_data)
self.background_image = helpers.get_media_path('bg_dark.png')
self.MarkupBuffer.dark_mode(True)
else:
# Dark mode off
css = open(helpers.get_media_path('style.css'), 'rb')
css_data = css.read()
css.close()
self.style_provider.load_from_data(css_data)
self.background_image = helpers.get_media_path('bg_light.png')
self.MarkupBuffer.dark_mode(False)
surface = cairo.ImageSurface.create_from_png(self.background_image)
self.background_pattern = cairo.SurfacePattern(surface)
self.background_pattern.set_extend(cairo.EXTEND_REPEAT)
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), self.style_provider,
Gtk.STYLE_PROVIDER_PRIORITY_USER
)
(w, h) = self.get_size()
self.resize(w+1, h+1)
def on_dbus_name_appeared(_connection, name, owner):
logging.info("%s %s" % (name, owner))
setup_icon_path()
try:
self.Applet = AppletService()
except DBusProxyFailed:
print("Blueman applet needs to be running")
exit()
check_bluetooth_status(
_("Bluetooth needs to be turned on for the device manager to function"
), lambda: Gtk.main_quit())
manager = Manager()
try:
manager.get_adapter(self.Config['last-adapter'])
except DBusNoSuchAdapterError:
logging.error(
'Default adapter not found, trying first available.')
try:
manager.get_adapter(None)
except DBusNoSuchAdapterError:
logging.error('No adapter(s) found, exiting')
exit(1)
self.Applet.connect('g-signal', on_applet_signal)
self.connect("delete-event", on_window_delete)
self.props.icon_name = "blueman"
w, h, x, y = self.Config["window-properties"]
if w and h:
self.resize(w, h)
if x and y:
self.move(x, y)
sw = self.Builder.get_object("scrollview")
# Disable overlay scrolling
if Gtk.get_minor_version() >= 16:
sw.props.overlay_scrolling = False
self.List = ManagerDeviceList(adapter=self.Config["last-adapter"],
inst=self)
self.List.show()
sw.add(self.List)
self.Toolbar = ManagerToolbar(self)
self.Menu = ManagerMenu(self)
self.Stats = ManagerStats(self)
if self.List.is_valid_adapter():
self.List.display_known_devices(autoselect=True)
self.List.connect("adapter-changed", self.on_adapter_changed)
toolbar = self.Builder.get_object("toolbar")
statusbar = self.Builder.get_object("statusbar")
self.Config.bind_to_widget("show-toolbar", toolbar, "visible")
self.Config.bind_to_widget("show-statusbar", statusbar, "visible")
self.show()
def have_gtk_version(version_string):
[major, minor, micro] = version_string.split(".", 3)
return Gtk.get_major_version() >= eval(major) and \
Gtk.get_minor_version() >= eval(minor) and \
Gtk.get_micro_version() >= eval(micro)
def __init__(self, album_id, genre_ids, artist_ids, show_cover):
"""
Init detailed album widget
@param album id as int
@param genre ids as [int]
@param artist ids as [int]
@param lazy as LazyLoadingView
@param show cover as bool
"""
Gtk.Bin.__init__(self)
AlbumWidget.__init__(self, album_id, genre_ids)
self._album.set_artists(artist_ids)
self.__width = None
# Cover + rating + spacing
self.__height = ArtSize.BIG + 26
self.__orientation = None
self.__child_height = TrackRow.get_best_height(self)
# Header + separator + spacing + margin
self.__requested_height = self.__child_height + 6
# Discs to load, will be emptied
self.__discs = self._album.discs
self.__locked_widget_right = True
self._filter_ids = artist_ids
self.set_property('height-request', self.__height)
self.connect('size-allocate', self.__on_size_allocate)
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/Lollypop/AlbumDetailedWidget.ui')
self._widget = builder.get_object('widget')
self.__overlay = builder.get_object('overlay')
self._play_button = builder.get_object('play-button')
self._artwork_button = builder.get_object('artwork-button')
self._action_button = builder.get_object('action-button')
self._action_event = builder.get_object('action-event')
builder.connect_signals(self)
rating = RatingWidget(self._album)
rating.show()
artist_label = builder.get_object('artist')
if show_cover:
self._cover = builder.get_object('cover')
builder.get_object('duration').set_hexpand(True)
self._cover.get_style_context().add_class('cover-frame')
self.__coverbox = builder.get_object('coverbox')
self.__coverbox.show()
# 6 for 2*3px (application.css)
self.__coverbox.set_property('width-request', ArtSize.BIG + 6)
self.__coverbox.add(rating)
if Lp().window.get_view_width() < WindowSize.MEDIUM:
self.__coverbox.hide()
if len(artist_ids) > 1:
artist_label.set_text(", ".join(self._album.artists))
artist_label.show()
else:
builder.get_object('header').attach(rating, 4, 0, 1, 1)
rating.set_hexpand(True)
rating.set_property('halign', Gtk.Align.END)
rating.set_property('valign', Gtk.Align.CENTER)
artist_label.set_text(", ".join(self._album.artists))
artist_label.show()
self._cover = None
self.__duration_label = builder.get_object('duration')
self.__set_duration()
self.__box = Gtk.Grid()
self.__box.set_column_homogeneous(True)
self.__box.set_property('valign', Gtk.Align.START)
self.__box.show()
builder.get_object('albuminfo').add(self.__box)
self._tracks_left = {}
self._tracks_right = {}
self.set_cover()
self.update_state()
builder.get_object('title').set_label(self._album.name)
if self._album.year:
year = builder.get_object('year')
year.set_label(self._album.year)
year.show()
for disc in self.__discs:
self.__add_disc_container(disc.number)
self.__set_disc_height(disc)
self.add(self._widget)
# We start transparent, we switch opaque at size allocation
# This prevent artifacts
self.set_opacity(0)
self._menu = builder.get_object('menu')
self._menu.connect('clicked', self.__pop_menu)
# TODO Remove this later
if Gtk.get_minor_version() > 16:
self._menu.show()
else:
self.connect('map', self.__on_map)
if self._album.is_youtube and show_cover:
self._cover.get_style_context().add_class('cover-frame-youtube')
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),
}
def reconfigure(self):
"""Update configuration for the whole application"""
if self.style_providers:
for style_provider in self.style_providers:
Gtk.StyleContext.remove_provider_for_screen(
Gdk.Screen.get_default(), style_provider)
self.style_providers = []
# Force the window background to be transparent for newer versions of
# GTK3. We then have to fix all the widget backgrounds because the
# widgets theming may not render it's own background.
css = """
.terminator-terminal-window {
background-color: alpha(@theme_bg_color,0); }
.terminator-terminal-window .notebook.header,
.terminator-terminal-window notebook header {
background-color: @theme_bg_color; }
.terminator-terminal-window .pane-separator {
background-color: @theme_bg_color; }
.terminator-terminal-window .terminator-terminal-searchbar {
background-color: @theme_bg_color; }
"""
# Fix several themes that put a borders, corners, or backgrounds around
# viewports, making the titlebar look bad.
css += """
.terminator-terminal-window GtkViewport,
.terminator-terminal-window viewport {
border-width: 0px;
border-radius: 0px;
background-color: transparent; }
"""
# Add per profile snippets for setting the background of the HBox
template = """
.terminator-profile-%s {
background-color: alpha(%s, %s); }
"""
profiles = self.config.base.profiles
bgcolor = None
for profile in profiles.keys():
if not profiles[profile]['use_theme_colors']:
bgcolor = profiles[profile]['background_color']
if profiles[profile]['background_type'] == 'transparent':
bgalpha = profiles[profile]['background_darkness']
else:
bgalpha = '1'
munged_profile = ''.join(
[c if c.isalnum() else '-' for c in profile])
css += template % (munged_profile, bgcolor, bgalpha)
style_provider = Gtk.CssProvider()
style_provider.load_from_data(css.encode('utf8'))
self.style_providers.append(style_provider)
# Attempt to load some theme specific stylistic tweaks for appearances
usr_theme_dir = os.path.join(os.getenv('XDG_DATA_HOME'), 'themes')
(head, _tail) = os.path.split(borg.__file__)
app_theme_dir = os.path.join(head, 'themes')
theme_name = self.gtk_settings.get_property('gtk-theme-name')
theme_part_list = ['terminator.css']
if self.config[
'extra_styling']: # checkbox_style - needs adding to prefs
theme_part_list.append('terminator_styling.css')
for theme_part_file in theme_part_list:
for theme_dir in [usr_theme_dir, app_theme_dir]:
path_to_theme_specific_css = os.path.join(
theme_dir, theme_name, 'gtk-3.0/apps', theme_part_file)
if os.path.isfile(path_to_theme_specific_css):
style_provider = Gtk.CssProvider()
style_provider.connect('parsing-error',
self.on_css_parsing_error)
try:
style_provider.load_from_path(
path_to_theme_specific_css)
except GError:
# Hmmm. Should we try to provide GTK version specific files here on failure?
gtk_version_string = '.'.join([
str(Gtk.get_major_version()),
str(Gtk.get_minor_version()),
str(Gtk.get_micro_version())
])
err(f'Error(s) loading css from {path_to_theme_specific_css} into Gtk {gtk_version_string}'
)
self.style_providers.append(style_provider)
break
# Size the GtkPaned splitter handle size.
if self.config['handle_size'] in range(0, 21):
hsize = self.config['handle_size']
css = f'''.terminator-terminal-window GtkPaned,
.terminator-terminal-window paned
{{min-width: {hsize}px;min-height: {hsize}px;}}'''
style_provider = Gtk.CssProvider()
style_provider.load_from_data(css.encode())
self.style_providers.append(style_provider)
# Apply the providers, incrementing priority so they don't cancel out
# each other
for idx in range(0, len(self.style_providers)):
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), self.style_providers[idx],
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION + idx)
# Cause all the terminals to reconfigure
for terminal in self.terminals:
terminal.reconfigure()
# Reparse our keybindings
self.keybindings.configure(self.config['keybindings'])
# Update tab position if appropriate
maker = Factory()
for window in self.windows:
child = window.get_child()
if maker.isinstance(child, 'Notebook'):
child.configure()
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())
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
# backend switching.
raise ImportError(exc)
def show_settings():
"""
Shows settings of all of the major components.
"""
py_str = '%d.%d.%d' % sys.version_info[:3]
try:
import gi
gi.require_version('Gtk', '3.0')
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, ValueError):
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"):
import gi
gi.require_version('OsmGpsMap', '1.0')
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"):
import gi
gi.require_version('GExiv2', '0.10')
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'
except ValueError:
gexiv2_str = 'not new enough'
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(')', '')
bsddb_location_str = bsddb.__file__
except:
bsddb_str = 'not found'
bsddb_db_str = 'not found'
bsddb_location_str = 'not found'
try:
import sqlite3
sqlite3_py_version_str = sqlite3.version
sqlite3_version_str = sqlite3.sqlite_version
sqlite3_location_str = sqlite3.__file__
except:
sqlite3_version_str = 'not found'
sqlite3_py_version_str = 'not found'
sqlite3_location_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')
gramps_resources_str = get_env_var('GRAMPS_RESOURCES', '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():
try:
gsversion_str = Popen(['gswin32c', '--version'],
stdout=PIPE).communicate(input=None)[0]
except:
gsversion_str = Popen(['gswin64c', '--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(' 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)
if __debug__:
print(' GRAMPS_RESOURCES : %s' % gramps_resources_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('')
print("Databases:")
print("-------------------------")
print(' bsddb :')
print(' version : %s' % bsddb_str)
print(' db version : %s' % bsddb_db_str)
print(' location : %s' % bsddb_location_str)
print(' sqlite3 :')
print(' version : %s' % sqlite3_version_str)
print(' py version : %s' % sqlite3_py_version_str)
print(' location : %s' % sqlite3_location_str)
print('')
def close(self, object=None):
if Gtk.get_minor_version() < 22:
self.popover.hide()
else:
self.popover.popdown()
def __init_window(self):
"""
Add fields for all ui objects we need to access from code.
Initialize everything we can't do from glade like events and other stuff.
"""
log.info("Initialize main window")
self.window = self.window_builder.get_object("app_window")
self.window.set_default_size(1100, 700)
self.window.set_application(self.app)
self.window.show_all()
self.window.present()
self.window.connect("delete-event", self.on_close)
self.window.connect("drag_data_received", self.__on_drag_data_received)
self.window.drag_dest_set(
Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT
| Gtk.DestDefaults.DROP,
[Gtk.TargetEntry.new("text/uri-list", 0, 80)], Gdk.DragAction.COPY)
# resizing the progress bar for older gtk versions
if not Gtk.get_minor_version() > 18:
self.window.connect("check-resize", self.__window_resized)
self.author_box = self.window_builder.get_object("author_box")
self.reader_box = self.window_builder.get_object("reader_box")
self.book_box = self.window_builder.get_object("book_box")
self.book_scroller = self.window_builder.get_object("book_scroller")
self.sort_stack = self.window_builder.get_object("sort_stack")
self.sort_box = self.window_builder.get_object("sort_box")
self.import_box = self.window_builder.get_object("import_box")
self.position_box = self.window_builder.get_object("position_box")
self.main_stack = self.window_builder.get_object("main_stack")
self.author_toggle_button = self.window_builder.get_object(
"author_toggle_button")
self.reader_toggle_button = self.window_builder.get_object(
"reader_toggle_button")
self.no_media_file_chooser = self.window_builder.get_object(
"no_media_file_chooser")
self.no_media_file_chooser.connect("file-set",
self.__on_no_media_folder_changed)
self.auto_scan_switch = self.window_builder.get_object(
"auto_scan_switch")
# get about dialog
self.about_dialog = self.about_builder.get_object("about_dialog")
self.about_dialog.set_transient_for(self.window)
self.about_dialog.connect("delete-event", self.hide_window)
self.about_dialog.set_version(self.version)
# shortcuts
self.accel = Gtk.AccelGroup()
# sorting and filtering
self.author_box.connect("row-activated", self.__on_listbox_changed)
self.reader_box.connect("row-activated", self.__on_listbox_changed)
self.book_box.set_sort_func(self.__sort_books, None, False)
self.book_box.set_filter_func(self.__filter_books, None, False)
self.book_box.connect("selected-children-changed",
self.__on_book_selec_changed)
# button actions
self.author_toggle_button.connect("toggled", self.__toggle_author)
self.reader_toggle_button.connect("toggled", self.__toggle_reader)
try:
about_close_button = self.about_builder.get_object(
"button_box").get_children()[2]
if about_close_button is not None:
about_close_button.connect("clicked",
self.__about_close_clicked)
except Exception as e:
log.info("Not connecting about close button.")
player.add_player_listener(self.__player_changed)
def get_backend_name():
"""The GDK backend name"""
display = Gdk.Display.get_default()
if display is not None:
name = display.__gtype__.name
if name.startswith("Gdk"):
name = name[3:]
if name.endswith("Display"):
name = name[:-7]
return name
return u"Unknown"
gtk_version = (Gtk.get_major_version(), Gtk.get_minor_version(),
Gtk.get_micro_version())
pygobject_version = gi.version_info
def io_add_watch(fd, prio, condition, func, *args, **kwargs):
try:
# The new gir bindings don't fail with an invalid fd,
# and we can't do the same with the static ones (return a valid
# source ID..) so fail with newer pygobject as well.
if isinstance(fd, int) and fd < 0:
raise ValueError("invalid fd")
elif hasattr(fd, "fileno") and fd.fileno() < 0:
raise ValueError("invalid fd")
return GLib.io_add_watch(fd, prio, condition, func, *args, **kwargs)
everyThing = []
everyThing.sort()
count = 0
for theFile in everyThing:
fileName , extension = os.path.splitext(theFile)
extension = extension.lower()
if True:
count += 1
iterFiles = liststoreFiles.append()
liststoreFiles.set(iterFiles, 0, theFile)
treeviewcolumnFilename = self.builder.get_object('treeviewcolumnFilename')
treeviewcolumnFilename.set_title('Files ({})'.format(count))
if __name__ == '__main__':
# An initial message.
print('Operating System is "{}". Desktop is "{}".'.format(platform.system(), os.environ.get('DESKTOP_SESSION')))
print('GTK+ Version {}.{}.{} (expecting GTK+3).'.format(Gtk.get_major_version(), Gtk.get_minor_version(), Gtk.get_micro_version()))
# Main GTK loop.
mainWindow = MainWindow(args)
mainWindow.window.show_all()
Gtk.main()
# A final message
print('Goodbye from the \033[1;31mGTK+ Treeview Test\033[0;m program.')
def __init__(self, album_id, genre_id, pop_allowed, size_group):
"""
Init detailed album widget
@param album id as int
@param genre id as int
@param parent width as int
@param pop_allowed as bool if widget can show popovers
@param size group as Gtk.SizeGroup
"""
Gtk.Bin.__init__(self)
AlbumWidget.__init__(self, album_id, genre_id=genre_id)
self._pop_allowed = pop_allowed
builder = Gtk.Builder()
builder.add_from_resource('/org/gnome/Lollypop/%s.ui' %
type(self).__name__)
self._color = builder.get_object('color')
rating = RatingWidget(self._album)
rating.show()
builder.get_object('coverbox').add(rating)
builder.connect_signals(self)
self._artist_label = builder.get_object('artist')
label = builder.get_object('duration')
duration = Lp().albums.get_duration(album_id, genre_id)
hours = int(duration / 3600)
mins = int(duration / 60)
if hours > 0:
mins -= hours * 60
if mins > 0:
label.set_text(_("%s h %s m") % (hours, mins))
else:
label.set_text(_("%s h") % hours)
else:
label.set_text(_("%s m") % mins)
grid = builder.get_object('tracks')
self._discs = self._album.discs
self._tracks_left = {}
self._tracks_right = {}
show_label = len(self._discs) > 1
i = 0
for disc in self._discs:
index = disc.number
if show_label:
label = Gtk.Label()
label.set_text(_("Disc %s") % index)
label.set_property('halign', Gtk.Align.START)
label.get_style_context().add_class('dim-label')
if i:
label.set_property('margin-top', 30)
label.show()
grid.attach(label, 0, i, 2, 1)
i += 1
self._tracks_left[index] = TracksWidget(pop_allowed, True)
self._tracks_right[index] = TracksWidget(pop_allowed, True)
grid.attach(self._tracks_left[index], 0, i, 1, 1)
grid.attach(self._tracks_right[index], 1, i, 1, 1)
size_group.add_widget(self._tracks_left[index])
size_group.add_widget(self._tracks_right[index])
self._tracks_left[index].connect('activated', self._on_activated)
self._tracks_left[index].connect('button-press-event',
self._on_button_press_event)
self._tracks_right[index].connect('activated', self._on_activated)
self._tracks_right[index].connect('button-press-event',
self._on_button_press_event)
self._tracks_left[index].show()
self._tracks_right[index].show()
i += 1
self._cover = builder.get_object('cover')
self.set_cover()
self.update_state()
builder.get_object('title').set_label(self._album.name)
if self._album.year:
year = builder.get_object('year')
year.set_label(self._album.year)
year.show()
self.add(builder.get_object('widget'))
# TODO: Remove this test later
if pop_allowed or Gtk.get_minor_version() > 16:
self._menu = builder.get_object('menu')
self._menu.connect('clicked', self._pop_menu)
self._menu.show()
def reconfigure(self):
"""Update configuration for the whole application"""
if self.style_providers != []:
for style_provider in self.style_providers:
Gtk.StyleContext.remove_provider_for_screen(
Gdk.Screen.get_default(), style_provider)
self.style_providers = []
# Force the window background to be transparent for newer versions of
# GTK3. We then have to fix all the widget backgrounds because the
# widgets theming may not render it's own background.
css = """
.terminator-terminal-window {
background-color: alpha(@theme_bg_color,0); }
.terminator-terminal-window .notebook.header,
.terminator-terminal-window notebook header {
background-color: @theme_bg_color; }
.terminator-terminal-window .pane-separator {
background-color: @theme_bg_color; }
.terminator-terminal-window .terminator-terminal-searchbar {
background-color: @theme_bg_color; }
"""
# Fix several themes that put a borders, corners, or backgrounds around
# viewports, making the titlebar look bad.
css += """
.terminator-terminal-window GtkViewport,
.terminator-terminal-window viewport {
border-width: 0px;
border-radius: 0px;
background-color: transparent; }
"""
# Add per profile snippets for setting the background of the HBox
template = """
.terminator-profile-%s {
background-color: alpha(%s, %s); }
"""
profiles = self.config.base.profiles
for profile in profiles.keys():
if profiles[profile]['use_theme_colors']:
# Create a dummy window/vte and realise it so it has correct
# values to read from
tmp_win = Gtk.Window()
tmp_vte = Vte.Terminal()
tmp_win.add(tmp_vte)
tmp_win.realize()
bgcolor = tmp_vte.get_style_context().get_background_color(
Gtk.StateType.NORMAL)
bgcolor = "#{0:02x}{1:02x}{2:02x}".format(
int(bgcolor.red * 255), int(bgcolor.green * 255),
int(bgcolor.blue * 255))
tmp_win.remove(tmp_vte)
del (tmp_vte)
del (tmp_win)
else:
bgcolor = Gdk.RGBA()
bgcolor = profiles[profile]['background_color']
if profiles[profile]['background_type'] == 'transparent':
bgalpha = profiles[profile]['background_darkness']
else:
bgalpha = "1"
munged_profile = "".join(
[c if c.isalnum() else "-" for c in profile])
css += template % (munged_profile, bgcolor, bgalpha)
style_provider = Gtk.CssProvider()
style_provider.load_from_data(css)
self.style_providers.append(style_provider)
# Attempt to load some theme specific stylistic tweaks for appearances
usr_theme_dir = os.path.expanduser('~/.local/share/themes')
(head, _tail) = os.path.split(borg.__file__)
app_theme_dir = os.path.join(head, 'themes')
theme_name = self.gtk_settings.get_property('gtk-theme-name')
theme_part_list = ['terminator.css']
if self.config[
'extra_styling']: # checkbox_style - needs adding to prefs
theme_part_list.append('terminator_styling.css')
for theme_part_file in theme_part_list:
for theme_dir in [usr_theme_dir, app_theme_dir]:
path_to_theme_specific_css = os.path.join(
theme_dir, theme_name, 'gtk-3.0/apps', theme_part_file)
if os.path.isfile(path_to_theme_specific_css):
style_provider = Gtk.CssProvider()
style_provider.connect('parsing-error',
self.on_css_parsing_error)
try:
style_provider.load_from_path(
path_to_theme_specific_css)
except GError:
# Hmmm. Should we try to provide GTK version specific files here on failure?
gtk_version_string = '.'.join([
str(Gtk.get_major_version()),
str(Gtk.get_minor_version()),
str(Gtk.get_micro_version())
])
err('Error(s) loading css from %s into Gtk %s' %
(path_to_theme_specific_css, gtk_version_string))
self.style_providers.append(style_provider)
break
# Size the GtkPaned splitter handle size.
css = ""
if self.config['handle_size'] in xrange(0, 21):
css += """
.terminator-terminal-window GtkPaned,
.terminator-terminal-window paned {
-GtkPaned-handle-size: %s; }
""" % self.config['handle_size']
style_provider = Gtk.CssProvider()
style_provider.load_from_data(css)
self.style_providers.append(style_provider)
# Apply the providers, incrementing priority so they don't cancel out
# each other
for idx in xrange(0, len(self.style_providers)):
Gtk.StyleContext.add_provider_for_screen(
Gdk.Screen.get_default(), self.style_providers[idx],
Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION + idx)
# Cause all the terminals to reconfigure
for terminal in self.terminals:
terminal.reconfigure()
# Reparse our keybindings
self.keybindings.configure(self.config['keybindings'])
# Update tab position if appropriate
maker = Factory()
for window in self.windows:
child = window.get_child()
if maker.isinstance(child, 'Notebook'):
child.configure()
def main(root_path):
"""
Called at application start.
Initializes application with a default project.
"""
# DEBUG: Direct output to log file if log file set
if _log_file != None:
log_print_output_to_file()
print "Application version: " + editorstate.appversion
# Print OS, Python version and GTK+ version
try:
os_release_file = open("/etc/os-release", "r")
os_text = os_release_file.read()
s_index = os_text.find("PRETTY_NAME=")
e_index = os_text.find("\n", s_index)
print "OS: " + os_text[s_index + 13:e_index - 1]
except:
pass
print "Python", sys.version
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"
#print "SDL version:", str(editorstate.get_sdl_version())
# passing -xdg as a flag will change the user_dir location with XDG_CONFIG_HOME
# For full xdg-app support all the launch processes need to add this too, currently not impl.
for arg in sys.argv:
if arg.lower() == "-xdg":
editorstate.use_xdg = True
# Create hidden folders if not present
user_dir = utils.get_hidden_user_dir_path()
print "User dir:", user_dir
if not os.path.exists(user_dir):
os.mkdir(user_dir)
if not os.path.exists(user_dir + mltprofiles.USER_PROFILES_DIR):
os.mkdir(user_dir + mltprofiles.USER_PROFILES_DIR)
if not os.path.exists(user_dir + AUTOSAVE_DIR):
os.mkdir(user_dir + AUTOSAVE_DIR)
if not os.path.exists(user_dir + BATCH_DIR):
os.mkdir(user_dir + BATCH_DIR)
if not os.path.exists(user_dir + appconsts.AUDIO_LEVELS_DIR):
os.mkdir(user_dir + appconsts.AUDIO_LEVELS_DIR)
if not os.path.exists(utils.get_hidden_screenshot_dir_path()):
os.mkdir(utils.get_hidden_screenshot_dir_path())
if not os.path.exists(user_dir + appconsts.GMIC_DIR):
os.mkdir(user_dir + appconsts.GMIC_DIR)
if not os.path.exists(user_dir + appconsts.MATCH_FRAME_DIR):
os.mkdir(user_dir + appconsts.MATCH_FRAME_DIR)
if not os.path.exists(user_dir + appconsts.TRIM_VIEW_DIR):
os.mkdir(user_dir + appconsts.TRIM_VIEW_DIR)
if not os.path.exists(user_dir + appconsts.NATRON_DIR):
os.mkdir(user_dir + appconsts.NATRON_DIR)
# Set paths.
respaths.set_paths(root_path)
# Load editor prefs and list of recent projects
editorpersistance.load()
if editorpersistance.prefs.theme != appconsts.LIGHT_THEME:
respaths.apply_dark_theme()
if editorpersistance.prefs.display_all_audio_levels == False:
editorstate.display_all_audio_levels = False
editorpersistance.create_thumbs_folder_if_needed(user_dir)
editorpersistance.create_rendered_clips_folder_if_needed(user_dir)
editorpersistance.save()
# Init translations module with translations data
translations.init_languages()
translations.load_filters_translations()
mlttransitions.init_module()
# Apr-2017 - SvdB - Keyboard shortcuts
shortcuts.load_shortcut_files()
shortcuts.load_shortcuts()
# We respaths and translations data available so we need to init in a function.
workflow.init_data()
# RHEL7/CentOS compatibility fix
if gtk_version == "3.8.8":
GObject.threads_init()
# 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()
# Load drag'n'drop images
dnd.init()
# Adjust gui parameters for smaller screens
scr_w = Gdk.Screen.width()
scr_h = Gdk.Screen.height()
editorstate.SCREEN_WIDTH = scr_w
editorstate.SCREEN_HEIGHT = scr_h
print "Screen size:", scr_w, "x", scr_h
print "Small height:", editorstate.screen_size_small_height()
print "Small width:", editorstate.screen_size_small_width()
_set_draw_params()
# Refuse to run on too small screen.
if scr_w < 1151 or scr_h < 767:
_too_small_screen_exit()
return
# Splash screen
if editorpersistance.prefs.display_splash_screen == True:
show_splash_screen()
# Init MLT framework
repo = mlt.Factory().init()
repo.producers().set('qimage', None, 0)
repo.producers().set('qtext', None, 0)
repo.producers().set('kdenlivetitle', None, 0)
# 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)
# Replace some services if better replacements available.
mltfilters.replace_services(mltenv.services)
# Create list of available mlt profiles.
mltprofiles.load_profile_list()
# Save assoc file path if found in arguments.
global assoc_file_path
assoc_file_path = get_assoc_file_path()
# There is always a project open, so at startup we create a default project.
# Set default project as the project being edited.
editorstate.project = projectdata.get_default_project()
check_crash = True
# Audiomonitoring being available needs to be known before GUI creation.
audiomonitoring.init(editorstate.project.profile)
# Set trim view mode to current default value.
editorstate.show_trim_view = editorpersistance.prefs.trim_view_default
# Check for tools and init tools integration.
gmic.test_availablity()
toolnatron.init()
toolsintegration.init()
#toolsintegration.test()
# Create player object.
create_player()
# Create main window and set widget handles in gui.py for more convenient reference.
create_gui()
# Inits widgets with project data.
init_project_gui()
# Inits widgets with current sequence data.
init_sequence_gui()
# Launch player now that data and gui exist
launch_player()
# Editor and modules need some more initializing.
init_editor_state()
# Tracks need to be recentered if window is resized.
# Connect listener for this now that the tline panel size allocation is sure to be available.
global window_resize_id, window_state_id
window_resize_id = gui.editor_window.window.connect(
"size-allocate", lambda w, e: updater.window_resized())
window_state_id = gui.editor_window.window.connect(
"window-state-event", lambda w, e: updater.window_resized())
# Get existing autosave files
autosave_files = get_autosave_files()
# Show splash
if ((editorpersistance.prefs.display_splash_screen == True)
and len(autosave_files) == 0
) and not editorstate.runtime_version_greater_then_test_version(
editorpersistance.prefs.workflow_dialog_last_version_shown,
editorstate.appversion):
global splash_timeout_id
splash_timeout_id = GLib.timeout_add(2600, destroy_splash_screen)
splash_screen.show_all()
appconsts.SAVEFILE_VERSION = projectdata.SAVEFILE_VERSION # THIS IS A QUESTIONABLE IDEA TO SIMPLIFY IMPORTS, NOT DRY. WHEN DOING TOOLS THAT RUN IN ANOTHER PROCESSES AND SAVE PROJECTS, THIS LINE NEEDS TO BE THERE ALSO.
# Every running instance has unique autosave file which is deleted at exit
set_instance_autosave_id()
# Existance of autosave file hints that program was exited abnormally.
if check_crash == True and len(autosave_files) > 0:
if len(autosave_files) == 1:
GObject.timeout_add(10, autosave_recovery_dialog)
else:
GObject.timeout_add(10, autosaves_many_recovery_dialog)
else:
start_autosave()
# We prefer to monkeypatch some callbacks into some modules, usually to
# maintain a simpler and/or non-circular import structure.
monkeypatch_callbacks()
# File in assoc_file_path is opened after very short delay.
if not (check_crash == True and len(autosave_files) > 0):
if assoc_file_path != None:
print "Launch assoc file:", assoc_file_path
global assoc_timeout_id
assoc_timeout_id = GObject.timeout_add(10, open_assoc_file)
# SDL 2 consumer needs to created after Gtk.main() has run enough for window to be visble
#if editorstate.get_sdl_version() == editorstate.SDL_2: # needs more state considerion still
# print "SDL2 timeout launch"
# global sdl2_timeout_id
# sdl2_timeout_id = GObject.timeout_add(1500, create_sdl_2_consumer)
# In PositionNumericalEntries we are using Gtk.Entry objects in a way that works for us nicely, but is somehow "error" for Gtk, so we just kill this.
Gtk.Settings.get_default().set_property("gtk-error-bell", False)
# Show first run worflow info dialog if not shown for this version of application.
if editorstate.runtime_version_greater_then_test_version(
editorpersistance.prefs.workflow_dialog_last_version_shown,
editorstate.appversion):
GObject.timeout_add(500, show_worflow_info_dialog)
# Launch gtk+ main loop
Gtk.main()
Gdk.threads_leave()
def __init__(self, config, language, languages, able_to_lock_screen, on_save_settings, glade_file):
self.config = config
self.on_save_settings = on_save_settings
self.languages = []
builder = Gtk.Builder()
builder.add_from_file(glade_file)
builder.connect_signals(self)
# Get the UI components
self.window = builder.get_object('window_settings')
self.spin_short_break_duration = builder.get_object('spin_short_break_duration')
self.spin_long_break_duration = builder.get_object('spin_long_break_duration')
self.spin_interval_between_two_breaks = builder.get_object('spin_interval_between_two_breaks')
self.spin_short_between_long = builder.get_object('spin_short_between_long')
self.spin_time_to_prepare = builder.get_object('spin_time_to_prepare')
self.spin_idle_time_to_pause = builder.get_object('spin_idle_time_to_pause')
self.spin_postpone_duration = builder.get_object('spin_postpone_duration')
self.switch_strict_break = builder.get_object('switch_strict_break')
self.switch_postpone = builder.get_object('switch_postpone')
self.switch_audible_alert = builder.get_object('switch_audible_alert')
self.cmb_language = builder.get_object('cmb_language')
self.switch_screen_lock = builder.get_object('switch_screen_lock')
self.spin_time_to_screen_lock = builder.get_object('spin_time_to_screen_lock')
# Translate the UI labels
builder.get_object('lbl_short_break').set_label(language['ui_controls']['short_break_duration'])
builder.get_object('lbl_long_break').set_label(language['ui_controls']['long_break_duration'])
builder.get_object('lbl_interval_bettween_breaks').set_label(language['ui_controls']['interval_between_two_breaks'])
builder.get_object('lbl_short_per_long').set_label(language['ui_controls']['no_of_short_breaks_between_two_long_breaks'])
builder.get_object('lbl_time_to_prepare').set_label(language['ui_controls']['time_to_prepare_for_break'])
builder.get_object('lbl_idle_time_to_pause').set_label(language['ui_controls']['idle_time'])
builder.get_object('lbl_postpone_duration').set_label(language['ui_controls']['postpone_duration'])
builder.get_object('lbl_allow_postpone').set_label(language['ui_controls']['allow_postpone'])
builder.get_object('lbl_strict_break').set_label(language['ui_controls']['strict_break'])
builder.get_object('lbl_audible_alert').set_label(language['ui_controls']['audible_alert'])
builder.get_object('lbl_language').set_label(language['ui_controls']['language'])
builder.get_object('lbl_enable_screen_lock').set_label(language['ui_controls']['enable_screen_lock'])
builder.get_object('lbl_lock_screen_after').set_label(language['ui_controls']['time_to_screen_lock'])
builder.get_object('btn_cancel').set_label(language['ui_controls']['cancel'])
builder.get_object('btn_save').set_label(language['ui_controls']['save'])
# Set the current values of input fields
self.spin_short_break_duration.set_value(config['short_break_duration'])
self.spin_long_break_duration.set_value(config['long_break_duration'])
self.spin_interval_between_two_breaks.set_value(config['break_interval'])
self.spin_short_between_long.set_value(config['no_of_short_breaks_per_long_break'])
self.spin_time_to_prepare.set_value(config['pre_break_warning_time'])
self.spin_idle_time_to_pause.set_value(config['idle_time'])
self.spin_postpone_duration.set_value(config['postpone_duration'])
self.switch_strict_break.set_active(config['strict_break'])
self.switch_audible_alert.set_active(config['audible_alert'])
self.spin_time_to_screen_lock.set_value(config['time_to_screen_lock'])
# Enable idle_time_to_pause only if xprintidle is available
self.spin_idle_time_to_pause.set_sensitive(Utility.command_exist('xprintidle'))
self.switch_screen_lock.set_sensitive(able_to_lock_screen)
self.switch_screen_lock.set_active(able_to_lock_screen and config['enable_screen_lock'])
self.switch_postpone.set_active(config['allow_postpone'] and not config['strict_break'])
# Update relative states
# GtkSwitch state-set signal is available only from 3.14
if Gtk.get_minor_version() >= 14:
self.switch_strict_break.connect('state-set', self.on_switch_strict_break_activate)
self.switch_screen_lock.connect('state-set', self.on_switch_screen_lock_activate)
self.switch_postpone.connect('state-set', self.on_switch_postpone_activate)
self.on_switch_strict_break_activate(self.switch_strict_break, self.switch_strict_break.get_active())
self.on_switch_screen_lock_activate(self.switch_screen_lock, self.switch_screen_lock.get_active())
self.on_switch_postpone_activate(self.switch_postpone, self.switch_postpone.get_active())
# Initialize the language combobox
language_list_store = Gtk.ListStore(GObject.TYPE_STRING)
language_index = 2
lang_code = config['language']
# Add 'System Language' as the first option
language_list_store.append([language['ui_controls']['system_language']])
language_list_store.append(['-'])
self.languages.append('system')
self.languages.append('system') # Dummy record for row separator
if 'system' == lang_code:
self.cmb_language.set_active(0)
for key in sorted(languages.keys()):
language_list_store.append([languages[key]])
self.languages.append(key)
if key == lang_code:
self.cmb_language.set_active(language_index)
language_index += 1
self.cmb_language.set_model(language_list_store)
self.cmb_language.set_row_separator_func(lambda m,i: m.get_value(i, 0) == '-')
cell = Gtk.CellRendererText()
self.cmb_language.pack_start(cell, True)
self.cmb_language.add_attribute(cell, 'text', 0)
def main():
(options, leftovers) = parse_commandline()
cli.setupLogging("virt-manager", options.debug, False, False)
log.debug("virt-manager version: %s", BuildConfig.version)
log.debug("virtManager import: %s", os.path.dirname(__file__))
if BuildConfig.running_from_srcdir:
_setup_gsettings_path(BuildConfig.gsettings_dir)
if options.trace_libvirt:
log.debug("Libvirt tracing requested")
from .lib import module_trace
import libvirt
module_trace.wrap_module(libvirt,
mainloop=(options.trace_libvirt == "mainloop"),
regex=None)
CLITestOptions = CLITestOptionsClass(options.test_options)
# With F27 gnome+wayland we need to set these before GTK import
os.environ["GSETTINGS_SCHEMA_DIR"] = BuildConfig.gsettings_dir
# Now we've got basic environment up & running we can fork
do_drop_stdio = False
if not options.no_fork and not options.debug:
drop_tty()
do_drop_stdio = True
# Ignore SIGHUP, otherwise a serial console closing drops the whole app
signal.signal(signal.SIGHUP, signal.SIG_IGN)
leftovers = _import_gtk(leftovers)
Gtk = globals()["Gtk"]
# Do this after the Gtk import so the user has a chance of seeing any error
if do_drop_stdio:
drop_stdio()
if leftovers:
raise RuntimeError("Unhandled command line options '%s'" % leftovers)
log.debug("PyGObject version: %d.%d.%d",
gi.version_info[0],
gi.version_info[1],
gi.version_info[2])
log.debug("GTK version: %d.%d.%d",
Gtk.get_major_version(),
Gtk.get_minor_version(),
Gtk.get_micro_version())
# Prime the vmmConfig cache
from . import config
config.vmmConfig.get_instance(BuildConfig, CLITestOptions)
# Add our icon dir to icon theme
icon_theme = Gtk.IconTheme.get_default()
icon_theme.prepend_search_path(BuildConfig.icon_dir)
from .engine import vmmEngine
Gtk.Window.set_default_icon_name("virt-manager")
show_window = None
domain = None
if options.show_domain_creator:
show_window = vmmEngine.CLI_SHOW_DOMAIN_CREATOR
elif options.show_host_summary:
show_window = vmmEngine.CLI_SHOW_HOST_SUMMARY
elif options.show_domain_editor:
show_window = vmmEngine.CLI_SHOW_DOMAIN_EDITOR
domain = options.show_domain_editor
elif options.show_domain_performance:
show_window = vmmEngine.CLI_SHOW_DOMAIN_PERFORMANCE
domain = options.show_domain_performance
elif options.show_domain_console:
show_window = vmmEngine.CLI_SHOW_DOMAIN_CONSOLE
domain = options.show_domain_console
elif options.show_domain_delete:
show_window = vmmEngine.CLI_SHOW_DOMAIN_DELETE
domain = options.show_domain_delete
if show_window and options.uri is None: # pragma: no cover
raise RuntimeError("can't use --show-* options without --connect")
skip_autostart = False
if show_window:
skip_autostart = True
# Hook libvirt events into glib main loop
LibvirtGLib.init(None)
LibvirtGLib.event_register()
engine = vmmEngine.get_instance()
# Actually exit when we receive ctrl-c
from gi.repository import GLib
def _sigint_handler(user_data):
ignore = user_data
log.debug("Received KeyboardInterrupt. Exiting application.")
engine.exit_app()
GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGINT,
_sigint_handler, None)
engine.start(options.uri, show_window, domain, skip_autostart)
def do_startup(self):
Gtk.Application.do_startup(self)
# where do we get started
srcdir = Path(__file__).parent
# local installation, for development
if Path(srcdir, 'data').exists():
LOGGER.warning('Running from source tree, using local ui-files')
LOGGER.debug('srcdir: %s', srcdir)
# look for ui-files
pkgdatadir = Path(srcdir, 'data')
# look for settings
schema_source = Gio.SettingsSchemaSource.new_from_directory(
str(Path(srcdir, 'data')),
Gio.SettingsSchemaSource.get_default(), False)
schema = Gio.SettingsSchemaSource.lookup(schema_source,
'org.gge-em.MindEd',
False)
LOGGER.debug('Gsettings schema: %s', schema.get_path())
if not schema:
raise Exception("Cannot get GSettings schema")
self.settings = Gio.Settings.new_full(schema, None, None)
# Translation stuff
# older versions want str not PosixPath
locale.bindtextdomain('minded', str(srcdir.resolve()))
locale.textdomain('minded')
gettext.bindtextdomain('minded', str(srcdir.resolve()))
gettext.textdomain('minded')
# systemwide installation
else:
pkgdatadir = Path('/usr/share/minded')
self.settings = Gio.Settings('org.gge-em.MindEd')
locale.bindtextdomain('minded', '/usr/share/locale')
locale.textdomain('minded')
gettext.bindtextdomain('minded')
gettext.textdomain('minded')
resource_path = Path(pkgdatadir, 'minded.gresource')
resource = Gio.Resource.load(str(resource_path))
Gio.Resource._register(resource)
action = Gio.SimpleAction.new('preferences', None)
action.connect("activate", self.on_preferences)
self.add_action(action)
action = Gio.SimpleAction.new('about', None)
action.connect('activate', self.on_about)
self.add_action(action)
action = Gio.SimpleAction.new('quit', None)
action.connect("activate", self.on_quit)
self.add_action(action)
self.set_accels_for_action('app.quit', ['<Control>Q'])
builder = Gtk.Builder()
if Gtk.get_minor_version() > 18:
# use GtkShortcutsWindow
action = Gio.SimpleAction.new('shortcuts', None)
action.connect('activate', self.on_shortcuts)
self.add_action(action)
builder.add_from_resource('/org/gge-em/MindEd/minded-app-menu.ui')
else:
builder.add_from_resource(
'/org/gge-em/MindEd/minded-app-menu-traditional.ui')
self.set_app_menu(builder.get_object("appmenu"))
class MindEdApp(Gtk.Application):
''' The main application '''
def __init__(self, *args, **kwargs):
super().__init__(
*args,
application_id="org.gge-em.MindEd",
#flags=Gio.ApplicationFlags.FLAGS_NONE, # argparse in main
flags=Gio.ApplicationFlags.HANDLES_COMMAND_LINE, # do_commandline
**kwargs)
# For Gio.Application 2.40 -> Trusty
self.win = None
self.version = "0.7.14 - Heinz"
GLib.set_application_name("minded")
self.args = ()
self.filelist = []
self.settings = ''
# USB client
self.client = None
self.nxt_brick = None
self.ev3_brick = None
# windows
self.brickfiler = None
self.brickinfo = None
self.apiviewer = None
self.add_main_option_entries([
make_option("debug",
description="Show debug information on the console"),
make_option("version",
description="Print the version number and exit")
])
def do_startup(self):
Gtk.Application.do_startup(self)
# where do we get started
srcdir = Path(__file__).parent
# local installation, for development
if Path(srcdir, 'data').exists():
LOGGER.warning('Running from source tree, using local ui-files')
LOGGER.debug('srcdir: %s', srcdir)
# look for ui-files
pkgdatadir = Path(srcdir, 'data')
# look for settings
schema_source = Gio.SettingsSchemaSource.new_from_directory(
str(Path(srcdir, 'data')),
Gio.SettingsSchemaSource.get_default(), False)
schema = Gio.SettingsSchemaSource.lookup(schema_source,
'org.gge-em.MindEd',
False)
LOGGER.debug('Gsettings schema: %s', schema.get_path())
if not schema:
raise Exception("Cannot get GSettings schema")
self.settings = Gio.Settings.new_full(schema, None, None)
# Translation stuff
# older versions want str not PosixPath
locale.bindtextdomain('minded', str(srcdir.resolve()))
locale.textdomain('minded')
gettext.bindtextdomain('minded', str(srcdir.resolve()))
gettext.textdomain('minded')
# systemwide installation
else:
pkgdatadir = Path('/usr/share/minded')
self.settings = Gio.Settings('org.gge-em.MindEd')
locale.bindtextdomain('minded', '/usr/share/locale')
locale.textdomain('minded')
gettext.bindtextdomain('minded')
gettext.textdomain('minded')
resource_path = Path(pkgdatadir, 'minded.gresource')
resource = Gio.Resource.load(str(resource_path))
Gio.Resource._register(resource)
action = Gio.SimpleAction.new('preferences', None)
action.connect("activate", self.on_preferences)
self.add_action(action)
action = Gio.SimpleAction.new('about', None)
action.connect('activate', self.on_about)
self.add_action(action)
action = Gio.SimpleAction.new('quit', None)
action.connect("activate", self.on_quit)
self.add_action(action)
self.set_accels_for_action('app.quit', ['<Control>Q'])
builder = Gtk.Builder()
if Gtk.get_minor_version() > 18:
# use GtkShortcutsWindow
action = Gio.SimpleAction.new('shortcuts', None)
action.connect('activate', self.on_shortcuts)
self.add_action(action)
builder.add_from_resource('/org/gge-em/MindEd/minded-app-menu.ui')
else:
builder.add_from_resource(
'/org/gge-em/MindEd/minded-app-menu-traditional.ui')
self.set_app_menu(builder.get_object("appmenu"))
def do_activate(self):
# Listen to uevent
self.client = GUdev.Client(subsystems=["usb"])
self.client.connect("uevent", self.on_uevent)
for device in self.client.query_by_subsystem("usb"):
if self.look_for_brick(device):
break
#self.look_for_settings(self.settings)
look_for_settings(self.settings)
if not self.win:
self.win = MindEdAppWin(self.filelist, application=self)
else:
# MindEd already running, brick file in file browser clicked
for nth_file in self.filelist[1:]:
if Path(nth_file).is_file():
# check is file already open
document_uri = Path(nth_file).resolve().as_uri()
pagecount = document_is_open(self.win, document_uri)
LOGGER.debug('pagecount {}'.format(pagecount))
if pagecount:
self.win.notebook.set_current_page(pagecount - 1)
else:
self.win.load_file_in_editor(document_uri)
self.win.present()
def do_command_line(self, command_line):
options = command_line.get_options_dict()
if options.contains("version"):
print("MindEd {}".format(self.version))
return 0
if options.contains("debug"):
self.args += ("debug", )
logging.basicConfig(format='%(levelname)s:%(name)s:%(message)s',
level=logging.DEBUG)
else:
logging.basicConfig(format='%(levelname)s:%(name)s:%(message)s',
level=logging.WARN)
self.filelist = command_line.get_arguments()
LOGGER.debug("Filelist: %s", self.filelist)
self.activate()
return 0
def look_for_brick(self, device):
'''
look for LEGO-brick and initialize it
'''
if '694/2' in device.get_property('PRODUCT'):
LOGGER.debug('found NXT')
#if LOGGER.isEnabledFor(logging.DEBUG):
# for device_key in device.get_property_keys():
# LOGGER.debug(" device property %s: %s", device_key,
# device.get_property(device_key))
try:
#LOGGER.debug("NXT-lib: %s", nxt.locator.__file__)
self.nxt_brick = nxt.locator.find_one_brick()
return 'nxt'
except Exception as e:
LOGGER.warning('nxt-python failure: %s' % e)
elif '694/5' in device.get_property('PRODUCT'):
LOGGER.debug('found EV3')
#if LOGGER.isEnabledFor(logging.DEBUG):
# for device_key in device.get_property_keys():
# LOGGER.debug(" device property %s: %s", device_key,
# device.get_property(device_key))
try:
self.ev3_brick = ev3.EV3()
#self.ev3_brick.do_nothing()
return 'ev3'
except Exception as e:
LOGGER.warning('ev3-python failure: %s' % e)
return None
def on_uevent(self, client, action, device):
''' report plugin-event to application'''
if LOGGER.isEnabledFor(logging.DEBUG):
for device_key in device.get_property_keys():
LOGGER.debug(' device property %s: %s', device_key,
device.get_property(device_key))
if action == "add":
# only LEGO-devices
if self.look_for_brick(device) == 'nxt':
LOGGER.debug(' uevent: added NXT')
self.win.brick_status.push(self.win.brick_status_id, "NXT")
self.win.transmit_action.set_enabled(True)
elif self.look_for_brick(device) == 'ev3':
LOGGER.debug(' uevent: added EV3')
self.win.brick_status.push(self.win.brick_status_id, "EV3")
self.win.transmit_action.set_enabled(True)
else:
pass
# newer libgudev returns on remove ID_VENDOR None
if action == 'remove':
if '694/5' in device.get_property('PRODUCT'):
# EV3 PRODUCT 694/5/216
LOGGER.debug(' uevent: removed EV3')
self.win.brick_status.pop(self.win.brick_status_id)
self.win.transmit_action.set_enabled(False)
self.ev3_brick = None
if '694/2' in device.get_property('PRODUCT'):
# NXT PRODUCT 694/2/0
LOGGER.debug(' uevent: removed NXT')
self.win.brick_status.pop(self.win.brick_status_id)
self.win.transmit_action.set_enabled(False)
self.nxt_brick = None
def on_preferences(self, action, param):
''' Gio.SimpleAction preferences '''
dlg = PreferencesDialog(self.win.get_application())
dlg.window.set_transient_for(self.win)
dlg.window.set_modal(True)
dlg.window.present()
if Gtk.get_minor_version() > 18:
def on_shortcuts(self, action, param):
''' Gio.SimpleAction shortcuts '''
builder = Gtk.Builder()
builder.add_from_resource('/org/gge-em/MindEd/minded-shortcuts.ui')
shortcuts_win = builder.get_object('shortcuts-minded')
shortcuts_win.set_transient_for(self.win)
shortcuts_win.show_all()
def on_about(self, action, param):
''' Gio.SimpleAction about '''
builder = Gtk.Builder()
builder.add_from_resource('/org/gge-em/MindEd/minded-about.ui')
about_win = builder.get_object('about-dlg')
about_win.set_version(self.version)
about_win.set_transient_for(self.win)
about_win.show_all()
def on_quit(self, action, param):
'''
quit application
'''
self.win.gtk_main_quit()
import re
import sys
import time
import tempfile
import urllib.error
import urllib.parse
import urllib.request
from gettext import gettext as _
import gi
gi.require_version('Gst', '1.0')
gi.require_version('GstPbutils', '1.0')
from gi.repository import Gst, GstPbutils, GObject, Gtk, Gdk, Pango, GdkPixbuf, Gio, GLib
from .gi_composites import GtkTemplate
if Gtk.get_major_version() < 3 or Gtk.get_minor_version() < 14:
sys.exit('Gtk 3.14 is required')
from . import AboutPithosDialog, PreferencesPithosDialog, StationsDialog
from .StationsPopover import StationsPopover
from .gobject_worker import GObjectWorker
from .pandora import *
from .pandora.data import *
from .plugin import load_plugins
from .util import parse_proxy, open_browser, get_account_password
try:
import pacparser
except ImportError:
pacparser = None
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__))
# do not negotiate a single instance application
# https://developer.gnome.org/gio/unstable/GApplication.html#G-APPLICATION-NON-UNIQUE:CAPS
self.set_flags(Gio.ApplicationFlags.NON_UNIQUE)
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.references = []
"""A list to store references to arbitrary objects in for avoiding garbage collection."""
self.rpc = None
"""The :py:class:`~.KingPhisherRPCClient` instance for the application."""
self._rpc_ping_event = None
# this will be populated when the RPC object is authenticated to ping
# the server periodically and keep the session alive
self.server_events = None
"""The :py:class:`~.ServerEventSubscriber` instance for the application to receive server events."""
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.data_directory('plugins')
], self)
if use_plugins:
self.plugin_manager.load_all()
def __init_window(self):
"""
Add fields for all ui objects we need to access from code.
Initialize everything we can't do from glade like events and other stuff.
"""
log.info("Initialize main window")
self.window: Gtk.Window = self.window_builder.get_object("app_window")
self.window.set_default_size(1100, 700)
self.window.set_application(self.app)
self.window.show_all()
self.window.present()
self.window.connect("delete-event", self.on_close)
self.window.connect("drag_data_received", self.__on_drag_data_received)
self.window.drag_dest_set(Gtk.DestDefaults.MOTION | Gtk.DestDefaults.HIGHLIGHT | Gtk.DestDefaults.DROP,
[Gtk.TargetEntry.new("text/uri-list", 0, 80)], Gdk.DragAction.COPY)
self.window.title = "Cozy"
# resizing the progress bar for older gtk versions
if not Gtk.get_minor_version() > 18:
self.window.connect("check-resize", self.__window_resized)
self.author_box = self.window_builder.get_object("author_box")
self.reader_box = self.window_builder.get_object("reader_box")
self.book_box = self.window_builder.get_object("book_box")
self.book_scroller = self.window_builder.get_object("book_scroller")
self.sort_stack = self.window_builder.get_object("sort_stack")
self.sort_stack.connect("notify::visible-child",
self.__on_sort_stack_changed)
self.sort_box = self.window_builder.get_object("sort_box")
self.import_box = self.window_builder.get_object("import_box")
self.position_box = self.window_builder.get_object("position_box")
self.main_stack = self.window_builder.get_object("main_stack")
self.toolbar_revealer = self.window_builder.get_object("toolbar_revealer")
self.back_button = self.window_builder.get_object("back_button")
self.back_button.connect("clicked", self.__on_back_clicked)
self.category_toolbar = self.window_builder.get_object(
"category_toolbar")
self.sort_stack_revealer = self.window_builder.get_object(
"sort_stack_revealer")
# This fixes a bug where otherwise expand is
# somehow set to true internally
# but is still showing false in the inspector
self.sort_stack_revealer.props.expand = True
self.sort_stack_revealer.props.expand = False
self.sort_stack_switcher = self.window_builder.get_object(
"sort_stack_switcher")
self.no_media_file_chooser = self.window_builder.get_object(
"no_media_file_chooser")
self.no_media_file_chooser.connect(
"file-set", self.__on_no_media_folder_changed)
self.external_switch = self.window_builder.get_object(
"external_switch")
self.auto_scan_switch = self.window_builder.get_object(
"auto_scan_switch")
# some visual stuff
self.category_toolbar_separator = self.window_builder.get_object("category_toolbar_separator")
if tools.is_elementary():
self.category_toolbar.set_visible(False)
# get about dialog
self.about_dialog = self.about_builder.get_object("about_dialog")
self.about_dialog.set_transient_for(self.window)
self.about_dialog.connect("delete-event", self.hide_window)
self.about_dialog.set_version(self.version)
# shortcuts
self.accel = Gtk.AccelGroup()
# sorting and filtering
self.author_box.connect("row-selected", self.__on_listbox_changed)
self.reader_box.connect("row-selected", self.__on_listbox_changed)
self.book_box.set_sort_func(self.__sort_books, None, False)
self.book_box.set_filter_func(self.__filter_books, None, False)
try:
about_close_button = self.about_builder.get_object(
"button_box").get_children()[2]
if about_close_button:
about_close_button.connect(
"clicked", self.__about_close_clicked)
except Exception as e:
log.info("Not connecting about close button.")
player.add_player_listener(self.__player_changed)
# Perform the GTK UI dependency check here
import ui.dependency_check as dependency_check
dependency_check.check_all()
# Now that I know that I have them, import them!
from gi.repository import Gtk
from gi.repository import GObject
from gi.repository import GtkSource
# This is just general info, to help people knowing their system
print("Starting bokken {}, running on:".format(glob.version))
print(" Python version:")
print("\n".join(" " + x for x in sys.version.split("\n")))
print(" GTK version: " + str(Gtk.get_major_version()) + '.' +
str(Gtk.get_minor_version()))
import ui.gtk3.common
import ui.textviews as textviews
import ui.statusbar as statusbar
import ui.file_dialog as file_dialog
MAINTITLE = "Bokken "
class BokkenGTKClient:
'''Main GTK application'''
def __init__(self, target, backend):
import time
def main(root_path, force_launch=False):
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"
global _session_id
_session_id = md5.new(os.urandom(16)).hexdigest()
# Set paths.
respaths.set_paths(root_path)
# Init session folders
if os.path.exists(get_session_folder()):
shutil.rmtree(get_session_folder())
os.mkdir(get_session_folder())
# 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()
# Load aniamtions data
natronanimations.load_animations_projects_xml()
# Init gtk threads
Gdk.threads_init()
Gdk.threads_enter()
# Set monitor sizes
"""
scr_w = Gdk.Screen.width()
scr_h = Gdk.Screen.height()
editorstate.SCREEN_WIDTH = scr_w
editorstate.SCREEN_HEIGHT = scr_h
if editorstate.screen_size_large_height() == True and editorstate.screen_size_small_width() == False:
global MONITOR_WIDTH, MONITOR_HEIGHT
MONITOR_WIDTH = 650
MONITOR_HEIGHT = 400 # initial value, this gets changed when material is loaded
"""
# Request dark theme if so desired
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()
# We need mlt fpr profiles handling
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()
gui.load_current_colors()
# Set launch profile
profile_name = sys.argv[1].replace("_", " ") # we had underscores put in to pass as single arg
print profile_name
global _profile
_profile = mltprofiles.get_profile(profile_name)
global _animation_instance
_animation_instance = natronanimations.get_default_animation_instance(_profile)
global _window
_window = NatronAnimatationsToolWindow()
_window.pos_bar.set_dark_bg_color()
Gtk.main()
Gdk.threads_leave()
def init(self):
"""
Init main application
"""
self.settings = Settings.new()
# Mount enclosing volume as soon as possible
uris = self.settings.get_music_uris()
try:
for uri in uris:
if uri.startswith("file:/"):
continue
f = Gio.File.new_for_uri(uri)
f.mount_enclosing_volume(Gio.MountMountFlags.NONE,
None,
None,
None)
except Exception as e:
print("Application::init():", e)
self.__is_fs = False
if Gtk.get_minor_version() > 18:
cssProviderFile = Lio.File.new_for_uri(
"resource:///org/gnome/Lollypop/application.css")
else:
cssProviderFile = Lio.File.new_for_uri(
"resource:///org/gnome/Lollypop/application-legacy.css")
cssProvider = Gtk.CssProvider()
cssProvider.load_from_file(cssProviderFile)
screen = Gdk.Screen.get_default()
styleContext = Gtk.StyleContext()
styleContext.add_provider_for_screen(screen, cssProvider,
Gtk.STYLE_PROVIDER_PRIORITY_USER)
self.db = Database()
self.playlists = Playlists()
# We store cursors for main thread
SqlCursor.add(self.db)
SqlCursor.add(self.playlists)
self.albums = AlbumsDatabase()
self.artists = ArtistsDatabase()
self.genres = GenresDatabase()
self.tracks = TracksDatabase()
self.player = Player()
self.scanner = CollectionScanner()
self.art = Art()
self.art.update_art_size()
if self.settings.get_value("artist-artwork"):
GLib.timeout_add(5000, self.art.cache_artists_info)
if LastFM is not None:
self.lastfm = LastFM()
if not self.settings.get_value("disable-mpris"):
# Ubuntu > 16.04
if Gtk.get_minor_version() > 18:
from lollypop.mpris import MPRIS
# Ubuntu <= 16.04, Debian Jessie, ElementaryOS
else:
from lollypop.mpris_legacy import MPRIS
MPRIS(self)
if not self.settings.get_value("disable-notifications"):
from lollypop.notification import NotificationManager
self.notify = NotificationManager()
settings = Gtk.Settings.get_default()
self.__gtk_dark = settings.get_property(
"gtk-application-prefer-dark-theme")
if not self.__gtk_dark:
dark = self.settings.get_value("dark-ui")
settings.set_property("gtk-application-prefer-dark-theme", dark)
# Map some settings to actions
self.add_action(self.settings.create_action("playback"))
self.add_action(self.settings.create_action("shuffle"))
self.db.upgrade()
def main(root_path):
"""
Called at application start.
Initializes application with a default project.
"""
# DEBUG: Direct output to log file if log file set
if _log_file != None:
log_print_output_to_file()
set_quiet_if_requested()
print("Application version: " + editorstate.appversion)
# Print OS, Python version and GTK+ version
try:
os_release_file = open("/etc/os-release", "r")
os_text = os_release_file.read()
s_index = os_text.find("PRETTY_NAME=")
e_index = os_text.find("\n", s_index)
print("OS: " + os_text[s_index + 13:e_index - 1])
except:
pass
print("Python", sys.version)
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 needed and determine if we're 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()
if editorpersistance.prefs.theme != appconsts.LIGHT_THEME:
respaths.apply_dark_theme()
if editorpersistance.prefs.display_all_audio_levels == False:
editorstate.display_all_audio_levels = False
editorpersistance.save()
# Init translations module with translations data
translations.init_languages()
translations.load_filters_translations()
mlttransitions.init_module()
# Apr-2017 - SvdB - Keyboard shortcuts
shortcuts.load_shortcut_files()
shortcuts.load_shortcuts()
# Aug-2019 - SvdB - AS
# The test for len != 4 is to make sure that if we change the number of values below the prefs are reset to the correct list
# So when we add or remove a value, make sure we also change the len test
# Only use positive numbers.
if (not editorpersistance.prefs.AUTO_SAVE_OPTS
or len(editorpersistance.prefs.AUTO_SAVE_OPTS) != 4):
print("Initializing Auto Save Options")
editorpersistance.prefs.AUTO_SAVE_OPTS = ((0, _("No Autosave")),
(1, _("1 min")),
(2, _("2 min")),
(5, _("5 min")))
# We respaths and translations data available so we need to init in a function.
workflow.init_data()
# RHEL7/CentOS compatibility fix
if gtk_version == "3.8.8":
GObject.threads_init()
# Init gtk threads
Gdk.threads_init()
Gdk.threads_enter()
# Themes
if editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME:
success = gui.apply_gtk_css()
if not success:
editorpersistance.prefs.theme = appconsts.LIGHT_THEME
editorpersistance.save()
if editorpersistance.prefs.theme != appconsts.LIGHT_THEME:
Gtk.Settings.get_default().set_property(
"gtk-application-prefer-dark-theme", True)
# Load drag'n'drop images
dnd.init()
# Save screen size data and modify rendering based on screen size/s and number of monitors.
scr_w, scr_h = _set_screen_size_data()
_set_draw_params()
# Refuse to run on too small screen.
if scr_w < 1151 or scr_h < 767:
_too_small_screen_exit()
return
# Splash screen
if editorpersistance.prefs.display_splash_screen == True:
show_splash_screen()
# Init MLT framework
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)
# Replace some services if better replacements available.
mltfilters.replace_services(mltenv.services)
# Create list of available mlt profiles.
mltprofiles.load_profile_list()
# If we have crashed we could have large amount of disk space wasted unless we delete all files here.
tlinerender.app_launch_clean_up()
# Save assoc file path if found in arguments.
global assoc_file_path
assoc_file_path = get_assoc_file_path()
# There is always a project open, so at startup we create a default project.
# Set default project as the project being edited.
editorstate.project = projectdata.get_default_project()
check_crash = True
# Audiomonitoring being available needs to be known before GUI creation.
audiomonitoring.init(editorstate.project.profile)
# Set trim view mode to current default value.
editorstate.show_trim_view = editorpersistance.prefs.trim_view_default
# Check for tools and init tools integration.
gmic.test_availablity()
toolsintegration.init()
# Create player object.
create_player()
# Create main window and set widget handles in gui.py for more convenient reference.
create_gui()
# Inits widgets with project data.
init_project_gui()
# Inits widgets with current sequence data.
init_sequence_gui()
# Launch player now that data and gui exist
launch_player()
# Editor and modules need some more initializing.
init_editor_state()
# Tracks need to be recentered if window is resized.
# Connect listener for this now that the tline panel size allocation is sure to be available.
global window_resize_id, window_state_id
window_resize_id = gui.editor_window.window.connect(
"size-allocate", lambda w, e: updater.window_resized())
window_state_id = gui.editor_window.window.connect(
"window-state-event", lambda w, e: updater.window_resized())
# Get existing autosave files
autosave_files = get_autosave_files()
# Show splash
if ((editorpersistance.prefs.display_splash_screen == True)
and len(autosave_files) == 0
) and not editorstate.runtime_version_greater_then_test_version(
editorpersistance.prefs.workflow_dialog_last_version_shown,
editorstate.appversion):
global splash_timeout_id
splash_timeout_id = GLib.timeout_add(2600, destroy_splash_screen)
splash_screen.show_all()
appconsts.SAVEFILE_VERSION = projectdata.SAVEFILE_VERSION # THIS IS A QUESTIONABLE IDEA TO SIMPLIFY IMPORTS, NOT DRY. WHEN DOING TOOLS THAT RUN IN ANOTHER PROCESSES AND SAVE PROJECTS, THIS LINE NEEDS TO BE THERE ALSO.
# Every running instance has unique autosave file which is deleted at exit
set_instance_autosave_id()
# Existance of autosave file hints that program was exited abnormally.
if check_crash == True and len(autosave_files) > 0:
if len(autosave_files) == 1:
GObject.timeout_add(10, autosave_recovery_dialog)
else:
GObject.timeout_add(10, autosaves_many_recovery_dialog)
else:
tlinerender.init_session()
start_autosave()
projectaction.clear_changed_since_last_save_flags()
# We prefer to monkeypatch some callbacks into some modules, usually to
# maintain a simpler and/or non-circular import structure.
monkeypatch_callbacks()
# File in assoc_file_path is opened after very short delay.
if not (check_crash == True and len(autosave_files) > 0):
if assoc_file_path != None:
print("Launch assoc file:", assoc_file_path)
global assoc_timeout_id
assoc_timeout_id = GObject.timeout_add(10, open_assoc_file)
if editorpersistance.prefs.theme == appconsts.FLOWBLADE_THEME:
gui.apply_flowblade_theme_fixes()
# SDL 2 consumer needs to created after Gtk.main() has run enough for window to be visble
#if editorstate.get_sdl_version() == editorstate.SDL_2: # needs more state considerion still
# print "SDL2 timeout launch"
# global sdl2_timeout_id
# sdl2_timeout_id = GObject.timeout_add(1500, create_sdl_2_consumer)
# In PositionNumericalEntries we are using Gtk.Entry objects in a way that works for us nicely, but is somehow "error" for Gtk, so we just kill this.
Gtk.Settings.get_default().set_property("gtk-error-bell", False)
# Show first run worflow info dialog if not shown for this version of application.
if editorstate.runtime_version_greater_then_test_version(
editorpersistance.prefs.workflow_dialog_last_version_shown,
editorstate.appversion):
GObject.timeout_add(500, show_worflow_info_dialog)
# Handle userfolders init error and data copy.
if userfolders.get_init_error() != None:
GObject.timeout_add(500, show_user_folders_init_error_dialog,
userfolders.get_init_error())
elif userfolders.data_copy_needed():
GObject.timeout_add(500, show_user_folders_copy_dialog)
else:
print("No user folders actions needed.")
# Launch gtk+ main loop
Gtk.main()
Gdk.threads_leave()
def __init__(self, applet):
super().__init__(title=_("Plugins"),
icon_name="blueman",
name="PluginDialog",
border_width=6,
default_width=490,
default_height=380,
resizable=False,
visible=False)
self.applet = applet
self.Builder = Gtk.Builder(translation_domain="blueman")
self.Builder.add_from_file(UI_PATH + "/applet-plugins-widget.ui")
self.description = self.Builder.get_object("description")
self.icon = self.Builder.get_object("icon")
self.author_txt = self.Builder.get_object("author_txt")
self.depends_hdr = self.Builder.get_object("depends_hdr")
self.depends_txt = self.Builder.get_object("depends_txt")
self.conflicts_hdr = self.Builder.get_object("conflicts_hdr")
self.conflicts_txt = self.Builder.get_object("conflicts_txt")
self.plugin_name = self.Builder.get_object("name")
self.main_container = self.Builder.get_object("main_container")
self.content_grid = self.Builder.get_object("content")
self.b_prefs = self.Builder.get_object("b_prefs")
self.b_prefs.connect("toggled", self.on_prefs_toggled)
self.add(self.Builder.get_object("all"))
cr = Gtk.CellRendererToggle()
cr.connect("toggled", self.on_toggled)
data = [
{
"id": "active",
"type": bool,
"renderer": cr,
"render_attrs": {
"active": 0,
"activatable": 1,
"visible": 1
}
},
{
"id": "activatable",
"type": bool
},
{
"id": "icon",
"type": str,
"renderer": Gtk.CellRendererPixbuf(),
"render_attrs": {
"icon-name": 2
}
},
# device caption
{
"id": "desc",
"type": str,
"renderer": Gtk.CellRendererText(),
"render_attrs": {
"markup": 3
},
"view_props": {
"expand": True
}
},
{
"id": "name",
"type": str
},
]
self.list = GenericList(data, headers_visible=False, visible=True)
self.list.liststore.set_sort_column_id(3, Gtk.SortType.ASCENDING)
self.list.liststore.set_sort_func(3, self.list_compare_func)
self.list.selection.connect("changed", self.on_selection_changed)
plugin_list = self.Builder.get_object("plugin_list")
plugin_info = self.Builder.get_object("main_scrolled_window")
plugin_list.add(self.list)
# Disable overlay scrolling
if Gtk.get_minor_version() >= 16:
plugin_list.props.overlay_scrolling = False
plugin_info.props.overlay_scrolling = False
self.populate()
self.sig_a: int = self.applet.Plugins.connect(
"plugin-loaded", self.plugin_state_changed, True)
self.sig_b: int = self.applet.Plugins.connect(
"plugin-unloaded", self.plugin_state_changed, False)
self.connect("delete-event", self._on_close)
self.list.set_cursor(0)
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 needed and determine if we are 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 \
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()
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 column_clicked(self, obj, data):
"""
Called when a column is clicked.
obj A TreeViewColumn object of the column clicked
data The column index
"""
self.uistate.set_busy_cursor(True)
self.uistate.push_message(self.dbstate,
_("Column clicked, sorting..."))
cput = time.clock()
same_col = False
if self.sort_col != data:
order = Gtk.SortType.ASCENDING
else:
same_col = True
if (self.columns[data].get_sort_order() == Gtk.SortType.DESCENDING
or not self.columns[data].get_sort_indicator()):
order = Gtk.SortType.ASCENDING
else:
order = Gtk.SortType.DESCENDING
self.sort_col = data
self.sort_order = order
handle = self.first_selected()
if not self.search_bar.is_visible():
filter_info = (True, self.generic_filter, False)
else:
value = self.search_bar.get_value()
filter_info = (False, value, value[0] in self.exact_search())
if same_col:
# activate when https://bugzilla.gnome.org/show_bug.cgi?id=684558
# is resolved
if False and (Gtk.get_major_version(),
Gtk.get_minor_version()) >= (3, 8):
self.model.reverse_order()
else:
## GTK 3.6 rows_reordered not exposed by gi, we need to reconnect
## model to obtain desired effect, but this collapses nodes ...
self.list.set_model(None)
self.model.reverse_order()
self.list.set_model(self.model)
else:
self.model = self.make_model(self.dbstate.db,
self.sort_col,
self.sort_order,
search=filter_info,
sort_map=self.column_order())
self.list.set_model(self.model)
self.__display_column_sort()
if handle:
self.goto_handle(handle)
# set the search column to be the sorted column
search_col = self.column_order()[data][1]
self.list.set_search_column(search_col)
self.uistate.set_busy_cursor(False)
LOG.debug(' ' + self.__class__.__name__ + ' column_clicked ' +
str(time.clock() - cput) + ' sec')
def __init__(self, break_config, is_short, parent_config, plugin_map,
on_close, on_add, on_remove):
self.break_config = break_config
self.parent_config = parent_config
self.plugin_check_buttons = {}
self.on_close = on_close
self.is_short = is_short
self.on_add = on_add
self.on_remove = on_remove
builder = utility.create_gtk_builder(SETTINGS_DIALOG_BREAK_GLADE)
builder.connect_signals(self)
self.window = builder.get_object('dialog_settings_break')
self.txt_break = builder.get_object('txt_break')
self.switch_override_interval = builder.get_object(
'switch_override_interval')
self.switch_override_duration = builder.get_object(
'switch_override_duration')
self.switch_override_plugins = builder.get_object(
'switch_override_plugins')
self.spin_interval = builder.get_object('spin_interval')
self.spin_duration = builder.get_object('spin_duration')
self.img_break = builder.get_object('img_break')
self.cmb_type = builder.get_object('cmb_type')
grid_plugins = builder.get_object('grid_plugins')
list_types = builder.get_object('lst_break_types')
interval_overriden = break_config.get('interval', None) is not None
duration_overriden = break_config.get('duration', None) is not None
plugins_overriden = break_config.get('plugins', None) is not None
# Set the values
self.window.set_title(_('Break Settings'))
self.txt_break.set_text(_(break_config['name']))
self.switch_override_interval.set_active(interval_overriden)
self.switch_override_duration.set_active(duration_overriden)
self.switch_override_plugins.set_active(plugins_overriden)
self.cmb_type.set_active(0 if is_short else 1)
list_types[0][0] = _(list_types[0][0])
list_types[1][0] = _(list_types[1][0])
if interval_overriden:
self.spin_interval.set_value(break_config['interval'])
else:
if is_short:
self.spin_interval.set_value(
parent_config.get('short_break_interval'))
else:
self.spin_interval.set_value(
parent_config.get('long_break_interval'))
if duration_overriden:
self.spin_duration.set_value(break_config['duration'])
else:
if is_short:
self.spin_duration.set_value(
parent_config.get('short_break_duration'))
else:
self.spin_duration.set_value(
parent_config.get('long_break_duration'))
row = 0
col = 0
for plugin_id in plugin_map.keys():
chk_button = Gtk.CheckButton(_(plugin_map[plugin_id]))
self.plugin_check_buttons[plugin_id] = chk_button
grid_plugins.attach(chk_button, row, col, 1, 1)
if plugins_overriden:
chk_button.set_active(plugin_id in break_config['plugins'])
else:
chk_button.set_active(True)
row += 1
if row > 2:
col += 1
row = 0
# GtkSwitch state-set signal is available only from 3.14
if Gtk.get_minor_version() >= 14:
self.switch_override_interval.connect(
'state-set', self.on_switch_override_interval_activate)
self.switch_override_duration.connect(
'state-set', self.on_switch_override_duration_activate)
self.switch_override_plugins.connect(
'state-set', self.on_switch_override_plugins_activate)
self.on_switch_override_interval_activate(
self.switch_override_interval,
self.switch_override_interval.get_active())
self.on_switch_override_duration_activate(
self.switch_override_duration,
self.switch_override_duration.get_active())
self.on_switch_override_plugins_activate(
self.switch_override_plugins,
self.switch_override_plugins.get_active())
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'
# add on additional details for context as necessary
if isinstance(exc_value, errors.KingPhisherGraphQLQueryError):
details += '\nGraphQL Exception Information:\n=============================\n\n'
if exc_value.errors:
details += 'GraphQL Errors:\n---------------\n'
details += '\n'.join(error.strip()
for error in exc_value.errors) + '\n\n'
details += 'GraphQL Query:\n--------------\n'
details += textwrap.dedent(exc_value.query) + '\n'
return details
