utils.py 14 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 dbus
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
class AutostartManager:
118 119 120
    def __init__(self, desktop_filename, autostart_desktop_filename="", exec_cmd="", extra_exec_args=""):
        self.desktop_filename = desktop_filename
        self._autostart_desktop_filename = autostart_desktop_filename or desktop_filename
121
        self._exec_cmd = exec_cmd
122
        self._extra_exec_args = " %s\n" % extra_exec_args
123

124 125 126 127 128 129
        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)
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150

        #find the desktop file
        self._desktop_file = ""
        for f in self._get_desktop_files():
            if os.path.exists(f):
                self._desktop_file = f
        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)

    def _get_system_autostart_files(self):
        return [
            os.path.join(d, "autostart", self._autostart_desktop_filename)
                for d in GLib.get_system_config_dirs()]

    def _get_desktop_files(self):
        dirs = [gtweak.DATA_DIR, GLib.get_user_data_dir()]
        dirs.extend(GLib.get_system_data_dirs())
        return [os.path.join(d, "applications", self.desktop_filename) for d in dirs]

151
    def get_autostart_condition(self):
152
        for f in self._get_system_autostart_files():
153 154 155 156 157 158 159
            if os.path.exists(f):
                with open(f, 'r') as f:
                    for l in f.readlines():
                        if l.startswith("AutostartCondition="):
                            return l.split("=")[-1].strip()
        return None

160 161 162
    def uses_autostart_condition(self, autostart_type=None):
        asc = self.get_autostart_condition()
        try:
163
            if asc and autostart_type:
164 165 166 167 168 169
                return asc.split(" ", 1)[0] == autostart_type
            else:
                return asc != None
        except:
            logging.warning("Testing for expected AutostartCondition failed: Got (%s)" % asc, exc_info=True)
            return False
170 171

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

    def update_start_at_login(self, update):

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

191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208
        asc = self.get_autostart_condition()
        if asc:
            #AutostartCondition=GNOME /desktop/gnome/interface/accessibility
            #AutostartCondition=GNOME3 if-session gnome-fallback
            #AutostartCondition=GSettings org.gnome.desktop.background show-desktop-icons
            method, value = asc.split(" ", 1)
            try:
                logging.info("Changing AutostartCondition %s -> %s" % (method, update))
                if method == "GSettings":
                    schema, key = value.split(" ")
                    GSettingsSetting(schema).set_boolean(key, update)
                else:
                    raise Exception("Method not supported")
            except:
                logging.warning("Autostart desktop file unsupported AutostartCondition (%s)" % asc, exc_info=True)

            return

209
        if update:
210
            if (not self._desktop_file) or (not os.path.exists(self._desktop_file)):
211
                logging.critical("Could not find desktop file: %s" % self._desktop_file)
212 213
                return

214
            logging.info("Adding autostart %s" % self._user_autostart_file)
215 216
            #copy the original file to the new file, but add the extra exec args
            old = open(self._desktop_file, "r")
217
            new = open(self._user_autostart_file, "w")
218 219 220

            for l in old.readlines():         
                if l.startswith("Exec="):
221 222 223 224 225
                    if self._exec_cmd:
                        new.write("Exec=%s\n" % self._exec_cmd)
                    else:
                        new.write(l[0:-1])
                        new.write(self._extra_exec_args)
226 227 228 229 230
                else:
                    new.write(l)

            old.close()
            new.close()
231

Alex Muñoz's avatar
Alex Muñoz committed
232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
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])
252 253 254 255 256 257 258 259 260 261 262 263
@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
264

265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314
@singleton
class XSettingsOverrides:

    VARIANT_TYPES = {
        'Gtk/ShellShowsAppMenu': GLib.Variant.new_int32,
        'Gtk/EnablePrimaryPaste': GLib.Variant.new_int32,
    }

    def __init__(self):
        self._settings = Gio.Settings('org.gnome.settings-daemon.plugins.xsettings')
        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)

    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):
        self._get_override('Gtk/ShellShowsAppMenu', True)
    def set_enable_primary_paste(self, v):
        self._set_override('Gtk/EnablePrimaryPaste', int(v))
    def get_enable_primary_paste(self):
        self._get_override('Gtk/EnablePrimaryPaste', True)

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

349
    def _logout(self, btn, action, unknown):
Alex Muñoz's avatar
Alex Muñoz committed
350 351 352 353 354 355 356 357
        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)
358

359 360
if __name__ == "__main__":
    gtweak.DATA_DIR = "/usr/share"
361
    gtweak.GSETTINGS_SCHEMA_DIR = "/usr/share/glib-2.0/schemas/"
362 363 364 365 366 367 368 369 370 371 372 373 374

    logging.basicConfig(format="%(levelname)-8s: %(message)s", level=logging.DEBUG)

    d = AutostartManager("matlab.desktop")
    print d.desktop_filename, "uses autostartcondition", d.uses_autostart_condition()
    print d.desktop_filename, "autostarts", d.is_start_at_login_enabled()
    d.update_start_at_login(True)
    print d.desktop_filename, "autostarts", d.is_start_at_login_enabled()
    d.update_start_at_login(False)
    print d.desktop_filename, "autostarts", d.is_start_at_login_enabled()

    d = AutostartManager("orca.desktop", "orca-autostart.desktop")
    print d.desktop_filename, "uses autostartcondition", d.uses_autostart_condition()
375
    print d.desktop_filename, "autostartcondition is:", d.get_autostart_condition()
376
    print d.desktop_filename, "uses GSettings autostartcondition", d.uses_autostart_condition("GSettings")
377 378 379 380 381 382
    print d.desktop_filename, "autostarts", d.is_start_at_login_enabled()

    d = AutostartManager("dropbox.desktop")
    print d.desktop_filename, "uses autostartcondition", d.uses_autostart_condition()
    print d.desktop_filename, "autostarts", d.is_start_at_login_enabled()

383 384 385
    d = AutostartManager("nautilus.desktop", "nautilus-autostart.desktop")
    print d.desktop_filename, "uses autostartcondition", d.uses_autostart_condition()
    d.update_start_at_login(False)