path: root/kberylsettings/beryl.py

#!/usr/bin/env python
# -*- coding: utf-8 -*-
""" kberylsettings.beryl -> wrappers around berylsettings objects.

"""
import berylsettings

from os.path import abspath, exists
from re import sub

from qt import QImage, QPixmap, QObject
from kdecore import KIcon
from kberylsettings.lib import App, Signals, icon


class Context(QObject):
    """ Context -> wraps berylsetting.Context instances with extra
    methods and properties.

    """
    activePluginsSettingName = 'active_plugins'

    def __init__(self, context=None):
        QObject.__init__(self)
        if context is None:
            context = berylsettings.Context()
            context.Read()
        self.context = context

    def getCategories(self):
        return self.context.Categories
    categories = property(getCategories)


    def getPlugins(self):
        """ sorted plugin sequence

        @return sequence of Plugin wrapper instances
        """
        seq = [Plugin(p) for p in self.context.Plugins]
        seq.sort(reverse=True)
        return iter(seq)
    plugins = property(getPlugins)

    def plugin(self, value):
        """ locates plugin by name, description, or index

        @param value plugin name, short description, or index
        @return Plugin wrapper instance
        """
        try:
            value + 0
        except (TypeError, ):
            for plugin in self.plugins:
                if value == plugin.ShortDesc:
                    return plugin
                if value == plugin.Name:
                    return plugin
        else:
            return list(self.plugins)[value]

    def getActive(self):
        """ sequence of active plugin names

        @return sequence of active plugin names
        """
        act = self.general.Setting(self.activePluginsSettingName).Value
        return act + [Plugin.generalName, ]

    def setActive(self, active):
        """ sets active plugins

        @param active sequence of plugin names to set as active
        @return None
        """
        self.general.Setting(self.activePluginsSettingName).Value = active
    active = property(getActive, setActive)

    def getGeneral(self):
        """ general plugin instance

        @return Plugin wrapper instance
        """
        return Plugin(self.context.Plugin(Plugin.generalName))
    general = property(getGeneral)

    def write(self):
        """ saves the beryl context

        @return None
        """
        self.emit(Signals.statusMessage, ('Saving Beryl settings....', ))
        self.context.Write()
        self.reload()

    def reload(self):
        """ messages the extension to reload the new settings

        @return None
        """
        berylsettings.send_reload()
        self.emit(Signals.statusMessage, ('Beryl settings reloaded.', ))    


class Plugin:
    generalName = '_'
    iconCache = {}
    
    def __init__(self, plugin):
        self.plugin = plugin

    def __getattr__(self, value):
        return getattr(self.plugin, value)

    def __cmp__(self, other):
        if self.isGeneral:
            return -1
        if not isinstance(other, Plugin):
            other = Plugin(other)
        return cmp(self.plugin.ShortDesc, other.plugin.ShortDesc)

    def isGeneral(self):
        return self.plugin.Name == self.generalName
    isGeneral = property(isGeneral)

    def icon(self, size, loader):
        if App.debug:
            return loader.loadIcon('empty', KIcon.NoGroup, size)
        name = self.plugin.Name
        try:
            pix = self.iconCache[(name, size)]
        except (KeyError, ):
            path = abspath(App.basedir + '/pixmaps/beryl-settings-section-%s.svg' % name)
            if not exists(path):
                path = 'unknown'
            ico = loader.loadIcon(path, KIcon.NoGroup)
            img = ico.convertToImage()
            pix = self.iconCache[(name, size)] = QPixmap()
            pix.convertFromImage(img.smoothScale(size, size, QImage.ScaleMin))
        return pix

    def nativeSettingsGroups(self):
        settingsMap = {}
        for setting in self.plugin.Settings:
            seq = settingsMap.setdefault(setting.Type, [])
            seq.append(setting)
        return settingsMap

    def regroupSettings(self):
        mapping = self.nativeSettingsGroups()
        remap = {}
        for typ, values in mapping.items():
            other = self.alternateGroup(typ, values, mapping)
            seq = remap.setdefault(other, [])
            values.sort()
            seq.extend(values)
        return remap

    def alternateGroup(self, typ, val, mapping):
        if typ in ('Int', 'Float'):
            return 'Numeric Values'
        if typ in ('Bool', 'String'):
            return 'Choices'
        if typ in ('Binding', ):
            return 'Bindings'
        return typ

    def settings(self):
        mapping = {}
        settings = [Setting(s) for s in self.plugin.Settings]
        for setting in settings:
            key = self.alternateGroup(setting.Type, None, None)
            seq = mapping.setdefault(key, [])
            seq.append(setting)
        for seq in mapping.values():
            seq.sort()
        return mapping
    
    settings = property(settings)


class Setting:
    iconNameMap = {
        'Binding' : 'mouse',
        'Bool' : 'apply',
        'Int' : 'configure',
        'List of String' : 'view_text',
        'String' : 'view_detailed',
        'Back':'back',
    }

    labelMap = {
        'Binding' : 'Keyboard/Mouse',
        'Bool' : 'Choices',
        'Int' : 'Values',
        'List of String' : 'Files',
        'String' : 'Values',
    }

    def __init__(self, setting):
        self.setting = setting

    def __cmp__(self, other):
        try:
            a = int(self.ShortDesc.split()[-1])
        except:
            a = self.ShortDesc
        try:
            b = int(other.ShortDesc.split()[-1])
        except:
            b = getattr(other, 'ShortDesc', None)
        return cmp(a, b)
    
    def __getattr__(self, value):
        return getattr(self.setting, value)

    def set(self, value):
        self.setting.Value = value
        
    def icon(cls, value, size):
        name = cls.iconNameMap.get(str(value), cls.iconNameMap['Bool'])
        return icon(name, size=size)
    icon = classmethod(icon)
    
    def label(self):
        value = self.ShortDesc
        value = value.title()
        for pattern, repl in self.fixes:
            value = sub(pattern, repl, value)
        return value
        return settingLabelMap.get(value, value)
    label = property(label)

    def getValue(self):
        try:
            return self.setting.Value
        except (IndexError, ):
            return ''

    def setValue(self, value):
        self.set(value)
    Value = property(getValue, setValue)

    
    fixes = [
        (' A ', ' a '),
        (' And ', ' and '),
        (' For ', ' for '),        
        (' In ', ' in '),
        (' The ', ' the '),        
        (' To ', ' to '),
        (' Of ', ' of '),
        (' On ', ' on '),        
        (' Fsp', ' FSP'),
        (' Svg', ' SVG'),        
        (' Vblank', ' VBlank'),        
        ]