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)