Current File : //lib/rhythmbox/plugins/alternative-toolbar/alttoolbar_preferences.py
# -*- Mode: python; coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
#
# Copyright (C) 2015 - 2020 David Mohammed <fossfreedom@ubuntu.com>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 3, or (at your option)
# any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
# define plugin
import gettext
import locale
import os
import shutil
import sys
import gi
import rb
from gi.repository import GObject
from gi.repository import Gio
from gi.repository import Gtk
gi.require_version('PeasGtk', '1.0')
from gi.repository import PeasGtk
from gi.repository import RB
class GSetting:
"""
This class manages the different settings that the plugin has to
access to read or write.
"""
# storage for the instance reference
__instance = None
class __impl:
""" Implementation of the singleton interface """
# below public variables and methods that can be called for GSetting
def __init__(self):
"""
Initializes the singleton interface, assigning all the constants
used to access the plugin's settings.
"""
self.Path = self._enum(
PLUGIN='org.gnome.rhythmbox.plugins.alternative_toolbar')
self.PluginKey = self._enum(
DISPLAY_TYPE='display-type',
START_HIDDEN='start-hidden',
SHOW_COMPACT='show-compact',
COMPACT_POS='compact-pos',
PLAYING_LABEL='playing-label',
VOLUME_CONTROL='volume-control',
INLINE_LABEL='inline-label',
ENHANCED_SIDEBAR='enhanced-sidebar',
EXPANDERS='expanders',
SHOW_TOOLTIPS='show-tooltips',
REPEAT_TYPE='repeat-type',
SOURCE_TOOLBAR='show-source-toolbar',
HORIZ_CATEGORIES='horiz-categories',
APP_MENU='app-menu-display',
DARK_THEME='dark-theme'
)
self.setting = {}
def get_setting(self, path):
"""
Return an instance of Gio.Settings pointing at the selected path.
"""
try:
setting = self.setting[path]
except:
self.setting[path] = Gio.Settings.new(path)
setting = self.setting[path]
return setting
def get_value(self, path, key):
"""
Return the value saved on key from the settings path.
"""
return self.get_setting(path)[key]
def set_value(self, path, key, value):
"""
Set the passed value to key in the settings path.
"""
self.get_setting(path)[key] = value
def _enum(self, **enums):
"""
Create an enumn.
"""
return type('Enum', (), enums)
def __init__(self):
""" Create singleton instance """
# Check whether we already have an instance
if GSetting.__instance is None:
# Create and remember instance
GSetting.__instance = GSetting.__impl()
# Store instance reference as the only member in the handle
self.__dict__['_GSetting__instance'] = GSetting.__instance
def __getattr__(self, attr):
""" Delegate access to implementation """
return getattr(self.__instance, attr)
def __setattr__(self, attr, value):
""" Delegate access to implementation """
return setattr(self.__instance, attr, value)
class CoverLocale:
"""
This class manages the locale
"""
# storage for the instance reference
__instance = None
class __impl:
""" Implementation of the singleton interface """
# below public variables and methods that can be called for CoverLocale
def __init__(self):
"""
Initializes the singleton interface, assigning all the constants
used to access the plugin's settings.
"""
self.Locale = self._enum(
RB='rhythmbox',
LOCALE_DOMAIN='alternative-toolbar')
def switch_locale(self, locale_type):
"""
Change the locale
"""
locale.setlocale(locale.LC_ALL, '')
locale.bindtextdomain(locale_type, RB.locale_dir())
locale.textdomain(locale_type)
gettext.bindtextdomain(locale_type, RB.locale_dir())
gettext.textdomain(locale_type)
gettext.install(locale_type)
def get_locale(self):
"""
return the string representation of the users locale
for example
en_US
"""
return locale.getdefaultlocale()[0]
def _enum(self, **enums):
"""
Create an enumn.
"""
return type('Enum', (), enums)
def get_translation(self, value):
"""
return the translated version of the string
"""
return gettext.gettext(value)
def __init__(self):
""" Create singleton instance """
# Check whether we already have an instance
if CoverLocale.__instance is None:
# Create and remember instance
CoverLocale.__instance = CoverLocale.__impl()
# Store instance reference as the only member in the handle
self.__dict__['_CoverLocale__instance'] = CoverLocale.__instance
def __getattr__(self, attr):
""" Delegate access to implementation """
return getattr(self.__instance, attr)
def __setattr__(self, attr, value):
""" Delegate access to implementation """
return setattr(self.__instance, attr, value)
class Preferences(GObject.Object, PeasGtk.Configurable):
"""
Preferences for the Plugins. It holds the settings for
the plugin and also is the responsible of creating the preferences dialog.
"""
__gtype_name__ = 'AlternativeToolbarPreferences'
object = GObject.property(type=GObject.Object)
def __init__(self):
"""
Initialises the preferences, getting an instance of the settings saved
by Gio.
"""
GObject.Object.__init__(self)
self.gs = GSetting()
self.plugin_settings = self.gs.get_setting(self.gs.Path.PLUGIN)
def do_create_configure_widget(self):
"""
Creates the plugin's preferences dialog
"""
print("DEBUG - create_display_contents")
# create the ui
self._first_run = True
cl = CoverLocale()
cl.switch_locale(cl.Locale.LOCALE_DOMAIN)
builder = Gtk.Builder()
builder.set_translation_domain(cl.Locale.LOCALE_DOMAIN)
builder.add_from_file(rb.find_plugin_file(self,
'ui/altpreferences.ui'))
builder.connect_signals(self)
# bind the toggles to the settings
start_hidden = builder.get_object('start_hidden_checkbox')
start_hidden.set_active(
not self.plugin_settings[self.gs.PluginKey.START_HIDDEN])
start_hidden.connect('toggled', self._start_hidden_checkbox_toggled)
self._show_compact = builder.get_object('show_compact_checkbox')
self.plugin_settings.bind(self.gs.PluginKey.SHOW_COMPACT,
self._show_compact, 'active',
Gio.SettingsBindFlags.DEFAULT)
self._show_compact.connect('toggled',
self._show_compact_checkbox_toggled)
self._compact_pos = builder.get_object('compact_pos_combobox')
self.plugin_settings.bind(self.gs.PluginKey.COMPACT_POS,
self._compact_pos, 'active',
Gio.SettingsBindFlags.DEFAULT)
self._playing_label = builder.get_object('playing_label_checkbox')
self.plugin_settings.bind(self.gs.PluginKey.PLAYING_LABEL,
self._playing_label, 'active',
Gio.SettingsBindFlags.DEFAULT)
self._inline_label = builder.get_object('inline_label_checkbox')
self.plugin_settings.bind(self.gs.PluginKey.INLINE_LABEL,
self._inline_label, 'active',
Gio.SettingsBindFlags.DEFAULT)
volume_control = builder.get_object('volume_control_checkbox')
self.plugin_settings.bind(self.gs.PluginKey.VOLUME_CONTROL,
volume_control, 'active',
Gio.SettingsBindFlags.DEFAULT)
self._enhanced_sidebar = builder.get_object(
'enhanced_sidebar_checkbox')
self.plugin_settings.bind(self.gs.PluginKey.ENHANCED_SIDEBAR,
self._enhanced_sidebar, 'active',
Gio.SettingsBindFlags.DEFAULT)
self._show_tooltips = builder.get_object('tooltips_checkbox')
self.plugin_settings.bind(self.gs.PluginKey.SHOW_TOOLTIPS,
self._show_tooltips, 'active',
Gio.SettingsBindFlags.DEFAULT)
self._dark_theme = \
builder.get_object('dark_theme_checkbox')
self.plugin_settings.bind(self.gs.PluginKey.DARK_THEME,
self._dark_theme, 'active',
Gio.SettingsBindFlags.DEFAULT)
modern_switch = builder.get_object('modern_switch')
# modern_switch.connect('state-set', self._modern_switch_state)
modern_switch.connect('notify', self._modern_switch_state)
# Determine what type of toolbar is to be displayed
default = Gtk.Settings.get_default()
display_type = self.plugin_settings[self.gs.PluginKey.DISPLAY_TYPE]
if display_type == 0:
if (not default.props.gtk_shell_shows_app_menu) or \
default.props.gtk_shell_shows_menubar:
modern_switch.set_active(False)
else:
modern_switch.set_active(True)
elif display_type == 1:
modern_switch.set_active(True)
else:
modern_switch.set_active(False)
if modern_switch.get_active():
self._show_compact.set_active(True)
self._show_compact_checkbox_toggled(self._show_compact)
infobar = builder.get_object('infobar')
button = infobar.add_button(_("Restart"), 1)
# restart_button = builder.get_object('restart_button')
button.connect('clicked', self._restart_button_clicked)
self._category_pos = builder.get_object('category_combobox')
self.plugin_settings.bind(self.gs.PluginKey.HORIZ_CATEGORIES,
self._category_pos, 'active',
Gio.SettingsBindFlags.DEFAULT)
self._first_run = False
return builder.get_object('preferences_box')
def _restart_button_clicked(self, *args):
exepath = shutil.which('rhythmbox')
os.execl(exepath, exepath, *sys.argv)
def _start_hidden_checkbox_toggled(self, toggle_button):
self.plugin_settings[self.gs.PluginKey.START_HIDDEN] = \
not toggle_button.get_active()
def _show_compact_checkbox_toggled(self, toggle_button):
enabled = toggle_button.get_active()
self._show_tooltips.set_sensitive(enabled)
self._inline_label.set_sensitive(enabled)
self._playing_label.set_sensitive(enabled)
def _modern_switch_state(self, switch, param):
state = switch.get_active()
self._show_compact.set_sensitive(not state)
self._compact_pos.set_sensitive(not state)
if state:
self._show_compact.set_active(True)
self.plugin_settings[self.gs.PluginKey.DISPLAY_TYPE] = 1
else:
self.plugin_settings[self.gs.PluginKey.DISPLAY_TYPE] = 2
Mini Shell