utils.py 11.5 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
# This file is part of gnome-tweak-tool.
#
# Copyright (c) 2011 John Stowers
#
# gnome-tweak-tool 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 of the License, or
# (at your option) any later version.
#
# gnome-tweak-tool 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 gnome-tweak-tool.  If not, see <http://www.gnu.org/licenses/>.

import os.path
19
import logging
20 21
import tempfile
import shutil
22
import subprocess
23
import glob
24

25
import gtweak
26
from gtweak.gsettings import GSettingsSetting
27

28
from gi.repository import GObject
29
from gi.repository import GLib
Alex Muñoz's avatar
Alex Muñoz committed
30
from gi.repository import Gio
31 32
from gi.repository import Notify

33 34 35 36 37 38 39 40 41 42 43 44 45
def singleton(cls):
    """
    Singleton decorator that works with GObject derived types. The 'recommended'
    python one - http://wiki.python.org/moin/PythonDecoratorLibrary#Singleton
    does not (interacts badly with GObjectMeta
    """
    instances = {}
    def getinstance():
        if cls not in instances:
            instances[cls] = cls()
        return instances[cls]
    return getinstance

46
def make_combo_list_with_default(opts, default, title=True, default_text=None):
47 48 49 50 51 52 53 54 55
    """
    Turns a list of values into a list of value,name (where name is the
    display name a user will see in a combo box). If a value is opt is
    equal to that supplied in default the display name for that value is
    modified to "value <i>(default)</i>"

    @opts: a list of value
    @returns: a list of 2-tuples (value, name)
    """
56 57
    themes = []
    for t in opts:
58
        if t.lower() == "default" and t != default:
59 60
            #some themes etc are actually called default. Ick. Dont show them if they
            #are not the actual default value
61 62
            continue

63
        if title and len(t):
64 65 66 67 68
            name = t[0].upper() + t[1:]
        else:
            name = t

        if t == default:
69
            #indicates the default theme, e.g Adwaita (default)
John Stowers's avatar
John Stowers committed
70
            name = default_text or _("%s <i>(default)</i>") % name
71 72 73 74

        themes.append((t, name))
    return themes

75 76 77 78 79 80 81 82 83 84 85 86
def walk_directories(dirs, filter_func):
    valid = []
    try:
        for thdir in dirs:
            if os.path.isdir(thdir):
                for t in os.listdir(thdir):
                    if filter_func(os.path.join(thdir, t)):
                         valid.append(t)
    except:
        logging.critical("Error parsing directories", exc_info=True)
    return valid

87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108
def extract_zip_file(z, members_path, dest):
    """ returns (true_if_extracted_ok, true_if_updated) """
    tmp = tempfile.mkdtemp()
    tmpdest = os.path.join(tmp, members_path)

    ok = True
    updated = False
    try:
        if os.path.exists(dest):
            shutil.rmtree(dest)
            updated = True
        z.extractall(tmp)
        shutil.copytree(tmpdest, dest)
    except OSError:
        ok = False
        logging.warning("Error extracting zip", exc_info=True)

    if ok:
        logging.info("Extracted zip to %s, copied to %s" % (tmpdest, dest))

    return ok, updated

109 110 111 112 113 114 115 116
def execute_subprocess(cmd_then_args, block=True):
    p = subprocess.Popen(
            cmd_then_args,
            stdin=subprocess.PIPE, stdout=subprocess.PIPE, close_fds=True)
    if block:
        stdout, stderr = p.communicate()
        return stdout, stderr, p.returncode

117
@singleton
118
class AutostartManager:
119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140

    @staticmethod
    def get_desktop_files():
        return [a.get_filename() for a in Gio.app_info_get_all()]

    @staticmethod
    def get_user_autostart_files():
        return glob.glob(
                    os.path.join(
                        GLib.get_user_config_dir(), "autostart", "*.desktop")) 

    @staticmethod
    def get_system_autostart_files():
        f = []
        for d in GLib.get_system_config_dirs():
            f.extend( glob.glob(os.path.join(d, "autostart", "*.desktop")) )
        return f

