utils.py 12.2 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

    @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=""):
139 140 141 142 143 144 145 146 147 148 149
        if appinfo:
            self._desktop_file = appinfo.get_filename()
            self._autostart_desktop_filename = autostart_desktop_filename or os.path.basename(self._desktop_file)
            self._create_file = False
        elif autostart_desktop_filename:
            self._desktop_file = None
            self._autostart_desktop_filename = autostart_desktop_filename
            self._create_file = True
        else:
            raise Exception("Need either an appinfo or a file name")

150
        self._exec_cmd = exec_cmd
151
        self._extra_exec_args = " %s\n" % extra_exec_args
152

153 154 155 156 157 158
        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)
159 160 161

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

162 163
        if self._desktop_file:
            logging.debug("Found desktop file: %s" % self._desktop_file)
164 165
        logging.debug("User autostart desktop file: %s" % self._user_autostart_file)

166 167 168 169 170 171
    def _create_user_autostart_file(self):
        f = open(self._user_autostart_file, "w")
        f.write("[Desktop Entry]\nType=Application\nName=%s\nExec=%s\n" %
                (self._autostart_desktop_filename[0:-len('.desktop')], self._exec_cmd + self._extra_exec_args))
        f.close()

172
    def is_start_at_login_enabled(self):
173 174
        if os.path.exists(self._user_autostart_file):
            #prefer user directories first
175 176 177
            #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
178
            return open(self._user_autostart_file).read().find("X-GNOME-Autostart-enabled=false") == -1
179
        else:
180
            #check the system directories
181 182
            for f in AutostartManager().get_system_autostart_files():
                if os.path.basename(f) == self._autostart_desktop_filename:
183 184
                    return True
        return False
185 186 187

    def update_start_at_login(self, update):

188 189 190
        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)
191 192

        if update:
193
            if (not self._desktop_file) or (not os.path.exists(self._desktop_file)):
194 195 196 197
                if self._create_file:
                    self._create_user_autostart_file()
                else:
                    logging.critical("Could not find desktop file: %s" % self._desktop_file)
198 199
                return

200
            logging.info("Adding autostart %s" % self._user_autostart_file)
201 202
            #copy the original file to the new file, but add the extra exec args
            old = open(self._desktop_file, "r")
203
            new = open(self._user_autostart_file, "w")
204 205 206

            for l in old.readlines():         
                if l.startswith("Exec="):
207 208 209 210 211
                    if self._exec_cmd:
                        new.write("Exec=%s\n" % self._exec_cmd)
                    else:
                        new.write(l[0:-1])
                        new.write(self._extra_exec_args)
212 213 214 215 216
                else:
                    new.write(l)

            old.close()
            new.close()
217

Alex Muñoz's avatar
Alex Muñoz committed
218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237
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])
238 239 240 241 242 243 244 245 246 247 248 249
@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
250

251 252 253 254 255 256
@singleton
class XSettingsOverrides:

    VARIANT_TYPES = {
        'Gtk/ShellShowsAppMenu': GLib.Variant.new_int32,
        'Gtk/EnablePrimaryPaste': GLib.Variant.new_int32,
257
        'Gdk/WindowScalingFactor': GLib.Variant.new_int32,
258 259 260
    }

    def __init__(self):
261
        self._settings = Gio.Settings(schema='org.gnome.settings-daemon.plugins.xsettings')
262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
        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)
283
        self._variant = self._settings.get_value("overrides")
284 285 286 287 288 289 290 291 292 293 294 295 296

    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):
297
        return self._get_override('Gtk/ShellShowsAppMenu', True)
298 299 300
    def set_enable_primary_paste(self, v):
        self._set_override('Gtk/EnablePrimaryPaste', int(v))
    def get_enable_primary_paste(self):
301
        return self._get_override('Gtk/EnablePrimaryPaste', True)
302 303 304 305
    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)
306

307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
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
323 324
class LogoutNotification:
    def __init__(self):
325
        if Notify.is_initted() or Notify.init("GNOME Tweak Tool"):
326
            self.notification = Notify.Notification.new(
327
                                "Configuration changes require restart",
328 329
                                "Your session needs to be restarted for settings to take effect",
                                'gnome-tweak-tool')
330 331 332
            self.notification.add_action(
                                "restart",
                                "Restart Session",
333
                                self._logout, None, None)
334 335 336
            self.notification.set_hint(
                                "desktop-entry",
                                GLib.Variant('s', 'gnome-tweak-tool'))
337
            self.notification.show()
338
        else:
339
            raise Exception("Not Supported")
340

341
    def _logout(self, btn, action, user_data, unknown):
Alex Muñoz's avatar
Alex Muñoz committed
342 343 344 345 346 347 348 349
        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)
350