def __init__(self, categories_array):
self.util = Utils()
# Item structure
self.path = ""
self.filename = ""
self.version_config = 0.1
self.name = ""
self.name_original = ""
self.comment = ""
self.comment_original = ""
self.category = ""
self.categories_list = []
self.categories_array = categories_array
self.category_other = False
self.icon = ""
# Icon type : themed, fix or fallback
self.icon_type = ""
self.icon_original = ""
self.try_exec = ""
self.only_show_in = []
self.not_show_in = []
self.activate = True
self.activate_original = True
self.deactivate_reasons = []
self.changed = False
self.check = True
# module or application
self.type = ""
# application specific
self.execute_command =""
# module specific
self.module_replace_application = []
self.module_depends = []
self.module_version = 0.0
self.module_api_version = 0.0
self.module_spec = None
self.module_toolkits = []
self.module_running_toolkit = None
self.module_experimental = False
def __init__(self, runtime):
logging.info("Setting.__init__: enter function")
self.util = Utils()
self.runtime = runtime
self.name = None
self.setting_type = "string"
self.available_values = {}
# LXSesion file: Format .ini file: ["lxsession", support, group, key]
self.lxsession_file_setting = ["lxsession_file", False, None, None]
# LXSession Dbus: Format Dbus: ["lxsession", support, Method, key1, key2]
self.lxsession_dbus_setting = [
"lxsession_dbus", False, None, None, None
]
# Cinnamon Setting: Format GSettings [group, key]
self.cinnamon_setting = ["cinnamon_settings", False, None, None]
# Gnome Setting: Format GSettings [group, key]
self.gnome_setting = ["gnome_settings", False, None, None]
# Mate Setting: Format GSettings [group, key]
self.mate_setting = ["mate_settings", False, None, None]
# LXQt Setting: Format GSettings [group, key]
self.lxqt_setting = ["lxqt_settings", False, None, None]
# GTK3 Setting: Format .ini [group, key]
self.gtk3_setting = ["gtk3_settings", False, None, None]
# Openbox Setting: Format xml [support, Tag1, Tag2]
self.openbox_setting = ["openbox_settings", False, None, None]
# LX Control Center: Format .ini file ["lx_control_center_setting", support, group, key]
self.lx_control_center_setting = [
"lx_control_center_setting", False, None, None
]
#List of settings
self.settings_list = [
self.lxsession_file_setting, self.lxsession_dbus_setting,
self.cinnamon_setting, self.gnome_setting, self.mate_setting,
self.lxqt_setting, self.gtk3_setting, self.openbox_setting,
self.lx_control_center_setting
]
self.support_list = []
def __init__(self):
logging.info("Runtime.__init__: enter function")
self.util = Utils()
# Format for runtime key
# self.support[key] = [pretty_name, binary, running ?, configuration_object, configuration_path]
self.support = {}
self.support["lxsession_file"] = [
"LXSession (keyfile)", "lxsession", False, None, None
]
self.support["lxsession_dbus"] = [
"LXSession (dbus)", "lxsession", False, None, None
]
self.support["cinnamon_settings"] = [
"Cinnamon", "cinnamon-settings-daemon", False, None, None
]
self.support["gnome_settings"] = [
"GNOME", "gnome-settings-daemon", False, None, None
]
self.support["mate_settings"] = [
"MATE", "mate-settings-daemon", False, None, None
]
self.support["lxqt_settings"] = [
"LXQt", "lxqt-session", False, None, None
]
self.support["gtk3_settings"] = ["GTK3", None, False, None, None]
self.support["openbox_settings"] = [
"Openbox", "openbox", False, None, None
]
self.support["lx_control_center_setting"] = [
"LX Control Center", None, True, None, None
]
# List of support key which are actually running on the system
self.running = []
# Startup functions
self.running_aplications = self.util.generate_running_applications()
self.check_running_support()
self.check_conf_support()
class Runtime():
# Class to check support (applications runnings) on current machine. It only needs to be instantiate once, and be reused.
def __init__(self):
logging.info("Runtime.__init__: enter function")
self.util = Utils()
# Format for runtime key
# self.support[key] = [pretty_name, binary, running ?, configuration_object, configuration_path]
self.support = {}
self.support["lxsession_file"] = [
"LXSession (keyfile)", "lxsession", False, None, None
]
self.support["lxsession_dbus"] = [
"LXSession (dbus)", "lxsession", False, None, None
]
self.support["cinnamon_settings"] = [
"Cinnamon", "cinnamon-settings-daemon", False, None, None
]
self.support["gnome_settings"] = [
"GNOME", "gnome-settings-daemon", False, None, None
]
self.support["mate_settings"] = [
"MATE", "mate-settings-daemon", False, None, None
]
self.support["lxqt_settings"] = [
"LXQt", "lxqt-session", False, None, None
]
self.support["gtk3_settings"] = ["GTK3", None, False, None, None]
self.support["openbox_settings"] = [
"Openbox", "openbox", False, None, None
]
self.support["lx_control_center_setting"] = [
"LX Control Center", None, True, None, None
]
# List of support key which are actually running on the system
self.running = []
# Startup functions
self.running_aplications = self.util.generate_running_applications()
self.check_running_support()
self.check_conf_support()
# Debug
#self.debug()
def generate_running(self):
for support in self.support:
if (support[2] == True):
self.running.append(support)
def check_running_support(self):
logging.info("Runtime.check_running_support: enter function")
for support in self.support:
if (self.support[support][1] == None):
self.support[support][2] = True
elif (self.support[support][1] in self.running_aplications):
self.support[support][2] = True
def check_conf_support(self):
logging.info("Runtime.check_running_support: enter function")
for support in self.support:
if (support == "lxsession_file"):
profile = os.environ['DESKTOP_SESSION']
lxsession_dir = os.path.join("lxsession", profile)
try:
self.support[support][4] = os.path.join(
lxsession_dir, "desktop.conf")
if (self.support[support][4] is not None):
self.support[support][3] = self.util.load_object(
"ini", self.support[support][4])
except:
pass
elif (support == "lxsession_dbus"):
try:
bus = SessionBus()
remote_object = bus.get("org.lxde.SessionManager",
"/org/lxde/SessionManager")
self.support[support][3] = remote_object
except:
pass
elif (support == "gtk3_settings"):
try:
self.support[support][4] = os.path.join(
"gtk-3.0", "settings.ini")
if (self.support[support][4] is not None):
self.support[support][3] = self.util.load_object(
"ini", self.support[support][4])
except:
pass
elif (support == "lxqt_settings"):
try:
self.support[support][4] = os.path.join(
"lxqt", "lxqt.conf")
if (self.support[support][4] is not None):
self.support[support][3] = self.util.load_object(
"ini", self.support[support][4])
except:
pass
elif (support == "lx_control_center_setting"):
try:
self.support[support][4] = os.path.join(
"lx-control-center", "settings.conf")
if (self.support[support][4] is not None):
self.support[support][3] = self.util.load_object(
"ini", self.support[support][4])
except:
pass
elif (support == "openbox_settings"):
conf_file = "rc.xml"
procs = psutil.process_iter()
for proc in procs:
if (proc.name() == "openbox"):
try:
conf_file = proc.cmdline()[2]
except:
pass
self.support[support][4] = os.path.join("openbox", conf_file)
if (self.support[support][4] is not None):
self.support[support][3] = self.util.load_object(
"xml", self.support[support][4])
def debug(self):
for i in self.support:
print("Runtime.support for %s: %s - %s - %s - %s - %s" %
(i, self.support[i][0], self.support[i][1],
self.support[i][2], self.support[i][3], self.support[i][4]))
def __init__(self):
logging.info("Base__init__: enter function")
self.util = Utils()
self.runtime = Runtime()
# Base
self.version_config = 0.1
self.keyfile_settings = None
self.keyfile_items = None
self.items = {}
self.items_conf_path = None
self.desktop_environments = []
self.trigger_save_settings_file = False
self.module_activated = None
self.toolkit = None
self.standalone_module = None
self.keyword_categories_settings_list_default = [ "Settings",
"System",
"DesktopSettings",
"X-LXDE-Settings",
"X-GNOME-Settings-Panel",
"X-GNOME-PersonalSettings",
"X-XFCE-SettingsDialog",
"X-XFCE-HardwareSetting"]
self.keyword_categories_settings_list = self.keyword_categories_settings_list_default
self.desktop_environments_setting_default = ["Auto"]
self.desktop_environments_setting = self.desktop_environments_setting_default
self.frontend_control_center_setting = FrontendControlCenterSetting(self.runtime)
self.frontend = "GTK3"
self.version_config_default = 0.1
self.version_config = self.version_config_default
self.modules_support_control_center_setting = ModulesSupportControlCenterSetting(self.runtime)
self.modules_experimental_control_center_setting = ModulesExperimentalControlCenterSetting(self.runtime)
self.applications_support_control_center_setting = ApplicationsSupportControlCenterSetting(self.runtime)
self.category_other_control_center_setting = CategoryOtherControlCenterSetting(self.runtime)
self.blacklist_default = ["debian-xterm.desktop","debian-uxterm.desktop"]
self.blacklist = self.blacklist_default
self.whitelist_default = []
self.whitelist = self.whitelist_default
# Order by importance (first read take advantage)
self.applications_path_default = ["/usr/share/applications"]
self.applications_path = self.applications_path_default
self.modules_path_default = [ "/usr/lib/lx-control-center",
"/usr/share/lx-control-center",
"LXControlCenter/modules/"]
self.modules_path = self.modules_path_default
self.categories_fixed_default = False
self.categories_fixed = self.categories_fixed_default
self.categories_keys_default = { _("DesktopSettings"):("DesktopSettings",),
_("HardwareSettings"):("HardwareSettings",),
_("Printing"):("Printing",),
_("System"):("PackageManager","TerminalEmulator"),
_("FileManager"):("FileManager","FileTools","Filesystem"),
_("Monitor"):("Monitor",),
_("Security"):("Security",),
_("Accessibility"):("Accessibility",)
}
self.categories_keys = self.categories_keys_default
self.categories_triaged = {}
# UI - View
self.window_size_w_default = 800
self.window_size_w = self.window_size_w_default
self.window_size_h_default = 600
self.window_size_h = self.window_size_h_default
self.window_icon_default = "preferences-system"
self.window_icon = self.window_icon_default
self.window_title_default = _("LX-Control-Center")
self.window_title = self.window_title_default
self.icon_view_columns_default = 3
self.icon_view_columns = self.icon_view_columns_default
self.icons_size_control_center_setting = IconsSizeControlCenterSetting(self.runtime)
self.icon_not_theme_allow_default = False
self.icon_not_theme_allow = self.icon_not_theme_allow_default
self.icon_force_size_default = True
self.icon_force_size = self.icon_force_size_default
self.icon_fallback_default = "gtk-stop"
self.icon_fallback = self.icon_fallback_default
self.view_mode_default = "icons-all"
self.view_mode = self.view_mode_default
self.view_visual_effects_default = False
self.view_visual_effects = self.view_visual_effects_default
# UI
# Items visible in the view, to be display
self.items_visible = []
# Items visible, triage by categories
self.items_visible_by_categories = {}
# Items, triage by categories
self.items_by_categories = {}
# Different mode of display the UI :
# - main-UI => Icons view
# - pref-UI => Preferences view
# - edit-UI => Edit mode of the icons view
# - edit-item-UI => Edit an item, after clicking on a icon of edit mode
# - category-UI => View of only 1 category
# - module-UI ==> Display the current module loaded
self.mode = "main-UI"
# Menu items labels & tooltips
self.icons_menu_item = _("Icons")
self.preferences_menu_item = _("Preferences")
self.edit_menu_item = _("Edit")
# TODO Find something useful to display
self.icons_menu_item_tooltip = _("Icons")
self.preferences_menu_item_tooltip = _("Preferences")
self.edit_menu_item_tooltip = _("Edit")
# Pref Mode labels
self.pref_category_configuration_label = _("Configuration")
self.pref_category_ui_label = _("Visual")
# UI Items
self.content_ui_vbox = None
self.search_string = None
class Base(Utils):
def __init__(self):
logging.info("Base__init__: enter function")
self.util = Utils()
self.runtime = Runtime()
# Base
self.version_config = 0.1
self.keyfile_settings = None
self.keyfile_items = None
self.items = {}
self.items_conf_path = None
self.desktop_environments = []
self.trigger_save_settings_file = False
self.module_activated = None
self.toolkit = None
self.standalone_module = None
self.keyword_categories_settings_list_default = [ "Settings",
"System",
"DesktopSettings",
"X-LXDE-Settings",
"X-GNOME-Settings-Panel",
"X-GNOME-PersonalSettings",
"X-XFCE-SettingsDialog",
"X-XFCE-HardwareSetting"]
self.keyword_categories_settings_list = self.keyword_categories_settings_list_default
self.desktop_environments_setting_default = ["Auto"]
self.desktop_environments_setting = self.desktop_environments_setting_default
self.frontend_control_center_setting = FrontendControlCenterSetting(self.runtime)
self.frontend = "GTK3"
self.version_config_default = 0.1
self.version_config = self.version_config_default
self.modules_support_control_center_setting = ModulesSupportControlCenterSetting(self.runtime)
self.modules_experimental_control_center_setting = ModulesExperimentalControlCenterSetting(self.runtime)
self.applications_support_control_center_setting = ApplicationsSupportControlCenterSetting(self.runtime)
self.category_other_control_center_setting = CategoryOtherControlCenterSetting(self.runtime)
self.blacklist_default = ["debian-xterm.desktop","debian-uxterm.desktop"]
self.blacklist = self.blacklist_default
self.whitelist_default = []
self.whitelist = self.whitelist_default
# Order by importance (first read take advantage)
self.applications_path_default = ["/usr/share/applications"]
self.applications_path = self.applications_path_default
self.modules_path_default = [ "/usr/lib/lx-control-center",
"/usr/share/lx-control-center",
"LXControlCenter/modules/"]
self.modules_path = self.modules_path_default
self.categories_fixed_default = False
self.categories_fixed = self.categories_fixed_default
self.categories_keys_default = { _("DesktopSettings"):("DesktopSettings",),
_("HardwareSettings"):("HardwareSettings",),
_("Printing"):("Printing",),
_("System"):("PackageManager","TerminalEmulator"),
_("FileManager"):("FileManager","FileTools","Filesystem"),
_("Monitor"):("Monitor",),
_("Security"):("Security",),
_("Accessibility"):("Accessibility",)
}
self.categories_keys = self.categories_keys_default
self.categories_triaged = {}
# UI - View
self.window_size_w_default = 800
self.window_size_w = self.window_size_w_default
self.window_size_h_default = 600
self.window_size_h = self.window_size_h_default
self.window_icon_default = "preferences-system"
self.window_icon = self.window_icon_default
self.window_title_default = _("LX-Control-Center")
self.window_title = self.window_title_default
self.icon_view_columns_default = 3
self.icon_view_columns = self.icon_view_columns_default
self.icons_size_control_center_setting = IconsSizeControlCenterSetting(self.runtime)
self.icon_not_theme_allow_default = False
self.icon_not_theme_allow = self.icon_not_theme_allow_default
self.icon_force_size_default = True
self.icon_force_size = self.icon_force_size_default
self.icon_fallback_default = "gtk-stop"
self.icon_fallback = self.icon_fallback_default
self.view_mode_default = "icons-all"
self.view_mode = self.view_mode_default
self.view_visual_effects_default = False
self.view_visual_effects = self.view_visual_effects_default
# UI
# Items visible in the view, to be display
self.items_visible = []
# Items visible, triage by categories
self.items_visible_by_categories = {}
# Items, triage by categories
self.items_by_categories = {}
# Different mode of display the UI :
# - main-UI => Icons view
# - pref-UI => Preferences view
# - edit-UI => Edit mode of the icons view
# - edit-item-UI => Edit an item, after clicking on a icon of edit mode
# - category-UI => View of only 1 category
# - module-UI ==> Display the current module loaded
self.mode = "main-UI"
# Menu items labels & tooltips
self.icons_menu_item = _("Icons")
self.preferences_menu_item = _("Preferences")
self.edit_menu_item = _("Edit")
# TODO Find something useful to display
self.icons_menu_item_tooltip = _("Icons")
self.preferences_menu_item_tooltip = _("Preferences")
self.edit_menu_item_tooltip = _("Edit")
# Pref Mode labels
self.pref_category_configuration_label = _("Configuration")
self.pref_category_ui_label = _("Visual")
# UI Items
self.content_ui_vbox = None
self.search_string = None
def init(self):
logging.info("Base.init: enter function")
# Load configuration file, and the settings in it
self.load_settings()
# Normal startup, if no module arg set
if (self.standalone_module == None):
self.load_all_applications()
self.load_all_modules()
self.desktop_environments_generate()
# Desactivate items
self.triage_items()
# Load specific item conf
self.load_items_conf()
else:
self.load_all_modules()
for i in self.items:
self.triage_modules(i)
# Debug if enable
self.print_debug()
# Base functions
def triage_items(self):
logging.info("Base.triage_items: enter function")
for i in self.items:
self.apply_applications_modules_suport(i)
self.triage_modules(i)
self.apply_desktop_env_sort(i)
self.apply_try_exec_test(i)
self.apply_no_exec_applications(i)
self.apply_blacklist(i)
self.apply_module_toolkit(i)
self.apply_items_categories(i)
self.apply_category_other(i)
self.apply_whitelist(i)
self.load_items_conf()
def triage_modules(self, item):
logging.info("Base.triage_modules: enter function")
self.apply_module_experimental_support(item)
self.apply_module_toolkit(item)
def load_settings (self):
logging.info("Base.load_settings: enter function")
""" Load settings from lx-control-center/settings.conf"""
self.keyfile_settings = self.runtime.support["lx_control_center_setting"][3]
if(self.keyfile_settings != None):
# Configuration
self.keyword_categories_settings_list = self.util.get_setting("keyfile", self.keyfile_settings, "Configuration", "desktop_categories", self.keyword_categories_settings_list_default, "list")
self.desktop_environments_setting = self.util.get_setting("keyfile", self.keyfile_settings, "Configuration", "desktop_environments", self.desktop_environments_setting_default, "list")
self.frontend_setting = self.frontend_control_center_setting.get()
self.version_config = self.util.get_setting("keyfile", self.keyfile_settings, "Configuration", "version_config", self.version_config_default, "float")
self.modules_support = self.modules_support_control_center_setting.get()
self.modules_experimental_support = self.modules_experimental_control_center_setting.get()
self.applications_support = self.applications_support_control_center_setting.get()
self.categories_fixed = self.util.get_setting("keyfile", self.keyfile_settings, "Configuration", "categories_fixed", self.categories_fixed_default, "boolean")
self.show_category_other = self.category_other_control_center_setting.get()
self.blacklist = self.util.get_setting("keyfile", self.keyfile_settings, "Configuration","blacklist", self.blacklist_default, "list")
self.whitelist = self.util.get_setting("keyfile", self.keyfile_settings, "Configuration","whitelist", self.whitelist_default, "list")
# Categories
if (self.categories_fixed == False):
if (self.keyfile_settings.has_section("Categories")):
self.categories_keys.clear()
self.categories_triaged.clear()
tmp_categories_keys = self.keyfile_settings.options("Categories")
for key in tmp_categories_keys:
logging.debug("load_settings: key in tmp_categories_keys = %s" % key)
self.categories_keys[key] = self.util.get_setting("keyfile", self.keyfile_settings, "Categories", key, self.categories_keys_default, "list")
logging.debug("load_settings: self.categories_keys = %s" % self.categories_keys)
self.categories_triaged_generate()
# Path
self.applications_path = self.util.get_setting("keyfile", self.keyfile_settings, "Path","applications_path", self.applications_path_default, "list")
self.modules_path = self.util.get_setting("keyfile", self.keyfile_settings, "Path","modules_path", self.modules_path_default, "list")
# UI
self.window_size_w = self.util.get_setting("keyfile", self.keyfile_settings, "UI", "window_size_w", self.window_size_w_default, "int")
self.window_size_h = self.util.get_setting("keyfile", self.keyfile_settings, "UI", "window_size_h", self.window_size_h_default, "int")
self.window_icon = self.util.get_setting("keyfile", self.keyfile_settings, "UI", "window_icon", self.window_icon_default, "string")
self.window_title = self.util.get_setting("keyfile", self.keyfile_settings, "UI", "window_title", self.window_title_default, "string")
self.icon_view_columns = self.util.get_setting("keyfile", self.keyfile_settings, "UI", "icon_view_columns", self.icon_view_columns_default, "int")
self.icon_view_icons_size = self.icons_size_control_center_setting.get()
self.icon_not_theme_allow = self.util.get_setting("keyfile", self.keyfile_settings, "UI", "icon_not_theme_allow", self.icon_not_theme_allow_default, "boolean")
self.icon_force_size = self.util.get_setting("keyfile", self.keyfile_settings, "UI", "icon_force_size", self.icon_force_size_default, "boolean")
self.icon_fallback = self.util.get_setting("keyfile", self.keyfile_settings, "UI", "icon_fallback", self.icon_fallback_default, "string")
self.view_mode = self.util.get_setting("keyfile", self.keyfile_settings, "UI", "view_mode", self.view_mode_default, "string")
self.view_visual_effects = self.util.get_setting("keyfile", self.keyfile_settings, "UI", "view_visual_effects", self.view_visual_effects_default, "boolean")
def load_items_conf(self):
logging.info("Base.load_items_conf: enter function")
if (self.keyfile_items == None):
self.keyfile_items = self.util.load_object("ini", os.path.join("lx-control-center","items.conf"))
for keyfile_item in self.keyfile_items.sections():
logging.debug("load_items_conf: keyfile_item =%s" % keyfile_item)
for setting in self.keyfile_items.options(keyfile_item):
logging.debug("load_items_conf: setting =%s" % setting)
if (setting == "name"):
self.items[keyfile_item].name = self.keyfile_items.get(keyfile_item, setting)
self.items[keyfile_item].changed = True
elif (setting == "comment"):
self.items[keyfile_item].comment = self.keyfile_items.get(keyfile_item, setting)
self.items[keyfile_item].changed = True
elif (setting == "icon"):
self.items[keyfile_item].icon = self.keyfile_items.get(keyfile_item, setting)
self.items[keyfile_item].changed = True
elif (setting == "activate"):
self.items[keyfile_item].activate = self.keyfile_items.getboolean(keyfile_item, setting)
self.items[keyfile_item].changed = True
def list_all_applications_from_dirs(self):
""" List all applications from applications directories"""
logging.info("list_all_applications_from_dirs: enter function")
return_list = []
for path in self.applications_path:
try:
list_files = [f for f in os.listdir(path) if os.path.isfile(os.path.join(path, f))]
for application_file in list_files:
app_path = os.path.join(path,application_file)
keyfile = None
if (os.path.splitext(app_path)[1] == ".desktop"):
keyfile = self.util.load_object("xdg",app_path)
categories = []
categories = keyfile.getCategories()
if (categories != []):
to_add = 0
for item in self.keyword_categories_settings_list:
if (item in categories):
to_add = 1
if (to_add == 1):
item_to_add = app_path
if (item_to_add not in return_list):
return_list.append(app_path)
except OSError:
logging.info("list_all_applications_from_dirs: %s not found in applications path" % path)
return return_list
def load_all_applications (self):
logging.info("Base.load_all_applications: enter function")
list_app = self.list_all_applications_from_dirs()
logging.debug("load_all_applications: %s" % list_app)
for i in list_app:
item = Item(self.categories_triaged)
item.load_application_from_path(i)
if (item.check == True):
self.items[item.path] = item
def list_all_modules_from_dirs(self):
logging.info("Base.list_all_modules_from_dirs: enter function")
return_list = []
for path in self.modules_path:
if(os.path.exists(path)):
list_dirs = [d for d in os.listdir(path) if os.path.isdir(os.path.join(path, d))]
for dirs in list_dirs:
dir_path = os.path.join(path, dirs)
logging.debug("list_all_modules_from_dirs: list_dirs = %s " % dirs)
list_files = [f for f in os.listdir(dir_path) if os.path.isfile(os.path.join(dir_path, f))]
for module_file in list_files:
file_path = os.path.join(dir_path, module_file)
logging.debug("list_all_modules_from_dirs: list_files = %s " % module_file)
if (os.path.splitext(file_path)[1] == ".desktop"):
keyfile = None
keyfile = self.util.load_object("xdg",file_path)
return_list.append(file_path)
else:
logging.info("list_all_modules_from_dirs: %s doesn't exist in path" % path)
return return_list
def load_all_modules (self):
logging.info("Base.load_all_modules: enter function")
list_modules = self.list_all_modules_from_dirs()
logging.debug("load_all_modules: %s :" % list_modules)
for m in list_modules:
item = Item(self.categories_triaged)
item.load_module_from_path(m, self.toolkit)
if (item.check == True):
self.items[item.path] = item
# TODO Store list of running applications, to filter desktop application
# Use self.generate_running_applications
def apply_desktop_env_sort(self, i):
logging.info("Base.apply_desktop_env_sort: enter function")
if (len(self.items[i].not_show_in) != 0):
for desktop in self.desktop_environments:
if (desktop in self.items[i].not_show_in):
self.items[i].activate = False
self.items[i].activate_original = False
self.items[i].add_deactivate_reason(_("Current environment in NotShow field"))
if (self.items[i].activate == True):
if (len(self.items[i].only_show_in) != 0):
for desktop in self.desktop_environments:
if (desktop not in self.items[i].only_show_in):
self.items[i].activate = False
self.items[i].activate_original = False
self.items[i].add_deactivate_reason(_("Current environment not in OnlyShow field"))
def apply_try_exec_test(self, i):
logging.info("Base.apply_try_exec_test: enter function")
if (self.items[i].type == "application"):
if (self.items[i].try_exec != ""):
if (os.path.exists(self.items[i].try_exec) == False):
self.items[i].activate = False
self.items[i].activate_original = False
self.items[i].add_deactivate_reason(_("Excecutable in TryExec doesn't exist"))
def apply_no_exec_applications(self, i):
logging.info("Base.apply_no_exec_applications: enter function")
if (self.items[i].type == "application"):
if (self.items[i].execute_command is None):
self.items[i].activate = False
self.items[i].activate_original = False
self.items[i].add_deactivate_reason(_("Excecutable path doesn't exist"))
def apply_blacklist (self, i):
logging.info("Base.apply_blacklist: enter function")
# Test abslotute path
if (self.items[i].path in self.blacklist):
self.items[i].activate = False
self.items[i].activate_original = False
self.items[i].add_deactivate_reason(_("Blacklisted (absolute path)"))
# Test desktop file name
if (self.items[i].filename in self.blacklist):
self.items[i].activate = False
self.items[i].activate_original = False
self.items[i].add_deactivate_reason(_("Blacklisted (desktop file name)"))
def apply_whitelist (self, i):
logging.info("Base.apply_whitelist: enter function")
# Test abslotute path
if (self.items[i].path in self.whitelist):
self.items[i].activate = True
self.items[i].activate_original = True
self.items[i].add_deactivate_reason(_("Whitelisted (absolute path)"))
# Test desktop file name
if (self.items[i].filename in self.whitelist):
self.items[i].activate = True
self.items[i].activate_original = True
self.items[i].add_deactivate_reason(_("Whitelisted (desktop file name)"))
def apply_category_other (self, i):
logging.info("Base.apply_category_other: enter function")
if (self.show_category_other == False):
if (self.items[i].category_other == True):
self.items[i].activate = False
self.items[i].activate_original = False
self.items[i].add_deactivate_reason(_("Category Other deactivated"))
def apply_applications_modules_suport(self, i):
logging.info("Base.apply_applications_modules_suport: enter function")
if (self.items[i].type == "module"):
self.items[i].activate = self.modules_support
self.items[i].activate_original = self.modules_support
elif (self.items[i].type == "application"):
self.items[i].activate = self.applications_support
self.items[i].activate_original = self.modules_support
def apply_triage_module(self, i):
logging.info("Base.apply_triage_module: enter function")
if (self.items[i].type == "module"):
if (self.modules_support == True):
to_replace = self.items[i].module_replace_application
for r in to_replace:
if (self.items[i].filename == r):
self.items[i].activate = False
self.items[i].activate_original = False
self.items[i].add_deactivate_reason(_("Replaced by an active module"))
else:
self.items[i].activate = False
self.items[i].activate_original = False
self.items[i].add_deactivate_reason(_("Module support deactivated"))
def apply_module_toolkit(self, i):
logging.info("Base.apply_module_toolkit: enter function")
if (self.items[i].type == "module"):
if (len(self.items[i].module_toolkits) > 0):
if (self.toolkit not in self.items[i].module_toolkits):
self.items[i].activate = False
self.items[i].activate_original = False
self.items[i].add_deactivate_reason(_("Module is not compatible with current toolkit"))
def apply_module_experimental_support(self, i):
logging.info("Base.apply_module_experimental_support: enter function")
if (self.items[i].type == "module"):
if (self.items[i].module_experimental == True):
if (self.modules_experimental_support == True):
self.items[i].add_deactivate_reason(_("Experimental module, with support enabled"))
else:
self.items[i].activate = False
self.items[i].activate_original = False
self.items[i].add_deactivate_reason(_("Experimental module, but the support is not enabled"))
def apply_items_categories(self, i):
logging.info("Base.apply_items_categories: enter fonction")
self.items[i].category_array = self.categories_triaged
self.items[i].define_category_from_list()
def desktop_environments_generate(self):
logging.info("Base.desktop_environments_generate: enter function")
if self.desktop_environments_setting == ["Auto"]:
new_list = []
new_list.append(os.getenv("XDG_CURRENT_DESKTOP"))
self.desktop_environments = new_list
else:
self.desktop_environments = self.desktop_environments_setting
def categories_triaged_generate(self):
logging.info("Base.categories_triaged_generate: enter function")
for key in self.categories_keys.keys():
for item in self.categories_keys[key]:
if (len(item) > 1):
self.categories_triaged[item] = key
else:
to_add = self.categories_keys[key]
self.categories_triaged[to_add] = key
break
def save_settings(self):
logging.info("Base.save_settings: enter function")
self.keyfile_settings = self.runtime.support["lx_control_center_setting"][3]
# Configuration
self.util.set_setting("keyfile", self.keyfile_settings, "Configuration","desktop_categories", self.keyword_categories_settings_list, self.keyword_categories_settings_list_default,"list", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "Configuration","desktop_environments", self.desktop_environments_setting, self.desktop_environments_setting_default, "list", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "Configuration", "version_config", self.version_config, self.version_config_default, "float", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "Configuration", "categories_fixed", self.categories_fixed, self.categories_fixed_default, "boolean", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "Configuration", "blacklist", self.blacklist, self.blacklist_default, "list", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "Configuration", "whitelist", self.whitelist, self.whitelist_default, "list", self.trigger_save_settings_file)
# Categories
if (self.categories_fixed == False):
if (self.categories_keys != self.categories_keys_default):
for category in self.categories_keys:
self.util.set_setting("keyfile", self.keyfile_settings, "Categories",category, self.categories_keys[category], None, "list", self.trigger_save_settings_file)
# Path
self.util.set_setting("keyfile", self.keyfile_settings, "Path","applications_path", self.applications_path, self.applications_path_default, "list", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "Path","modules_path", self.modules_path, self.modules_path_default, "list", self.trigger_save_settings_file)
# UI
self.util.set_setting("keyfile", self.keyfile_settings, "UI", "window_size_w", self.window_size_w, self.window_size_w_default, "int", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "UI", "window_size_h", self.window_size_h, self.window_size_h_default, "int", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "UI", "window_icon", self.window_icon, self.window_icon_default, "generic", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "UI", "window_title", self.window_title, self.window_title_default, "generic", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "UI", "icon_view_columns", self.icon_view_columns, self.icon_view_columns_default, "int", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "UI", "icon_not_theme_allow", self.icon_not_theme_allow, self.icon_not_theme_allow_default, "boolean", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "UI", "icon_force_size", self.icon_force_size, self.icon_force_size_default, "boolean", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "UI", "icon_fallback", self.icon_fallback, self.icon_fallback_default, "generic", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "UI", "view_mode", self.view_mode, self.view_mode_default, "generic", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_settings, "UI", "view_visual_effects", self.view_visual_effects, self.view_visual_effects_default, "boolean", self.trigger_save_settings_file)
if (self.trigger_save_settings_file == True):
self.util.save_object(self.keyfile_settings, os.path.join("lx-control-center", "settings.conf"))
self.trigger_save_settings_file = False
# items.conf
if (self.keyfile_items == None):
self.keyfile_items = self.util.load_object("ini", os.path.join("lx-control-center","items.conf"))
logging.debug("save_settings: loading %s as a keyfile_items" % os.path.join("lx-control-center","items.conf"))
for i in self.items:
if (self.items[i].changed == True):
self.util.set_setting("keyfile", self.keyfile_items, self.items[i].path, "name", self.items[i].name, self.items[i].name_original, "generic", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_items, self.items[i].path, "icon", self.items[i].icon, self.items[i].icon_original, "generic", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_items, self.items[i].path, "comment", self.items[i].comment, self.items[i].comment_original, "generic", self.trigger_save_settings_file)
self.util.set_setting("keyfile", self.keyfile_items, self.items[i].path, "activate", self.items[i].activate, self.items[i].activate_original, "boolean", self.trigger_save_settings_file)
if (self.trigger_save_settings_file == True):
self.util.save_object(self.keyfile_settings, os.path.join("lx-control-center", "items.conf"))
self.trigger_save_settings_file = False
def module_active(self,item):
logging.info("Base.module_active: enter function")
self.module_activated = item
# UI functions
def generate_view(self):
logging.info("Base.generate_view: enter function")
self.items_visible_generate()
self.items_visible_by_categories_generate()
self.items_by_categories_generate()
self.icon_view_columns_generate()
def build_generic_icon_view(self, type_view):
""" Re-implement me on a toolkit backend
"""
pass
def build_icon_view(self):
logging.info("Base.build_icon_view: enter function")
self.clean_main_view()
# Generate the view again, to take the modifications of edit_view
self.generate_view()
self.build_generic_icon_view("visible")
def build_edit_view(self):
logging.info("Base.build_edit_view: enter function")
self.clean_main_view()
# Update items for search filter
self.items_by_categories_generate()
self.build_generic_icon_view("all")
def filter_item_by_search(self, item):
logging.info("Base.filter_item_by_search: enter function")
match = False
python_version = sys.version_info
if (python_version[0] == 2):
if self.search_string is None:
logging.debug("Base.filter_item_by_search: search is None")
search = u""
else:
logging.debug("Base.filter_item_by_search: search is not None")
search = self.search_string.encode()
else:
search = self.search_string
if (self.search_string == None):
if (python_version[0] != 2):
logging.debug("Base.filter_item_by_search, no search")
match = True
elif (search in item.name.lower()):
if (python_version[0] != 2):
logging.debug("Base.filter_item_by_search, search %s in name: match for %s with %s" % (search, item.path, item.name))
match = True
elif (search in item.comment.lower()):
if (python_version[0] != 2):
logging.debug("Base.filter_item_by_search, search %s in comment: match for %s with %s" % (search, item.path, item.comment))
match = True
else:
math = False
return match
def items_visible_generate(self):
logging.info("Base.items_visible_generate: enter function")
self.items_visible = []
for i in self.items:
if (self.items[i].activate == True):
if (self.filter_item_by_search(self.items[i]) == True):
logging.debug("items_visible_generate, append %s in items_visible_generate" % self.items[i].path)
self.items_visible.append(self.items[i])
def items_visible_by_categories_generate(self):
logging.info("Base.items_visible_by_categories_generate: enter function")
self.items_visible_by_categories = {}
non_order_dict = {}
for i in self.items_visible:
if (i.category not in non_order_dict):
empty_list = []
non_order_dict[i.category] = empty_list
non_order_dict[i.category].append(i)
self.items_visible_by_categories = collections.OrderedDict(sorted(non_order_dict.items()))
def items_by_categories_generate(self):
# TODO Factorise with items_visble_by_categories_generate
logging.info("Base.items_by_categories_generate: enter function")
self.items_by_categories = {}
non_order_dict = {}
for i in self.items:
if (self.filter_item_by_search(self.items[i]) == True):
if (self.items[i].category not in non_order_dict):
empty_list = []
non_order_dict[self.items[i].category] = empty_list
non_order_dict[self.items[i].category].append(self.items[i])
self.items_by_categories = collections.OrderedDict(sorted(non_order_dict.items()))
#TODO Sorting items inside categories
def icon_view_columns_generate(self):
logging.info("Base.icon_view_columns_generate: enter function")
# TODO use iconview item size (or any way to have the size of the item instead of the size of the icon)
logging.debug("icon_view_columns_generate: self.window_size_w : %s" % self.window_size_w)
logging.debug("icon_view_columns_generate: self.icon_view_icons_size : %s" % self.icon_view_icons_size)
blank_pixels = 10
max_nbr_col_win = 0
max_nbr_col_categories = 0
max_nbr_col_win = self.window_size_w // ((4 * self.icon_view_icons_size) + (2 * blank_pixels))
logging.debug("icon_view_columns_generate: max_nbr_col_win : %s" % max_nbr_col_win)
if (self.items_visible == []):
max_nbr_col_categories = 0
max_categories = 0
logging.warning("icon_view_columns_generate: no icons visible")
else:
max_categories = max(self.items_visible_by_categories.keys(), key=(lambda k: len(self.items_visible_by_categories[k])))
max_nbr_col_categories = len(self.items_visible_by_categories[max_categories])
logging.debug("icon_view_columns_generate: max_nbr_col_categories : %s" % max_nbr_col_categories)
if (max_nbr_col_categories >= max_nbr_col_win):
self.icon_view_columns = max_nbr_col_win
else:
self.icon_view_columns = max_nbr_col_categories
def on_icons_mode_menu_click(self, widget, data=None):
logging.info("Base.on_icons_mode_menu_click: Clicked")
self.mode = "main-UI"
self.load_settings()
self.triage_items()
self.generate_view()
self.draw_ui()
def on_edit_mode_menu_click(self, widget, data=None):
logging.info("Base.on_edit_mode_menu_click: Clicked")
self.mode = "edit-UI"
self.load_settings()
self.triage_items()
self.generate_view()
self.draw_ui()
def on_pref_mode_menu_click(self, widget, data=None):
logging.info("Base.on_pref_mode_menu_click: Clicked")
self.mode = "pref-UI"
self.load_settings()
self.triage_items()
self.generate_view()
self.draw_ui()
def build_module_view(self):
logging.info("Base.build_module_view: enter function")
self.clean_main_view()
self.module_class = self.module_activated.module_spec.LXCC_Module(self.toolkit)
self.activate_module_view()
def on_item_activated_common(self, path):
logging.info("Base.on_item_activated_common: enter function")
item_to_launch = self.items[path]
if (self.items[path].type == "module"):
self.mode = "module-UI"
self.module_active(self.items[path])
self.items[path].launch()
self.draw_ui()
else:
self.items[path].launch()
def draw_ui(self):
logging.info("Base.draw_ui: enter function")
pass
def on_resize_common(self, w, h):
logging.info("Base.on_resize_common: enter function")
if (self.mode == "main-UI"):
self.on_resize_function(w, h)
elif (self.mode == "edit-UI"):
self.on_resize_function(w, h)
def on_resize_function(self, w, h):
logging.info("Base.on_resize: resize activated")
self.window_size_w = w
self.window_size_h = h
tmp_icons_col = self.icon_view_columns
self.icon_view_columns_generate()
if (self.icon_view_columns != tmp_icons_col):
self.draw_ui()
def set_standalone(self):
logging.info("Base.set_standalone: enter function")
logging.debug("set_standalone: value of standalone_module: %s" % self.standalone_module)
if (self.standalone_module != None):
self.mode = "module-UI"
for i in self.items:
if (self.items[i].filename == self.standalone_module + '.desktop'):
if (self.toolkit in self.items[i].module_toolkits):
self.on_item_activated_common(i)
return True
else:
logging.error("Module %s is not compatible with current toolkit %s." % (self.standalone_module, self.toolkit))
return False
else:
return True
def print_debug(self):
""" Prints variables and other useful items for debug purpose"""
logging.debug("Printing variables")
logging.debug("self.keyword_categories_settings_list : %s" % self.keyword_categories_settings_list)
logging.debug("self.applications_path : %s" % self.applications_path)
logging.debug("self.modules_path : %s" % self.modules_path)
logging.debug("self.applications_support: %s" % self.applications_support)
logging.debug("self.modules_support: %s" % self.modules_support)
logging.debug("self.modules_experimental_support: %s" % self.modules_experimental_support)
logging.debug("self.categories_triaged: %s" % self.categories_triaged)
logging.debug("self.categories_keys : %s" % self.categories_keys)
logging.debug("self.desktop_environments : %s" % self.desktop_environments)
logging.debug("Print items")
for i in self.items:
logging.debug("Item name : %s" % self.items[i].name)
logging.debug("Item filename : %s" % self.items[i].filename)
logging.debug("Item path : %s" % self.items[i].path)
logging.debug("Item category : %s" % self.items[i].category)
logging.debug("Item icon : %s" % self.items[i].icon)
logging.debug("Item only_show_in : %s" % self.items[i].only_show_in)
logging.debug("Item not_show_in : %s" % self.items[i].not_show_in)
logging.debug("Item execute : %s" % self.items[i].execute_command)
logging.debug("Item activate : %s" % self.items[i].activate)
logging.debug("Item changed : %s" % self.items[i].changed)
logging.debug("Item check : %s" % self.items[i].check)
logging.debug("Item deactivation reasons : %s" % self.items[i].deactivate_reasons)
logging.debug("Item module_replace_application : %s" % self.items[i].module_replace_application)
logging.debug("Item module_toolkits : %s" % self.items[i].module_toolkits)
logging.debug("Item module_experimental : %s" % self.items[i].module_experimental)
logging.debug("=================")
class Setting():
def __init__(self, runtime):
logging.info("Setting.__init__: enter function")
self.util = Utils()
self.runtime = runtime
self.name = None
self.setting_type = "string"
self.available_values = {}
# LXSesion file: Format .ini file: ["lxsession", support, group, key]
self.lxsession_file_setting = ["lxsession_file", False, None, None]
# LXSession Dbus: Format Dbus: ["lxsession", support, Method, key1, key2]
self.lxsession_dbus_setting = [
"lxsession_dbus", False, None, None, None
]
# Cinnamon Setting: Format GSettings [group, key]
self.cinnamon_setting = ["cinnamon_settings", False, None, None]
# Gnome Setting: Format GSettings [group, key]
self.gnome_setting = ["gnome_settings", False, None, None]
# Mate Setting: Format GSettings [group, key]
self.mate_setting = ["mate_settings", False, None, None]
# LXQt Setting: Format GSettings [group, key]
self.lxqt_setting = ["lxqt_settings", False, None, None]
# GTK3 Setting: Format .ini [group, key]
self.gtk3_setting = ["gtk3_settings", False, None, None]
# Openbox Setting: Format xml [support, Tag1, Tag2]
self.openbox_setting = ["openbox_settings", False, None, None]
# LX Control Center: Format .ini file ["lx_control_center_setting", support, group, key]
self.lx_control_center_setting = [
"lx_control_center_setting", False, None, None
]
#List of settings
self.settings_list = [
self.lxsession_file_setting, self.lxsession_dbus_setting,
self.cinnamon_setting, self.gnome_setting, self.mate_setting,
self.lxqt_setting, self.gtk3_setting, self.openbox_setting,
self.lx_control_center_setting
]
self.support_list = []
def get(self):
logging.info("Setting.get: enter function")
return_value = None
# TODO Break when we found a setting ?
for setting in self.support_list:
# Check if the setting is handle
if (setting[1] == True):
if (setting[0] == "lx_control_center_setting"):
return_value = self.util.get_setting(
"keyfile",
self.runtime.support["lx_control_center_setting"][3],
self.lx_control_center_setting[2],
self.lx_control_center_setting[3], None,
self.setting_type)
return_value = self.transcode_values(
setting[0], return_value)
elif (setting[0] == "lxsession_file"):
return_value = self.util.get_setting(
"keyfile", self.runtime.support["lxsession_file"][3],
self.lxsession_file_setting[2],
self.lxsession_file_setting[3], None,
self.setting_type)
return_value = self.transcode_values(
setting[0], return_value)
elif (setting[0] == "lxsession_dbus"):
#TODO
#support.lxsession_dbus_runtime.SessionSet(key1,key2)
logging.warning("lxsession_dbus not supported")
elif (setting[0] == "cinnamon_settings"):
return_value = self.util.get_setting(
"gsetting", None, self.cinnamon_setting[2],
self.cinnamon_setting[3], None, self.setting_type)
return_value = self.transcode_values(
setting[0], return_value)
elif (setting[0] == "gnome_settings"):
return_value = self.util.get_setting(
"gsetting", None, self.gnome_setting[2],
self.gnome_setting[3], None, self.setting_type)
return_value = self.transcode_values(
setting[0], return_value)
elif (setting[0] == "mate_settings"):
return_value = self.util.get_setting(
"gsetting", None, self.mate_setting[2],
self.mate_setting[3], None, self.setting_type)
return_value = self.transcode_values(
setting[0], return_value)
elif (setting[0] == "gtk3_settings"):
return_value = self.util.get_setting(
"keyfile", self.runtime.support["gtk3_settings"][3],
self.gtk3_setting[2], self.gtk3_setting[3], None,
self.setting_type)
return_value = self.transcode_values(
setting[0], return_value)
elif (setting[0] == "lxqt_settings"):
return_value = self.util.get_setting(
"keyfile", self.runtime.support["lxqt_settings"][3],
self.lxqt_setting[2], self.lxqt_setting[3], None,
self.setting_type)
return_value = self.transcode_values(
setting[0], return_value)
elif (setting[0] == "openbox_settings"):
return_value = self.util.get_setting(
"xml", self.runtime.support["openbox_settings"][3],
self.openbox_setting[2], self.openbox_setting[3], None,
self.setting_type)
return_value = self.transcode_values(
setting[0], return_value)
else:
logging.warning("%s not supported for %s" %
(setting[0], self.name))
if (return_value is None and self.default_value is not None):
return_value = self.default_value
return return_value
def set(self, value):
logging.info("Setting.set: enter function")
current_value = self.get()
for setting in self.support_list:
# Check if the setting is handle
if (setting[1] == True):
if (setting[0] == "lx_control_center_setting"):
trigger_save = self.util.set_setting(
"keyfile",
self.runtime.support["lx_control_center_setting"][3],
self.lx_control_center_setting[2],
self.lx_control_center_setting[3],
self.transcode_values(setting[0], value),
self.default_value, self.setting_type)
if (trigger_save == True):
self.util.save_object(
"keyfile",
self.runtime.support["lx_control_center_setting"]
[3],
self.runtime.support["lx_control_center_setting"]
[4])
elif (setting[0] == "lxsession_file"):
trigger_save = self.util.set_setting(
"keyfile", self.runtime.support["lxsession_file"][3],
self.lxsession_file_setting[2],
self.lxsession_file_setting[3],
self.transcode_values(setting[0], value),
current_value, self.setting_type)
if (trigger_save == True):
self.util.save_object(
"keyfile",
self.runtime.support["lxsession_file"][3],
self.runtime.support["lxsession_file"][4])
elif (setting[0] == "lxsession_dbus"):
#TODO
#support.lxsession_dbus_runtime.SessionSet(key1,key2)
logging.warning("lxsession_dbus not supported")
elif (setting[0] == "cinnamon_settings"):
self.util.set_setting(
"gsetting", None, self.cinnamon_setting[2],
self.cinnamon_setting[3],
self.transcode_values(setting[0], value),
current_value, self.setting_type)
elif (setting[0] == "gnome_settings"):
self.util.set_setting(
"gsetting", None, self.gnome_setting[2],
self.gnome_setting[3],
self.transcode_values(setting[0], value),
current_value, self.setting_type)
elif (setting[0] == "mate_settings"):
self.util.set_setting(
"gsetting", None, self.mate_setting[2],
self.mate_setting[3],
self.transcode_values(setting[0], value),
current_value, self.setting_type)
elif (setting[0] == "gtk3_settings"):
trigger_save = self.util.set_setting(
"keyfile", self.runtime.support["gtk3_settings"][3],
self.gtk3_setting[2], self.gtk3_setting[3],
self.transcode_values(setting[0], value),
current_value, self.setting_type)
if (trigger_save == True):
self.util.save_object(
"keyfile",
self.runtime.support["gtk3_settings"][3],
self.runtime.support["gtk3_settings"][4])
elif (setting[0] == "lxqt_settings"):
trigger_save = self.util.set_setting(
"keyfile", self.runtime.support["lxqt_settings"][3],
self.lxqt_setting[2], self.lxqt_setting[3],
self.transcode_values(setting[0], value),
current_value, self.setting_type)
if (trigger_save == True):
self.util.save_object(
"keyfile",
self.runtime.support["lxqt_settings"][3],
self.runtime.support["lxqt_settings"][4])
elif (setting[0] == "openbox_settings"):
trigger_save = self.util.set_setting(
"xml", self.runtime.support["openbox_settings"][3],
self.openbox_setting[2], self.openbox_setting[3],
self.transcode_values(setting[0], value),
current_value, self.setting_type)
if (trigger_save == True):
self.util.save_object(
"xml", self.runtime.support["openbox_settings"][3],
self.runtime.support["openbox_settings"][4])
self.util.launch_command("openbox --reconfigure")
else:
logging.warning("%s not supported for %s" %
(setting[0], self.name))
self.set_after_hooks(value)
def set_settings_support(self):
logging.info("Setting.set_settings_support: enter function")
if (self.lxsession_file_setting[1] == True):
if (self.runtime.support["lxsession_file"][2] == True):
self.support_list.append(self.lxsession_file_setting)
if (self.lxsession_dbus_setting[1] == True):
if (self.runtime.support["lxsession_dbus"][2] == True):
self.support_list.append(self.lxsession_dbus_setting)
if (self.cinnamon_setting[1] == True):
if (self.runtime.support["cinnamon_settings"][2] == True):
self.support_list.append(self.cinnamon_setting)
if (self.gnome_setting[1] == True):
if (self.runtime.support["gnome_settings"][2] == True):
self.support_list.append(self.gnome_setting)
if (self.mate_setting[1] == True):
if (self.runtime.support["mate_settings"][2] == True):
self.support_list.append(self.mate_setting)
if (self.gtk3_setting[1] == True):
if (self.runtime.support["gtk3_settings"][2] == True):
self.support_list.append(self.gtk3_setting)
if (self.lxqt_setting[1] == True):
if (self.runtime.support["lxqt_settings"][2] == True):
self.support_list.append(self.lxqt_setting)
if (self.openbox_setting[1] == True):
if (self.runtime.support["openbox_settings"][2] == True):
self.support_list.append(self.openbox_setting)
if (self.lx_control_center_setting[1] == True):
if (self.runtime.support["lx_control_center_setting"][2] == True):
self.support_list.append(self.lx_control_center_setting)
def update_list(self, setting, arg_0, arg_1, arg_2, arg_3):
setting[0] = arg_0
setting[1] = arg_1
setting[2] = arg_2
setting[3] = arg_3
def set_after_hooks(self, value):
""" Function to launch after set function """
pass
def transcode_values(self, setting, value):
return value
class Item():
def __init__(self, categories_array):
self.util = Utils()
# Item structure
self.path = ""
self.filename = ""
self.version_config = 0.1
self.name = ""
self.name_original = ""
self.comment = ""
self.comment_original = ""
self.category = ""
self.categories_list = []
self.categories_array = categories_array
self.category_other = False
self.icon = ""
# Icon type : themed, fix or fallback
self.icon_type = ""
self.icon_original = ""
self.try_exec = ""
self.only_show_in = []
self.not_show_in = []
self.activate = True
self.activate_original = True
self.deactivate_reasons = []
self.changed = False
self.check = True
# module or application
self.type = ""
# application specific
self.execute_command =""
# module specific
self.module_replace_application = []
self.module_depends = []
self.module_version = 0.0
self.module_api_version = 0.0
self.module_spec = None
self.module_toolkits = []
self.module_running_toolkit = None
self.module_experimental = False
def load_common_app_module_from_path(self,path,keyfile):
self.path = path
self.filename = os.path.basename(path)
self.name = keyfile.getName()
self.comment = keyfile.getComment()
self.categories_list = keyfile.getCategories()
self.icon = keyfile.getIcon()
self.only_show_in = keyfile.getOnlyShowIn()
self.not_show_in = keyfile.getNotShowIn()
self.execute_command = keyfile.getExec()
self.try_exec = keyfile.getTryExec()
self.name_original = self.name
self.comment_original = self.comment
self.icon_original = self.icon
self.category = None
self.version_config = 0.1
# Check if there are the minimum informations
self.check_common()
self.define_category_from_list()
self.define_icon_type()
def load_application_from_path(self, path):
keyfile = self.util.load_object("xdg",path)
self.load_common_app_module_from_path(path, keyfile)
self.type = "application"
def load_module_from_path(self, path, toolkit):
keyfile = self.util.load_object("xdg",path)
self.load_common_app_module_from_path(path, keyfile)
self.type = "module"
self.module_replace_application = keyfile.get("X-LX-Control-Center-Application-Replaces", group="Desktop Entry", type="string", list=True)
self.module_depends = keyfile.get("X-LX-Control-Center-Depends", group="Desktop Entry", type="string", list=True)
self.module_version = keyfile.get("X-LX-Control-Center-Version", group="Desktop Entry", type="numeric")
self.module_api_version = keyfile.get("X-LX-Control-Center-API-Version", group="Desktop Entry", type="numeric")
self.module_toolkits = keyfile.get("X-LX-Control-Center-Toolkits", group="Desktop Entry", type="list")
self.module_experimental = keyfile.get("X-LX-Control-Center-Experimental", group="Desktop Entry", type="boolean")
self.check_module()
self.module_running_toolkit = toolkit
def define_category_from_list(self):
logging.debug("define_category_from_list: enter function with categories_list for %s = %s" % (self.path, self.categories_list))
logging.debug("define_category_from_list: enter function with categories_array for %s = %s" % (self.path, self.categories_array))
tmp_dict = {}
keys = self.categories_array.keys()
for item in self.categories_list:
if (item in keys):
if (item in tmp_dict.keys()):
tmp_dict[item] = tmp_dict[item] + 1
else:
tmp_dict[item] = 1
if (len(tmp_dict) == 0):
self.category = _("Other")
self.category_other = True
else:
max_category = max(tmp_dict.keys(), key=(lambda k: tmp_dict[k]))
self.category = self.categories_array[max_category]
def define_icon_type(self):
if (len(self.icon) > 0):
if (self.icon[0] == "/"):
self.icon_type = "fix"
else:
self.icon_type = "themed"
else:
self.icon_type = "fallback"
def check_common(self):
if (self.name == None):
self.check = False
if (self.categories_list == None):
self.check = False
if (self.execute_command == None):
self.check = False
def check_module(self):
if (self.module_api_version <= 0.0):
self.check = False
logging.warning("check_module: Module name %s, on %s is outdated with current version of lx-control-center. Please contact the module author" % (self.name, self.path))
if (self.module_version == 0.0):
self.check = False
def add_deactivate_reason(self, reason):
if (reason not in self.deactivate_reasons):
self.deactivate_reasons.append(reason)
def launch(self):
logging.info("launch: trying execute : %s" % self.execute_command)
if (self.type == "application"):
self.util.launch_command(self.execute_command)
elif (self.type == "module"):
python_version = sys.version_info
module_path = os.path.join(os.path.dirname(self.path),self.execute_command)
if (python_version[0] == 2):
import imp
self.module_spec = imp.load_source('lxcc_module', module_path)
elif (python_version[0] == 3):
if(python_version[1] < 3.5):
from importlib.machinery import SourceFileLoader
self.module_spec = SourceFileLoader("lxcc_module", module_path).load_module()
self.module_spec.init(self.module_running_toolkit)
else:
import importlib.util
logging.debug("launch: trying to import : %s" % module_path)
spec = importlib.util.spec_from_file_location("lxcc_module", module_path)
self.module_spec = importlib.util.module_from_spec(spec)
spec.loader.exec_module(self.module_spec)
self.module_spec.init(self.module_running_toolkit)