class AutostartFile:
    def __init__(self, appinfo, autostart_desktop_filename="", exec_cmd="", extra_exec_args=""):
        self._desktop_file = appinfo.get_filename()
        self._autostart_desktop_filename = autostart_desktop_filename or os.path.basename(self._desktop_file)
141
        self._exec_cmd = exec_cmd
142
        self._extra_exec_args = " %s\n" % extra_exec_args
143

144 145 146 147 148 149
        user_autostart_dir = os.path.join(GLib.get_user_config_dir(), "autostart")
        if not os.path.isdir(user_autostart_dir):
            try:
                os.makedirs(user_autostart_dir)
            except:
                logging.critical("Could not create autostart dir: %s" % user_autostart_dir)
150 151 152 153 154 155

        self._user_autostart_file = os.path.join(user_autostart_dir, self._autostart_desktop_filename)

        logging.debug("Found desktop file: %s" % self._desktop_file)
        logging.debug("User autostart desktop file: %s" % self._user_autostart_file)

156
    def is_start_at_login_enabled(self):
157 158
        if os.path.exists(self._user_autostart_file):
            #prefer user directories first
159 160 161
            #if it contains X-GNOME-Autostart-enabled=false then it has
            #has been disabled by the user in the session applet, otherwise
            #it is enabled
162
            return open(self._user_autostart_file).read().find("X-GNOME-Autostart-enabled=false") == -1
163
        else:
164
            #check the system directories
165 166
            for f in AutostartManager().get_system_autostart_files():
                if os.path.basename(f) == self._autostart_desktop_filename:
167 168
                    return True
        return False
169 170 171

    def update_start_at_login(self, update):

172 173 174
        if os.path.exists(self._user_autostart_file):
            logging.info("Removing user autostart file %s" % self._user_autostart_file)
            os.remove(self._user_autostart_file)
175 176

        if update:
177
            if (not self._desktop_file) or (not os.path.exists(self._desktop_file)):
178
                logging.critical("Could not find desktop file: %s" % self._desktop_file)
179 180
                return

181
            logging.info("Adding autostart %s" % self._user_autostart_file)
182 183
            #copy the original file to the new file, but add the extra exec args
            old = open(self._desktop_file, "r")
184
            new = open(self._user_autostart_file, "w")
185 186 187

            for l in old.readlines():         
                if l.startswith("Exec="):
188 189 190 191 192
                    if self._exec_cmd:
                        new.write("Exec=%s\n" % self._exec_cmd)
                    else:
                        new.write(l[0:-1])
                        new.write(self._extra_exec_args)
193 194 195 196 197
                else:
                    new.write(l)

            old.close()
            new.close()
198

Alex Muñoz's avatar
Alex Muñoz committed
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218
class SchemaList:

    __list = None

    def __init__(self):

        if SchemaList.__list == None:
            SchemaList.__list = []
            
    def get(self):
        return SchemaList.__list
    
    def insert(self, key_name, schema_name):
        v = [key_name, schema_name]
        SchemaList.__list.append(v)
    
    def reset(self):
        for i in SchemaList.__list:
            s = Gio.Settings(i[1])
            s.reset(i[0])
219 220 221 222 223 224 225 226 227 228 229 230
@singleton
class DisableExtension(GObject.GObject):
    
    __gsignals__ = {
        "disable-extension": (GObject.SIGNAL_RUN_FIRST, GObject.TYPE_NONE,()),
    }    
    
    def __init__(self):
        GObject.GObject.__init__(self)
    
    def disable(self):
        self.emit("disable-extension")
Alex Muñoz's avatar
Alex Muñoz committed
231

