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