232 233 234 235 236 237
@singleton
class XSettingsOverrides:

    VARIANT_TYPES = {
        'Gtk/ShellShowsAppMenu': GLib.Variant.new_int32,
        'Gtk/EnablePrimaryPaste': GLib.Variant.new_int32,
238
        'Gtk/DecorationLayout': GLib.Variant.new_string,
239
        'Gdk/WindowScalingFactor': GLib.Variant.new_int32,
240 241 242
    }

    def __init__(self):
243
        self._settings = Gio.Settings(schema='org.gnome.settings-daemon.plugins.xsettings')
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264
        self._variant = self._settings.get_value("overrides")

    def _dup_variant_as_dict(self):
        items = {}
        for k in self._variant.keys():
            try:
                #variant override doesnt support .items()
                v = self._variant[k]
                items[k] = self.VARIANT_TYPES[k](v)
            except KeyError:
                pass
        return items

    def _dup_variant(self):
        return GLib.Variant('a{sv}', self._dup_variant_as_dict())

    def _set_override(self, name, v):
        items = self._dup_variant_as_dict()
        items[name] = self.VARIANT_TYPES[name](v)
        n = GLib.Variant('a{sv}', items)
        self._settings.set_value('overrides', n)
265
        self._variant = self._settings.get_value("overrides")
266 267 268 269 270 271 272 273 274 275 276 277 278

    def _get_override(self, name, default):
        try:
            return self._variant[name]
        except KeyError:
            return default

    #while I could store meta type information in the VARIANT_TYPES
    #dict, its easiest to do default value handling and missing value
    #checks in dedicated functions
    def set_shell_shows_app_menu(self, v):
        self._set_override('Gtk/ShellShowsAppMenu', int(v))
    def get_shell_shows_app_menu(self):
279
        return self._get_override('Gtk/ShellShowsAppMenu', True)
280 281 282
    def set_enable_primary_paste(self, v):
        self._set_override('Gtk/EnablePrimaryPaste', int(v))
    def get_enable_primary_paste(self):
283
        return self._get_override('Gtk/EnablePrimaryPaste', True)
284 285
    def set_window_buttons(self, v):
        self._set_override('Gtk/DecorationLayout', v)
286 287 288 289
    def set_window_scaling_factor(self, v):
        self._set_override('Gdk/WindowScalingFactor', int(v))
    def get_window_scaling_factor(self):
        return self._get_override('Gdk/WindowScalingFactor', 1)
290

291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306
class Notification:
    def __init__(self, summary, body):
        if Notify.is_initted() or Notify.init("GNOME Tweak Tool"):
            self.notification = Notify.Notification.new(
                                    summary,
                                    body,
                                    'gnome-tweak-tool'
            )
            self.notification.set_hint(
                                "desktop-entry",
                                GLib.Variant('s', 'gnome-tweak-tool'))
            self.notification.show()
        else:
            raise Exception("Not Supported")

@singleton
307 308
class LogoutNotification:
    def __init__(self):
309
        if Notify.is_initted() or Notify.init("GNOME Tweak Tool"):
310 311 312 313
            self.notification = Notify.Notification.new(
                                "Configuration changes requiere restart",
                                "Your session needs to be restarted for settings to take effect",
                                'gnome-tweak-tool')
314 315 316
            self.notification.add_action(
                                "restart",
                                "Restart Session",
317
                                self._logout, None, None)
318 319 320
            self.notification.set_hint(
                                "desktop-entry",
                                GLib.Variant('s', 'gnome-tweak-tool'))
321
            self.notification.show()
322
        else:
323
            raise Exception("Not Supported")
324

325
    def _logout(self, btn, action, user_data, unknown):
Alex Muñoz's avatar
Alex Muñoz committed
326 327 328 329 330 331 332 333
        d = Gio.bus_get_sync(Gio.BusType.SESSION, None)
        proxy = Gio.DBusProxy.new_sync(
                       d,Gio.DBusProxyFlags.NONE, None,
                       'org.gnome.SessionManager', 
                       '/org/gnome/SessionManager', 
                       'org.gnome.SessionManager',
                       None)
        proxy.Logout('(u)', 0)
334