#!/usr/bin/env python3 # # by Kendall Weaver # for Peppermint OS # # Peppermint Control Center is a Python/GTK+3 GUI wrapper to handle a # number of desktop configuration options from a number of different # applications/scripts and put them all in one place. # ############# ### To Do ### ############# # # 1. Improve keyboard shortcut support. # # 2. Add gettext support and begin working on translations. # # 3. Push to github. # import os import sys import subprocess import gi gi.require_version('Gtk', '3.0') from gi.repository import Gtk import xml.etree.ElementTree as ET if not os.path.exists(os.path.expanduser("~/.config/peppermint-control-center/")): try: os.system("mkdir -p ~/.config/peppermint-control-center") except: print("ERROR: Configuration directory does not exist and could not be created.") sys.exit(1) if not os.path.exists(os.path.expanduser("~/.config/peppermint-control-center/pointer")): try: os.system("echo '#!/bin/bash\n#Autogenerated script - Do not edit\nxset m 2 2\nxmodmap -e \"pointer = 1 2 3\"\nsynclient TouchPadOff=0\nsynclient VertEdgeScroll=0\nsynclient HorizEdgeScroll=0\nTapButton1=1 TapButton2=3\nsynclient VertTwoFingerScroll=1\nsynclient HorizTwoFingerScroll=0' >> ~/.config/peppermint-control-center/pointer") os.system("chmod +x ~/.config/peppermint-control-center/pointer") except: print("ERROR: pointer file does not exist and could not be generated.") sys.exit(1) #disable keyboard file generation and setting# if not os.path.exists(os.path.expanduser("~/.config/peppermint-control-center/keyboard")): #disable keyboard file generation and setting# try: #disable keyboard file generation and setting# os.system("echo '#!/bin/bash\n#Autogenerated script - Do not edit\nxset r rate 500 20' >> ~/.config/peppermint-control-center/keyboard") #disable keyboard file generation and setting# os.system("chmod +x ~/.config/peppermint-control-center/keyboard") #disable keyboard file generation and setting# except: #disable keyboard file generation and setting# print("ERROR: keyboard file does not exist and could not be generated.") #disable keyboard file generation and setting# sys.exit(1) if not os.path.exists(os.path.expanduser("~/.config/xfce4/xfconf/xfce-perchannel-xml/xfce4-keyboard-shortcuts.xml")): try: os.system("cp /usr/share/peppermint/peppermint-control-center/xfce4-keyboard-shortcuts.xml ~/.config/xfce4/xfconf/xfce-perchannel-xml/xfce4-keyboard-shortcuts.xml") except: print("ERROR: xfce4-keyboard-shortcuts.xml does not exist and could not be generated.") sys.exit(1) if not os.path.exists(os.path.expanduser("~/.config/peppermint-control-center/xbindkeys.conf")): try: os.system("cp /usr/share/peppermint/peppermint-control-center/xbindkeys.conf ~/.config/peppermint-control-center/xbindkeys.conf") except: print("ERROR: xbindkeys.conf does not exist and could not be generated.") sys.exit(1) if not os.path.exists(os.path.expanduser("~/.config/xfce4/xfconf/xfce-perchannel-xml/xfwm4.xml")): try: os.system("cp /usr/share/peppermint/peppermint-control-center/xfwm4.xml ~/.config/xfce4/xfce-perchannel-xml/xfwm4.xml") except: print("ERROR: xfwm4.xml does not exist and could not be generated.") sys.exit(1) # Open, read, and close the configuration files. try: pntr_file = open(os.path.expanduser("~/.config/peppermint-control-center/pointer"), 'r') #disable keyboard file generation and setting# keys_file = open(os.path.expanduser("~/.config/peppermint-control-center/keyboard"), 'r') xfks_file = open(os.path.expanduser("~/.config/xfce4/xfconf/xfce-perchannel-xml/xfce4-keyboard-shortcuts.xml"), 'r') bind_file = open(os.path.expanduser("~/.config/peppermint-control-center/xbindkeys.conf"), 'r') xfwm_file = open(os.path.expanduser("~/.config/xfce4/xfconf/xfce-perchannel-xml/xfwm4.xml"), 'r') except: print("ERROR: Could not open the necessary configuration files.") sys.exit(1) try: pntr_data = pntr_file.readlines() #disable keyboard file generation and setting# keys_data = keys_file.readlines() xfks_data = xfks_file.readlines() bind_data = bind_file.readlines() xfwm_data = xfwm_file.readlines() except: print("ERROR: One or more configuration files is corrupt.") sys.exit(1) pntr_file.close() #disable keyboard file generation and setting# keys_file.close() xfks_file.close() bind_file.close() xfwm_file.close() ########################################################### ### Generic methods for getting/setting boolean values. ### ########################################################### def value_from_xml(a): for line in xfwm_data: if a in line: b = line.split() c = b[3] d = c.replace(" ", "_") e = d.replace('"', ' ') f = e.split() return f[1] def get_generic(a): if value_from_xml('name="{0}"'.format(a)) == "true": return True return False def set_generic(widget, prop): if widget.get_active(): os.system("xfconf-query -c xfwm4 -p /general/{0} -s true".format(prop)) else: os.system("xfconf-query -c xfwm4 -p /general/{0} -s false".format(prop)) def set_compositing(widget, prop): if widget.get_active(): os.system("killall compton ; rm -f /$HOME/.config/autostart/compton.desktop ;\ xfconf-query -c xfwm4 -p /general/{0} -s true".format(prop)) else: os.system("cp -f /usr/share/peppermint/peppermint-control-center/compton.desktop /$HOME/.config/autostart/ ;\ xfconf-query -c xfwm4 -p /general/{0} -s false ; compton -b".format(prop)) ########################################## ### Methods for 'Window Manager' page. ### ########################################## # xfwm4 theme methods. def get_theme(): return value_from_xml('name="theme"') def theme_list(): themelist = [] syslist = os.listdir("/usr/share/themes") for item in syslist: if os.path.exists("/usr/share/themes/{0}/xfwm4/themerc".format(item)): themelist.append(item) if os.path.exists(os.path.expanduser("~/.themes/")): usrlist = os.listdir(os.path.expanduser("~/.themes")) for item in usrlist: if os.path.exists(os.path.expanduser("~/.themes/{0}/xfwm4/themerc".format(item))): themelist.append(item) if os.path.exists(os.path.expanduser("/usr/local/share/themes/")): usrlist = os.listdir(os.path.expanduser("/usr/local/share/themes")) for item in usrlist: if os.path.exists(os.path.expanduser("/usr/local/share/themes/{0}/xfwm4/themerc".format(item))): themelist.append(item) return sorted(themelist) def theme_index(): try: return theme_list().index(get_theme()) except ValueError as e: print("DEBUG: Caught exception '{0}', using 'Xfwm4_Fallback' as default.".format(e)) return theme_list().index('Xfwm4_Fallback') def set_theme(widget): os.system("xfconf-query -c xfwm4 -p /general/theme -s {0}".format(theme_box.get_active_text())) # Title font methods. def get_title_font(): for line in xfwm_data: if 'name="title_font"' in line: a = line.replace(' ', '') return b.replace("\n", "") def set_title_font(widget): font_name = widget.get_font_name() os.system('xfconf-query -c xfwm4 -p /general/title_font -s "{0}"'.format(font_name)) widget.set_title(font_name) # Title alignment methods. def get_title_alignment(): return value_from_xml('name="title_alignment"') def alignment_index(): indices = { 'left': 0, 'center': 1, 'right': 2 } a = get_title_alignment() try: return indices[a] except KeyError: print("ERROR: Alignment index out of range.") sys.exit(1) def set_title_alignment(widget): indices = ['left', 'center', 'right'] a = alignment_box.get_active_text() if a.lower() in indices: os.system("xfconf-query -c xfwm4 -p /general/title_alignment -s {0}".format(a.lower())) else: print("ERROR: Alignment index out of range.") sys.exit(1) # Workspace count methods: def get_workspace_count(): return int(value_from_xml('name="workspace_count"')) def set_workspace_count(button): os.system("xfconf-query -c xfwm4 -p /general/workspace_count -s {0}".format(str(int(button.get_value())))) # Click to focus methods. def get_click_to_focus(): return value_from_xml('name="click_to_focus"') def set_click_to_focus(button, value): if button.get_active(): os.system("xfconf-query -c xfwm4 -p /general/click_to_focus -s {0}".format(value)) if value == "false": focus_delay_box.set_sensitive(True) if value == "true": focus_delay_box.set_sensitive(False) # Focus Delay methods. def get_focus_delay(): return int(value_from_xml('name="focus_delay"')) def set_focus_delay(widget): os.system("xfconf-query -c xfwm4 -p /general/focus_delay -s {0}".format(str(int(focus_delay.get_value())))) # New window focus methods. def get_focus_new(): return get_generic("focus_new") def set_focus_new(widget): set_generic(widget, "focus_new") # Raise on focus methods. def get_raise_on_focus(): return get_generic("raise_on_focus") def set_raise_on_focus(widget): set_generic(widget, "raise_on_focus") # Methods for focus raise delay. def get_raise_delay(): return int(value_from_xml('name="raise_delay"')) def set_raise_delay(widget): os.system("xfconf-query -c xfwm4 -p /general/raise_delay -s {0}".format(str(int(raise_delay.get_value())))) # Raise on click methods. def get_raise_on_click(): return get_generic("raise_on_click") def set_raise_on_click(widget): set_generic(widget, "raise_on_click") # Window snapping methods. def get_snap_to_border(): return get_generic("snap_to_border") def set_snap_to_border(widget): set_generic(widget, "snap_to_border") def get_snap_to_windows(): return get_generic("snap_to_windows") def set_snap_to_windows(widget): set_generic(widget, "snap_to_windows") def get_snap_width(): return int(value_from_xml('name="snap_width"')) def set_snap_width(widget): os.system("xfconf-query -c xfwm4 -p /general/snap_width -s {0}".format(str(int(snap_width.get_value())))) # Workspace wrapping methods. def get_wrap_workspaces(): return get_generic("wrap_workspaces") def set_wrap_workspaces(widget): set_generic(widget, "wrap_workspaces") def get_wrap_windows(): return get_generic("wrap_windows") def set_wrap_windows(widget): set_generic(widget, "wrap_windows") def get_wrap_resistance(): return int(value_from_xml('name="wrap_resistance"')) def set_wrap_resistance(widget): os.system("xfconf-query -c xfwm4 -p /general/wrap_resistance -s {0}".format(str(int(wrap_resistance.get_value())))) # Methods for hiding window content during transformations. def get_box_move(): return get_generic("box_move") def set_box_move(widget): set_generic(widget, "box_move") def get_box_resize(): return get_generic("box_resize") def set_box_resize(widget): set_generic(widget, "box_resize") # Title bar double click methods. def get_double_click_action(): return value_from_xml('name="double_click_action"') def set_double_click_action(button): a = double_click_action.get_active_text() if a == "Shade window": b = "shade" elif a == "Hide window": b = "hide" elif a == "Maximize window": b = "maximize" elif a == "Fill window": b = "fill" elif a == "Nothing": b = "none" else: print("ERROR: Double click action index out of range.") sys.exit(1) os.system("xfconf-query -c xfwm4 -p /general/double_click_action -s {0}".format(b)) def double_click_action_index(): indices = { 'shade': 0, 'hide': 1, 'maximize': 2, 'fill': 3, 'none': 4 } a = get_double_click_action() try: return indices[a] except KeyError: print("ERROR: Double click action index out of range.") sys.exit(1) ########################################### ### Methods for 'Pointer Options' page. ### ########################################### def get_acceleration(): return int(pntr_data[2].split()[2]) def get_threshold(): return int(pntr_data[2].split()[3]) def get_lefthanded(): return pntr_data[3][22] == "3" def get_touchenable(): return pntr_data[4][22] == "0" def get_taptoclick(): return pntr_data[7][21] == "1" def get_vertedge(): return pntr_data[5][25] == "1" def get_horizedge(): return pntr_data[6][26] == "1" def get_vtwofinger(): return pntr_data[8][30] == "1" def get_htwofinger(): return pntr_data[9][31] == "1" # 'Apply Pointer Options' button. def pntr_apply(widget): acceleration_value = str(int(acceleration.get_value())) threshold_value = str(int(threshold.get_value())) if lefthanded.get_active(): lefthanded_value = "3 2 1" else: lefthanded_value = "1 2 3" if touchenable.get_active(): touchenable_value = "0" else: touchenable_value = "1" if taptoclick.get_active(): taptoclick_value = "TapButton1=1 TapButton2=3" else: taptoclick_value = "TapButton1=0 TapButton2=0" if vertedge.get_active(): vertedge_value = "1" else: vertedge_value = "0" if horizedge.get_active(): horizedge_value = "1" else: horizedge_value = "0" if vtwofinger.get_active(): vtwofinger_value = "1" else: vtwofinger_value = "0" if htwofinger.get_active(): htwofinger_value = "1" else: htwofinger_value = "0" try: with open(os.path.expanduser("~/.config/peppermint-control-center/pointer"), 'w') as conf: conf.truncate() conf.write("#!/bin/bash\n") conf.write("#Autogenerated script - Do not edit\n") conf.write("xset m {0} {1}\n".format(acceleration_value, threshold_value)) conf.write('xmodmap -e "pointer = {0}"\n'.format(lefthanded_value)) conf.write("synclient TouchPadOff={0}\n".format(touchenable_value)) conf.write("synclient VertEdgeScroll={0}\n".format(vertedge_value)) conf.write("synclient HorizEdgeScroll={0}\n".format(horizedge_value)) conf.write("synclient {0}\n".format(taptoclick_value)) conf.write("synclient VertTwoFingerScroll={0}\n".format(vtwofinger_value)) conf.write("synclient HorizTwoFingerScroll={0}\n".format(htwofinger_value)) except: print("ERROR: Could not save new configuration.") sys.exit(1) try: os.system("ppmcc-load") except: print("ERROR: Could not load new configuration.") sys.exit(1) def get_delay(): return int(keys_data[2].split()[3]) def get_interval(): return int(keys_data[2].split()[4]) def lxkeymap(widget): os.system("lxkeymap &") #commented by mg# def layoutsetter(widget): #commented by mg# win = SetLayout() #commented by mg# win.show_all() #added by mg# def layoutsetter(widget): os.system("xfce4-keyboard-settings &") #end added by mg# #disable keyboard file generation and setting#def keys_apply(widget): #disable keyboard file generation and setting# delay_value = str(int(delay.get_value())) #disable keyboard file generation and setting# interval_value = str(int(interval.get_value())) #disable keyboard file generation and setting# #disable keyboard file generation and setting# try: #disable keyboard file generation and setting# with open(os.path.expanduser("~/.config/peppermint-control-center/keyboard"), 'w') as conf: #disable keyboard file generation and setting# conf.truncate() #disable keyboard file generation and setting# conf.write("#!/bin/bash\n") #disable keyboard file generation and setting# conf.write("#Autogenerated script - Do not edit\n") #disable keyboard file generation and setting# conf.write("xset r rate {0} {1}\n".format(delay_value, interval_value)) #disable keyboard file generation and setting# except: #disable keyboard file generation and setting# print("ERROR: Could not save new configuration.") #disable keyboard file generation and setting# sys.exit(1) try: os.system("ppmcc-load") except: print("ERROR: Could not load new configuration.") sys.exit(1) ############################################## ### Methods for 'Keyboard Shortcuts' page. ### ############################################## # Swap out encoded strings for human readable characters. def encodereplace(a): b = a.replace("<", "<") c = b.replace(">", ">") return c # Swap out human readable characters for encoded strings. def unencodereplace(a): b = a.replace("<", "<") c = b.replace(">", ">") return c # Format the xml data into a more human readable form. def xmlformat(a): spl = a.split() name = spl[3].replace('"', ' ').split() keys = spl[1].replace('"', ' ').split() disp = "{0} {1}".format(name[1], keys[1]) kpad = disp.replace("KP_", "") return encodereplace(kpad).replace("Primary", "Control") # Match the xbindkeys format to the xfce4 format. def bindformat(a): b = a.replace("Alt", "") c = b.replace("Mod4", "") d = c.replace("Control", "") e = d.replace("Shift", "") return e.replace("+", "") # Return the xfce4 format to native xbindkeys format. def unbindformat(a): b = a.replace("", "Alt + ") c = b.replace("", "Mod4 + ") d = c.replace("", "Control + ") e = d.replace("", "Shift + ") return e # Return a list of all valid shortcuts in xfce4-keyboard-shortcuts.xml. def get_xfce_shortcuts(): xfceline = [] for line in xfks_data: if 'type="string"' in line: try: xfceline.append(xmlformat(line)) except: continue return xfceline # This works as long as xbindkeys-config is not used and the user does # not edit the config file. We should launch xbindkeys in Peppermint # using a custom config file and this package should probably provide # xbindkeys-config in the debian/control file in order to prevent any # conflicts. def get_xbindkeys(): bindlist = [] bindtemp = "" bindline = [] for line in bind_data: if line[0] == "#" or line[0] == "\n": continue else: bindlist.append(line.replace("\n", "")) for line in bindlist: if line[0] == '"': bindtemp = line.replace('"', '') elif line[0] == " ": a = line.replace(" ", "") bindline.append(bindtemp + "\n" + bindformat(a)) else: continue return bindline def edit_xfce_shortcut(selection, path, column): global workspace workspace = "xfce" store = selection.get_model() global command command = store[path][0] global oldcommand oldcommand = store[path][1] treeiter = store.get_iter(path) shortcut = KeyboardShortcut(store, treeiter) shortcut.show_all() def edit_bind_shortcut(selection, path, column): global workspace workspace = "bind" store = selection.get_model() global command command = store[path][0] global oldcommand oldcommand = store[path][1] treeiter = store.get_iter(path) shortcut = KeyboardShortcut(store, treeiter) shortcut.show_all() def set_xfce_shortcut(command, shortcut): new0 = shortcut.replace("Control", "Primary") new1 = new0.replace("Space", "space") os.system('xfconf-query -c xfce4-keyboard-shortcuts -p "/xfwm4/custom/{0}" -r'.format(oldcommand)) os.system('xfconf-query -c xfce4-keyboard-shortcuts -p "/xfwm4/custom/{0}" -n -t string -s {1}'.format( new1, command)) ################################################################################################ ### To Do: This will require more formatting as it has a bazillion possible breaking points. ### ################################################################################################ def set_bind_shortcut(command, shortcut, store): bindlist = [] for item in store: if command in item[0] and oldcommand in item[1]: bindlist.append([item[0], shortcut]) continue bindlist.append([item[0], item[1]]) with open(os.path.expanduser("~/.config/peppermint-control-center/xbindkeys.conf"), 'w') as conf: conf.truncate() for line in bindlist: new0 = line[1] new1 = new0.replace("", "Control+") new2 = new1.replace("", "Alt+") new3 = new2.replace("", "Mod4+") new4 = new3.replace("", "Shift+") conf.write('"{0}"\n {1}\n\n'.format(line[0], new4)) os.system("killall xbindkeys") os.system("xbindkeys -f ~/.config/peppermint-control-center/xbindkeys.conf") def refresh_bind_shortcuts(): bindlist = [] for item in bindstore: bindlist.append([item[0], item[1]]) with open(os.path.expanduser("~/.config/peppermint-control-center/xbindkeys.conf"), 'w') as conf: conf.truncate() for line in bindlist: new0 = line[1] new1 = new0.replace("", "Control+") new2 = new1.replace("", "Alt+") new3 = new2.replace("", "Mod4+") new4 = new3.replace("", "Shift+") conf.write('"{0}"\n {1}\n\n'.format(line[0], new4)) os.system("killall xbindkeys") os.system("xbindkeys -f ~/.config/peppermint-control-center/xbindkeys.conf") def action_bind_new(widget, liststore): new = NewShortcut(liststore) new.show_all() def action_bind_restore(widget): action = "bind-restore" command = "cp -f /usr/share/peppermint/peppermint-control-center/xbindkeys.conf ~/.config/peppermint-control-center/xbindkeys.conf" confirm = AreYouSure(action, command) confirm.show_all() def action_xfce_restore(widget): action = "xfce-restore" command = "" confirm = AreYouSure(action, command) confirm.show_all() ########################################### ### Methods for 'Desktop Effects' page. ### ########################################### def get_use_compositing(): return get_generic("use_compositing") def set_use_compositing(widget): set_compositing(widget, "use_compositing") if widget.get_active() == True: effects_box.set_sensitive(True) elif widget.get_active() == False: effects_box.set_sensitive(False) # CheckButtons def get_unredirect_overlays(): return get_generic("unredirect_overlays") def set_unredirect_overlays(widget): set_generic(widget, "unredirect_overlays") def get_sync_to_vblank(): return get_generic("sync_to_vblank") def set_sync_to_vblank(widget): set_generic(widget, "sync_to_vblank") def get_show_popup_shadow(): return get_generic("show_popup_shadow") def set_show_popup_shadow(widget): set_generic(widget, "show_popup_shadow") def get_show_dock_shadow(): return get_generic("show_dock_shadow") def set_show_dock_shadow(widget): set_generic(widget, "show_dock_shadow") def get_show_frame_shadow(): return get_generic("show_frame_shadow") def set_show_frame_shadow(widget): set_generic(widget, "show_frame_shadow") # HScales def get_frame_opacity(): return int(value_from_xml('name="frame_opacity"')) def set_frame_opacity(widget): os.system("xfconf-query -c xfwm4 -p /general/frame_opacity -s {0}".format(str(int(widget.get_value())))) def get_inactive_opacity(): return int(value_from_xml('name="inactive_opacity"')) def set_inactive_opacity(widget): os.system("xfconf-query -c xfwm4 -p /general/inactive_opacity -s {0}".format(str(int(widget.get_value())))) def get_move_opacity(): return int(value_from_xml('name="move_opacity"')) def set_move_opacity(widget): os.system("xfconf-query -c xfwm4 -p /general/move_opacity -s {0}".format(str(int(widget.get_value())))) def get_resize_opacity(): return int(value_from_xml('name="resize_opacity"')) def set_resize_opacity(widget): os.system("xfconf-query -c xfwm4 -p /general/resize_opacity -s {0}".format(str(int(widget.get_value())))) def get_popup_opacity(): return int(value_from_xml('name="popup_opacity"')) def set_popup_opacity(widget): os.system("xfconf-query -c xfwm4 -p /general/popup_opacity -s {0}".format(str(int(widget.get_value())))) #################################### ### Methods for 'Advanced' page. ### #################################### # Window cycling def get_cycle_minimum(): return get_generic("cycle_minimum") def set_cycle_minimum(widget): set_generic(widget, "cycle_minimum") def get_cycle_hidden(): return get_generic("cycle_hidden") def set_cycle_hidden(widget): set_generic(widget, "cycle_hidden") def get_cycle_workspaces(): return get_generic("cycle_workspaces") def set_cycle_workspaces(widget): set_generic(widget, "cycle_workspaces") def get_cycle_preview(): return get_generic("cycle_preview") def set_cycle_preview(widget): set_generic(widget, "cycle_preview") def get_cycle_draw_frame(): return get_generic("cycle_draw_frame") def set_cycle_draw_frame(widget): set_generic(widget, "cycle_draw_frame") # Window focus def get_prevent_focus_stealing(): return get_generic("prevent_focus_stealing") def set_prevent_focus_stealing(widget): set_generic(widget, "prevent_focus_stealing") def get_focus_hint(): return get_generic("focus_hint") def set_focus_hint(widget): set_generic(widget, "focus_hint") def get_activate_action(): return value_from_xml('name="activate_action"') def set_activate_action(button, value): if button.get_active(): os.system("xfconf-query -c xfwm4 -p /general/activate_action -s {0}".format(value)) # Accessibility def get_raise_with_any_button(): return get_generic("raise_with_any_button") def set_raise_with_any_button(widget): set_generic(widget, "raise_with_any_button") def get_borderless_maximize(): return get_generic("borderless_maximize") def set_borderless_maximize(widget): set_generic(widget, "borderless_maximize") def get_restore_on_move(): return get_generic("restore_on_move") def set_restore_on_move(widget): set_generic(widget, "restore_on_move") if widget.get_active() == True: tile_on_move.set_sensitive(True) elif widget.get_active() == False: tile_on_move.set_sensitive(False) def get_tile_on_move(): return get_generic("tile_on_move") def set_tile_on_move(widget): set_generic(widget, "tile_on_move") def get_snap_resist(): return get_generic("snap_resist") def set_snap_resist(widget): set_generic(widget, "snap_resist") def get_urgent_blink(): return get_generic("urgent_blink") def set_urgent_blink(widget): set_generic(widget, "urgent_blink") if widget.get_active() == True: repeat_urgent_blink.set_sensitive(True) else: repeat_urgent_blink.set_sensitive(False) repeat_urgent_blink.set_active(False) set_repeat_urgent_blink_off() def get_repeat_urgent_blink(): return get_generic("repeat_urgent_blink") def set_repeat_urgent_blink(widget): set_generic(widget, "repeat_urgent_blink") def set_repeat_urgent_blink_off(): os.system("xfconf-query -c xfwm4 -p /general/repeat_urgent_blink -s false") def get_mousewheel_rollup(): return get_generic("mousewheel_rollup") def set_mousewheel_rollup(widget): set_generic(widget, "mousewheel_rollup") # Workspaces def get_scroll_workspaces(): return get_generic("scroll_workspaces") def set_scroll_workspaces(widget): set_generic(widget, "scroll_workspaces") def get_wrap_layout(): return get_generic("wrap_layout") def set_wrap_layout(widget): set_generic(widget, "wrap_layout") # Window placement def get_placement_ratio(): return int(value_from_xml("placement_ratio")) def set_placement_ratio(widget): os.system("xfconf-query -c xfwm4 -p /general/placement_ratio -s {0}".format(str(int(widget.get_value())))) def get_placement_mode(): return value_from_xml("placement_mode") def set_placement_mode(button, value): if button.get_active(): os.system("xfconf-query -c xfwm4 -p /general/placement_mode -s {0}".format(value)) # 'Are you sure?' window. class AreYouSure(Gtk.Window): def close_it(self, widget): self.close() def confirm(self, widget, action, command): if action == "bind-restore": os.system(command) os.system("killall xbindkeys") os.system("xbindkeys -f ~/.config/peppermint-control-center/xbindkeys.conf") bindview.set_model(None) bindstore.clear() get_bind = get_xbindkeys() for line in get_bind: a = line.split("\n") bindstore.append([a[0], a[1]]) bindview.set_model(bindstore) self.close() elif action == "xfce-restore": os.system('zenity --error --text "This feature has not yet been implemented."') elif action == "delete": bindstore.remove(command) refresh_bind_shortcuts() self.close() def __init__(self, action, command): Gtk.Window.__init__(self, title="Confirm") self.set_size_request(250, 120) self.set_icon_from_file("/usr/share/pixmaps/peppermint-control-center.png") label = Gtk.Label() label.set_markup("Are you sure you want to perform this action?") buttons = Gtk.HBox() void = Gtk.Label() no = Gtk.Button.new_from_stock(Gtk.STOCK_NO) no.connect("clicked", self.close_it) yes = Gtk.Button.new_from_stock(Gtk.STOCK_YES) yes.connect("clicked", self.confirm, action, command) buttons.pack_start(void, True, True, 0) buttons.pack_start(no, False, False, 10) buttons.pack_start(yes, False, False, 0) vbox = Gtk.VBox() vbox.pack_start(label, True, True, 0) vbox.pack_start(buttons, False, False, 10) hbox = Gtk.HBox() hbox.pack_start(vbox, True, True, 10) self.add(hbox) class SetLayout(Gtk.Window): def close_it(self, widget): self.close() def revert_it(self, widget, command): execute = "setxkbmap " + command os.system(execute) os.system('touch ~/.config/peppermint-control-center/keyboard_layout') os.system('chmod +x ~/.config/peppermint-control-center/keyboard_layout') os.system('echo "#!/bin/sh\n{0}" > ~/.config/peppermint-control-center/keyboard_layout'.format(execute)) def getlist(self): layoutfile = ET.parse("/usr/share/X11/xkb/rules/base.xml") root = layoutfile.getroot() layoutlist = [] for child in root.iter('layout'): name = "" sublist = [] for item in child.findall('configItem'): name = item.find('name').text command = name desc = item.find('description').text sublist.append([command, desc]) for variantList in child.findall('variantList'): for variant in variantList.findall('variant'): for item in variant.findall('configItem'): varname = item.find('name').text command = name + " " + varname vardesc = item.find('description').text sublist.append([command, vardesc]) layoutlist.append([name, sublist]) return sorted(layoutlist) def fill_variants(self, widget): variantstore.clear() layouts = self.getlist() select = layoutview.get_selection() model, treeiter = select.get_selected() for layout in layouts: if layout[0] == model[treeiter][0]: for variant in layout[1]: variantstore.append([variant[0], variant[1]]) x = 0 for obj in variantstore: if str(obj[0]) == cm: variantview.set_cursor(x) variantview.scroll_to_cell(x) x += 1 def set_layout(self, widget, var): try: select = variantview.get_selection() model, treeiter = select.get_selected() execute = "setxkbmap {0}".format(model[treeiter][0]) os.system(execute) os.system('touch ~/.config/peppermint-control-center/keyboard_layout') os.system('chmod +x ~/.config/peppermint-control-center/keyboard_layout') os.system('echo "#!/bin/sh\n{0}" > ~/.config/peppermint-control-center/keyboard_layout'.format(execute)) except: pass def get_current(self): command = "" cl = subprocess.Popen('setxkbmap -query | grep layout', shell=True, stdout=subprocess.PIPE) curlay = str(cl.stdout.read()) if "layout:" in curlay: cl1 = curlay.split() current_layout = cl1[1].replace("\\n'", "") command = command + current_layout cv = subprocess.Popen('setxkbmap -query | grep variant', shell=True, stdout=subprocess.PIPE) curvar = str(cv.stdout.read()) if "variant:" in curvar: cv1 = curvar.split() current_variant = cv1[1].replace("\\n'", "") command = "{0} {1}".format(command, current_variant) return current_layout, command def __init__(self): Gtk.Window.__init__(self, title="Select Keyboard Layout") self.set_size_request(600, 480) self.set_icon_from_file("/usr/share/pixmaps/peppermint-control-center.png") global cl, cm cl, cm = self.get_current() oldcommand = cm global layoutstore layoutstore = Gtk.ListStore(str) global variantstore variantstore = Gtk.ListStore(str, str) global layoutview layoutview = Gtk.TreeView(layoutstore) layout = Gtk.CellRendererText() layoutcolumn = Gtk.TreeViewColumn("Layout", layout, text=0) layoutview.append_column(layoutcolumn) global variantview variantview = Gtk.TreeView(variantstore) variant = Gtk.CellRendererText() description = Gtk.CellRendererText() variantcolumn = Gtk.TreeViewColumn("Variant") variantcolumn.pack_start(variant, True) variantcolumn.pack_start(description, True) variantcolumn.add_attribute(variant, "text", 0) variantcolumn.add_attribute(description, "text", 1) variantview.append_column(variantcolumn) layouts = self.getlist() for layout in layouts: layoutstore.append([layout[0]]) select = layoutview.get_selection() select.connect("changed", self.fill_variants) x = 0 for obj in layoutstore: if str(obj[0]) == cl: layoutview.set_cursor(x) layoutview.scroll_to_cell(x) x += 1 layoutbox = Gtk.HBox() layoutscroll = Gtk.ScrolledWindow() variantscroll = Gtk.ScrolledWindow() layoutscroll.add(layoutview) variantscroll.add(variantview) layoutbox.pack_start(layoutscroll, True, True, 0) layoutbox.pack_start(variantscroll, True, True, 5) entryt = Gtk.Entry() entryt.set_width_chars(35) entryt.set_placeholder_text("Type here to test the layout.") void = Gtk.Label() applyb = Gtk.Button.new_from_stock(Gtk.STOCK_APPLY) applyb.connect("clicked", self.set_layout, "us") revert = Gtk.Button.new_from_stock(Gtk.STOCK_REVERT_TO_SAVED) revert.connect("clicked", self.revert_it, oldcommand) cancel = Gtk.Button.new_from_stock(Gtk.STOCK_CLOSE) cancel.connect("clicked", self.close_it) buttons = Gtk.HBox() buttons.pack_start(entryt, False, False, 0) buttons.pack_start(void, True, True, 0) buttons.pack_start(applyb, False, False, 0) buttons.pack_start(revert, False, False, 10) buttons.pack_start(cancel, False, False, 0) vbox = Gtk.VBox() vbox.pack_start(layoutbox, True, True, 0) vbox.pack_start(buttons, False, False, 10) hbox = Gtk.HBox() hbox.pack_start(vbox, True, True, 10) self.add(hbox) # Add new shortcut window. class NewShortcut(Gtk.Window): def close_it(self, widget): self.close() def add_shortcut(self, widget, liststore): global oldcommand oldcommand = "" global command command = newcommand.get_text() global workspace workspace = "bind" liststore.prepend([newcommand.get_text(), ""]) treeiter = liststore.get_iter(0) print(treeiter) print(newcommand.get_text()) print(liststore[0][0]) self.close() a = KeyboardShortcut(liststore, treeiter) a.show_all() def __init__(self, liststore): Gtk.Window.__init__(self, title="Add New Shortcut") self.set_size_request(250, 120) self.set_icon_from_file("/usr/share/pixmaps/peppermint-control-center.png") label = Gtk.Label("Enter the command to execute:") global newcommand newcommand = Gtk.Entry() buttons = Gtk.HBox() button_void = Gtk.Label() button_okay = Gtk.Button.new_from_stock(Gtk.STOCK_OK) button_okay.connect("clicked", self.add_shortcut, liststore) button_cancel = Gtk.Button.new_from_stock(Gtk.STOCK_CANCEL) button_cancel.connect("clicked", self.close_it) buttons.pack_start(button_void, True, True, 0) buttons.pack_start(button_cancel, False, False, 10) buttons.pack_start(button_okay, False, False, 0) vbox = Gtk.VBox() vbox.pack_start(label, True, True, 10) vbox.pack_start(newcommand, False, False, 0) vbox.pack_start(buttons, False, False, 10) hbox = Gtk.HBox() hbox.pack_start(vbox, True, True, 10) self.add(hbox) # Keyboard Shortcut selection window. class KeyboardShortcut(Gtk.Window): def close_it(self, widget): self.close() def action_bind_del(self, widget, store, treeiter): action = "delete" command = treeiter self.close() confirm = AreYouSure(action, command) confirm.show_all() def set_shortcut(self, widget, store, treeiter): newkey = keybox_entry.get_text() array = ["F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F12", "`", "1", "2", "3", "4", "5", "6", "7", "8", "9", "0", "-", "=", "q", "w", "e", "r", "t", "y", "u", "i", "o", "p", "[", "]", "a", "s", "d", "f", "g", "h", "j", "k", "l", ";", "'", "z", "x", "c", "v", "b", "n", "m", ",", ".", "/", "\\", "Space", "Tab", "Up", "Down", "Left", "Right"] newshortcut = "" if newkey == " ": newkey = "Space" if newkey in array: if _shift.get_active(): newshortcut = newshortcut + "" if _control.get_active(): newshortcut = newshortcut + "" if _super.get_active(): newshortcut = newshortcut + "" if _alt.get_active(): newshortcut = newshortcut + "" if _shift.get_active() == False and _control.get_active() == False and _super.get_active() == False and \ _alt.get_active() == False: assign_void.set_markup("Specify modifier(s)") else: newshortcut = newshortcut + newkey print(newshortcut) store.set_value(treeiter, 1, newshortcut) if workspace == "xfce": set_xfce_shortcut(command, newshortcut) elif workspace == "bind": set_bind_shortcut(command, newshortcut, store) else: print("ERROR: Unknown workspace type.") sys.exit(1) self.close() else: assign_void.set_markup("Invalid character") def __init__(self, store, treeiter): Gtk.Window.__init__(self, title="Assign New Shortcut") self.set_size_request(250, 120) self.set_icon_from_file("/usr/share/pixmaps/peppermint-control-center.png") buttons = Gtk.HBox() global _shift _shift = Gtk.ToggleButton("Shift") global _control _control = Gtk.ToggleButton("Control") global _super _super = Gtk.ToggleButton("Super") global _alt _alt = Gtk.ToggleButton("Alt") buttons.pack_start(_shift, True, True, 5) buttons.pack_start(_control, True, True, 5) buttons.pack_start(_super, True, True, 5) buttons.pack_start(_alt, True, True, 5) keybox = Gtk.HBox() keybox_label = Gtk.Label("Enter a valid character:") keybox_space = Gtk.Label(" ") global keybox_entry keybox_entry = Gtk.Entry() keybox.pack_start(keybox_label, False, False, 0) keybox.pack_start(keybox_space, False, False, 5) keybox.pack_start(keybox_entry, True, True, 0) assign = Gtk.HBox() global assign_void assign_void = Gtk.Label() bind_delete = Gtk.Button.new_from_stock(Gtk.STOCK_DELETE) bind_delete.connect("clicked", self.action_bind_del, store, treeiter) assign_cancel = Gtk.Button.new_from_stock(Gtk.STOCK_CANCEL) assign_cancel.connect("clicked", self.close_it) assign_apply = Gtk.Button.new_from_stock(Gtk.STOCK_APPLY) assign_apply.connect("clicked", self.set_shortcut, store, treeiter) assign.pack_start(assign_void, True, True, 0) assign.pack_start(bind_delete, False, False, 0) assign.pack_start(assign_cancel, False, False, 5) assign.pack_start(assign_apply, False, False, 0) shortvbox = Gtk.VBox() shortvbox.pack_start(buttons, True, False, 5) shortvbox.pack_start(keybox, True, False, 5) shortvbox.pack_start(assign, True, False, 5) shorthbox = Gtk.HBox() shorthbox.pack_start(shortvbox, True, True, 10) self.add(shorthbox) # Window and window layout. class ControlCenter(Gtk.Window): def __init__(self): Gtk.Window.__init__(self, title="Peppermint Control Center") self.set_size_request(600, 500) self.set_icon_from_file("/usr/share/pixmaps/peppermint-control-center.png") ############################## ### 'Window Manager' page. ### ############################## page_wman_lab = Gtk.Label("Window Manager") page_wman = Gtk.VBox() page_wman_hbox = Gtk.HBox() page_wman_hbox.pack_start(page_wman, True, True, 10) scroll_wman = Gtk.ScrolledWindow() scroll_wman.add(page_wman_hbox) theme_label = Gtk.Label() theme_label.set_markup("Theme") theme_void = Gtk.Label(" ") theme_label_wrapper = Gtk.HBox() theme_label_wrapper.pack_start(theme_label, False, False, 10) theme_label_wrapper.pack_start(theme_void, True, True, 0) global theme_box theme_box = Gtk.ComboBoxText() theme_box.connect("changed", set_theme) for theme in theme_list(): theme_box.append_text(theme) theme_box.set_active(theme_index()) theme_box_wrapper = Gtk.HBox() theme_box_wrapper.pack_start(theme_box, True, True, 20) title_font_label = Gtk.Label() title_font_label.set_markup("Title font") title_font_void = Gtk.Label(" ") title_font_label_wrapper = Gtk.HBox() title_font_label_wrapper.pack_start(title_font_label, False, False, 10) title_font_label_wrapper.pack_start(title_font_void, True, True, 0) global title_font title_font = Gtk.FontButton() title_font.set_font_name(get_title_font()) title_font.connect("font-set", set_title_font) title_font_wrapper = Gtk.HBox() title_font_wrapper.pack_start(title_font, True, True, 20) title_alignment_label = Gtk.Label() title_alignment_label.set_markup("Title alignment") title_alignment_void = Gtk.Label(" ") title_alignment_label_wrapper = Gtk.HBox() title_alignment_label_wrapper.pack_start(title_alignment_label, False, False, 10) title_alignment_label_wrapper.pack_start(title_alignment_void, True, True, 0) global alignment_box alignment_box = Gtk.ComboBoxText() alignment_box.connect("changed", set_title_alignment) alignment_box.append_text("Left") alignment_box.append_text("Center") alignment_box.append_text("Right") alignment_box.set_active(alignment_index()) alignment_box_wrapper = Gtk.HBox() alignment_box_wrapper.pack_start(alignment_box, True, True, 20) workspace_count_label = Gtk.Label() workspace_count_label.set_markup("Number of workspaces:") workspace_count_adj = Gtk.Adjustment(0, 1, 100, 1, 10, 0) global workspace_count workspace_count = Gtk.SpinButton() workspace_count.set_adjustment(workspace_count_adj) workspace_count.set_value(get_workspace_count()) workspace_count.set_numeric(True) workspace_count.connect("changed", set_workspace_count) workspace_count_box = Gtk.HBox() workspace_count_box.pack_start(workspace_count_label, False, False, 10) workspace_count_box.pack_start(workspace_count, False, False, 10) global focus_delay_box focus_delay_box = Gtk.HBox() focus_delay_wrapper = Gtk.HBox() focus_delay_wrapper.pack_start(focus_delay_box, True, True, 50) click_to_focus_label_box = Gtk.HBox() click_to_focus_label = Gtk.Label() click_to_focus_label.set_markup("Focus model") click_to_focus_void = Gtk.Label(" ") click_to_focus_label_box.pack_start(click_to_focus_label, False, False, 10) click_to_focus_label_box.pack_start(click_to_focus_void, True, True, 0) ctf_button1 = Gtk.RadioButton.new_with_label_from_widget(None, "Click to focus") ctf_button1.connect("toggled", set_click_to_focus, "true") if get_click_to_focus() == "true": ctf_button1.set_active(True) ctf_button2 = Gtk.RadioButton.new_from_widget(ctf_button1) ctf_button2.set_label("Focus follows mouse") ctf_button2.connect("toggled", set_click_to_focus, "false") if get_click_to_focus() == "false": ctf_button2.set_active(True) click_to_focus = Gtk.HBox() click_to_focus.pack_start(ctf_button1, True, True, 30) click_to_focus.pack_start(ctf_button2, True, True, 30) focus_delay_label_box = Gtk.HBox() focus_delay_label = Gtk.Label("Delay before window receives focus:") focus_delay_void = Gtk.Label(" ") focus_delay_label_box.pack_start(focus_delay_label, False, False, 30) focus_delay_label_box.pack_start(focus_delay_void, True, True, 0) focus_delay_short = Gtk.Label() focus_delay_short.set_markup("Short") focus_delay_long = Gtk.Label() focus_delay_long.set_markup("Long") global focus_delay focus_delay = Gtk.HScale() focus_delay.set_range(5, 2000) focus_delay.set_increments(1, 1) focus_delay.set_digits(0) focus_delay.set_value(get_focus_delay()) focus_delay.connect("value-changed", set_focus_delay) focus_delay_box.pack_start(focus_delay_short, False, False, 0) focus_delay_box.pack_start(focus_delay, True, True, 10) focus_delay_box.pack_start(focus_delay_long, False, False, 0) if ctf_button1.get_active(): focus_delay_box.set_sensitive(False) focus_new_label_box = Gtk.HBox() focus_new_label = Gtk.Label() focus_new_label.set_markup("New window focus") focus_new_void = Gtk.Label(" ") focus_new_label_box.pack_start(focus_new_label, False, False, 10) focus_new_label_box.pack_start(focus_new_void, True, True, 0) global focus_new focus_new = Gtk.CheckButton("Automatically give focus to newly created windows") focus_new.set_active(get_focus_new()) focus_new.connect("toggled", set_focus_new) focus_new_wrapper = Gtk.HBox() focus_new_wrapper.pack_start(focus_new, True, True, 30) global raise_delay_box raise_delay_box = Gtk.HBox() raise_delay_wrapper = Gtk.HBox() raise_delay_wrapper.pack_start(raise_delay_box, True, True, 50) raise_on_focus_label_box = Gtk.HBox() raise_on_focus_label = Gtk.Label() raise_on_focus_label.set_markup("Raise on focus") raise_on_focus_void = Gtk.Label(" ") raise_on_focus_label_box.pack_start(raise_on_focus_label, False, False, 10) raise_on_focus_label_box.pack_start(raise_on_focus_void, True, True, 0) global raise_on_focus raise_on_focus = Gtk.CheckButton("Automatically raise windows when they receive focus") raise_on_focus.set_active(get_raise_on_focus()) raise_on_focus.connect("toggled", set_raise_on_focus) raise_on_focus_wrapper = Gtk.HBox() raise_on_focus_wrapper.pack_start(raise_on_focus, True, True, 30) raise_delay_label_box = Gtk.HBox() raise_delay_label_wrapper = Gtk.HBox() raise_delay_label_wrapper.pack_start(raise_delay_label_box, True, True, 30) raise_delay_label = Gtk.Label("Delay before raising focused window:") raise_delay_void = Gtk.Label(" ") raise_delay_label_box.pack_start(raise_delay_label, False, False, 0) raise_delay_label_box.pack_start(raise_delay_void, True, True, 0) raise_delay_short = Gtk.Label() raise_delay_short.set_markup("Short") raise_delay_long = Gtk.Label() raise_delay_long.set_markup("Long") global raise_delay raise_delay = Gtk.HScale() raise_delay.set_range(5, 2000) raise_delay.set_increments(1, 1) raise_delay.set_digits(0) raise_delay.set_value(get_raise_delay()) raise_delay.connect("value-changed", set_raise_delay) raise_delay_box.pack_start(raise_delay_short, False, False, 0) raise_delay_box.pack_start(raise_delay, True, True, 10) raise_delay_box.pack_start(raise_delay_long, False, False, 0) raise_on_click_label_box = Gtk.HBox() raise_on_click_label = Gtk.Label() raise_on_click_label.set_markup("Raise on click") raise_on_click_void = Gtk.Label(" ") raise_on_click_label_box.pack_start(raise_on_click_label, False, False, 10) raise_on_click_label_box.pack_start(raise_on_click_void, True, True, 0) global raise_on_click raise_on_click = Gtk.CheckButton("Raise window when clicking inside an application window") raise_on_click.set_active(get_raise_on_click()) raise_on_click.connect("toggled", set_raise_on_click) raise_on_click_wrapper = Gtk.HBox() raise_on_click_wrapper.pack_start(raise_on_click, True, True, 30) snap_label_box = Gtk.HBox() snap_label = Gtk.Label() snap_label.set_markup("Window Snapping") snap_void = Gtk.Label(" ") snap_label_box.pack_start(snap_label, False, False, 10) snap_label_box.pack_start(snap_void, True, True, 0) global snap_to_border snap_to_border = Gtk.CheckButton("To screen borders") snap_to_border.set_active(get_snap_to_border()) snap_to_border.connect("toggled", set_snap_to_border) global snap_to_windows snap_to_windows = Gtk.CheckButton("To other windows") snap_to_windows.set_active(get_snap_to_windows()) snap_to_windows.connect("toggled", set_snap_to_windows) snap_to_wrapper = Gtk.HBox() snap_to_wrapper.pack_start(snap_to_border, True, True, 30) snap_to_wrapper.pack_start(snap_to_windows, True, True, 30) global snap_width_box snap_width_box = Gtk.HBox() snap_width_wrapper = Gtk.HBox() snap_width_wrapper.pack_start(snap_width_box, True, True, 50) snap_width_label = Gtk.Label("Distance:") snap_width_void = Gtk.Label(" ") snap_width_label_wrapper = Gtk.HBox() snap_width_label_wrapper.pack_start(snap_width_label, False, False, 30) snap_width_label_wrapper.pack_start(snap_width_void, True, True, 0) snap_width_small = Gtk.Label() snap_width_small.set_markup("Small") snap_width_wide = Gtk.Label() snap_width_wide.set_markup("Wide") global snap_width snap_width = Gtk.HScale() snap_width.set_range(5, 100) snap_width.set_increments(1, 1) snap_width.set_digits(0) snap_width.set_value(get_snap_width()) snap_width.connect("value-changed", set_snap_width) snap_width_box.pack_start(snap_width_small, False, False, 0) snap_width_box.pack_start(snap_width, True, True, 10) snap_width_box.pack_start(snap_width_wide, False, False, 0) wrap_label_box = Gtk.HBox() wrap_label = Gtk.Label() wrap_label.set_markup("Wrap workspaces when reaching the screen edge") wrap_void = Gtk.Label(" ") wrap_label_box.pack_start(wrap_label, False, False, 10) wrap_label_box.pack_start(wrap_void, True, True, 0) global wrap_workspaces wrap_workspaces = Gtk.CheckButton("With the mouse pointer") wrap_workspaces.set_active(get_wrap_workspaces()) wrap_workspaces.connect("toggled", set_wrap_workspaces) global wrap_windows wrap_windows = Gtk.CheckButton("To other windows") wrap_windows.set_active(get_wrap_windows()) wrap_windows.connect("toggled", set_wrap_windows) wrap_type_wrapper = Gtk.HBox() wrap_type_wrapper.pack_start(wrap_workspaces, True, True, 30) wrap_type_wrapper.pack_start(wrap_windows, True, True, 30) global wrap_resistance_box wrap_resistance_box = Gtk.HBox() wrap_resistance_wrapper = Gtk.HBox() wrap_resistance_wrapper.pack_start(wrap_resistance_box, True, True, 50) wrap_resistance_label = Gtk.Label("Edge Resistance:") wrap_resistance_void = Gtk.Label(" ") wrap_resistance_label_wrapper = Gtk.HBox() wrap_resistance_label_wrapper.pack_start(wrap_resistance_label, False, False, 30) wrap_resistance_label_wrapper.pack_start(wrap_resistance_void, True, True, 0) wrap_resistance_small = Gtk.Label() wrap_resistance_small.set_markup("Small") wrap_resistance_wide = Gtk.Label() wrap_resistance_wide.set_markup("Wide") global wrap_resistance wrap_resistance = Gtk.HScale() wrap_resistance.set_range(5, 100) wrap_resistance.set_increments(1, 1) wrap_resistance.set_digits(0) wrap_resistance.set_value(get_wrap_resistance()) wrap_resistance.connect("value-changed", set_wrap_resistance) wrap_resistance_box.pack_start(wrap_resistance_small, False, False, 0) wrap_resistance_box.pack_start(wrap_resistance, True, True, 10) wrap_resistance_box.pack_start(wrap_resistance_wide, False, False, 0) box_label_box = Gtk.HBox() box_label = Gtk.Label() box_label.set_markup("Hide content of windows") box_void = Gtk.Label(" ") box_label_box.pack_start(box_label, False, False, 10) box_label_box.pack_start(box_void, True, True, 0) global box_move box_move = Gtk.CheckButton("When moving") box_move.set_active(get_box_move()) box_move.connect("toggled", set_box_move) global box_resize box_resize = Gtk.CheckButton("When resizing") box_resize.set_active(get_box_resize()) box_resize.connect("toggled", set_box_resize) box_type_wrapper = Gtk.HBox() box_type_wrapper.pack_start(box_move, True, True, 30) box_type_wrapper.pack_start(box_resize, True, True, 30) double_click_label_box = Gtk.HBox() double_click_label = Gtk.Label() double_click_label.set_markup("Title bar double click action") double_click_void = Gtk.Label(" ") double_click_label_box.pack_start(double_click_label, False, False, 10) double_click_label_box.pack_start(double_click_void, True, True, 0) global double_click_action double_click_action = Gtk.ComboBoxText() double_click_action.connect("changed", set_double_click_action) double_click_action.append_text("Shade window") double_click_action.append_text("Hide window") double_click_action.append_text("Maximize window") double_click_action.append_text("Fill window") double_click_action.append_text("Nothing") double_click_action.set_active(double_click_action_index()) double_click_box = Gtk.HBox() double_click_box.pack_start(double_click_action, True, True, 30) wmimage = Gtk.Image() wmimage.set_from_file("/usr/lib/peppermint/peppermint-control-center/images/wm.png") # temporary wmimage_label = Gtk.Label("Configure window manager\nbehavior and options") wmimage_label.set_justify(Gtk.Justification.CENTER) box_wmimage = Gtk.VBox() box_wmimage.pack_start(wmimage, True, True, 10) box_wmimage.pack_start(wmimage_label, True, True, 0) box_theme = Gtk.VBox() box_theme.pack_start(theme_label_wrapper, False, False, 4) box_theme.pack_start(theme_box_wrapper, False, False, 4) box_theme.pack_start(title_font_label_wrapper, False, False, 4) box_theme.pack_start(title_font_wrapper, False, False, 4) box_theme.pack_start(title_alignment_label_wrapper, False, False, 4) box_theme.pack_start(alignment_box_wrapper, False, False, 4) box_theme.pack_start(workspace_count_box, False, False, 10) box_top = Gtk.HBox() box_top.pack_start(box_wmimage, False, False, 30) box_top.pack_start(box_theme, True, True, 0) box_focus = Gtk.VBox() box_focus.pack_start(click_to_focus_label_box, False, False, 4) box_focus.pack_start(click_to_focus, False, False, 4) box_focus.pack_start(focus_delay_label_box, False, False, 4) box_focus.pack_start(focus_delay_wrapper, False, False, 4) box_focus_new = Gtk.VBox() box_focus_new.pack_start(focus_new_label_box, False, False, 4) box_focus_new.pack_start(focus_new_wrapper, False, False, 4) box_raise = Gtk.VBox() box_raise.pack_start(raise_on_focus_label_box, False, False, 4) box_raise.pack_start(raise_on_focus_wrapper, False, False, 4) box_raise.pack_start(raise_delay_label_wrapper, False, False, 4) box_raise.pack_start(raise_delay_wrapper, False, False, 4) box_click = Gtk.VBox() box_click.pack_start(raise_on_click_label_box, False, False, 4) box_click.pack_start(raise_on_click_wrapper, False, False, 4) box_snap = Gtk.VBox() box_snap.pack_start(snap_label_box, False, False, 4) box_snap.pack_start(snap_to_wrapper, False, False, 4) box_snap.pack_start(snap_width_label_wrapper, False, False, 4) box_snap.pack_start(snap_width_wrapper, False, False, 4) box_wrap = Gtk.VBox() box_wrap.pack_start(wrap_label_box, False, False, 4) box_wrap.pack_start(wrap_type_wrapper, False, False, 4) box_wrap.pack_start(wrap_resistance_label_wrapper, False, False, 4) box_wrap.pack_start(wrap_resistance_wrapper, False, False, 4) box_box = Gtk.VBox() box_box.pack_start(box_label_box, False, False, 4) box_box.pack_start(box_type_wrapper, False, False, 4) box_dclick = Gtk.VBox() box_dclick.pack_start(double_click_label_box, False, False, 4) box_dclick.pack_start(double_click_box, False, False, 4) page_wman.pack_start(box_top, True, True, 6) page_wman.pack_start(box_focus, True, True, 4) page_wman.pack_start(box_focus_new, True, True, 4) page_wman.pack_start(box_raise, True, True, 4) page_wman.pack_start(box_click, True, True, 4) page_wman.pack_start(box_snap, True, True, 4) page_wman.pack_start(box_wrap, True, True, 4) page_wman.pack_start(box_box, True, True, 4) page_wman.pack_start(box_dclick, True, True, 4) ############################### ### 'Pointer Options' page. ### ############################### page_point_lab = Gtk.Label("Keyboard & Pointer") page_point = Gtk.VBox() scroll_point = Gtk.ScrolledWindow() scroll_point.add(page_point) keyopt_label = Gtk.Label() keyopt_label.set_markup("Keyboard options") keyopt_void = Gtk.Label(" ") keyopt_label_box = Gtk.HBox() keyopt_label_box.pack_start(keyopt_label, False, False, 10) keyopt_label_box.pack_start(keyopt_void, True, True, 0) delay_label = Gtk.Label("Delay:") global delay delay = Gtk.HScale() delay.set_range(10, 1000) delay.set_increments(1, 1) delay.set_digits(0) #disable keyboard file generation and setting# try: #disable keyboard file generation and setting# delay.set_value(get_delay()) #disable keyboard file generation and setting# except: #disable keyboard file generation and setting# delay.set_value(500) #disable keyboard file generation and setting# #disable keyboard file generation and setting# delay.connect("value-changed", keys_apply) #disable keyboard file generation and setting# delay_label_box = Gtk.HBox() #disable keyboard file generation and setting# delay_label_box.pack_start(delay_label, False, False, 20) #disable keyboard file generation and setting# delay_label_box.pack_start(delay, True, True, 0) #disable keyboard file generation and setting# #disable keyboard file generation and setting# interval_label = Gtk.Label("Interval:") #disable keyboard file generation and setting# global interval #disable keyboard file generation and setting# interval = Gtk.HScale() #disable keyboard file generation and setting# interval.set_range(1, 50) #disable keyboard file generation and setting# interval.set_increments(1, 1) #disable keyboard file generation and setting# interval.set_digits(0) #disable keyboard file generation and setting# #disable keyboard file generation and setting# try: #disable keyboard file generation and setting# interval.set_value(get_interval()) #disable keyboard file generation and setting# except: #disable keyboard file generation and setting# interval.set_value(20) #disable keyboard file generation and setting# #disable keyboard file generation and setting# interval.connect("value-changed", keys_apply) #disable keyboard file generation and setting# interval_label_box = Gtk.HBox() #disable keyboard file generation and setting# interval_label_box.pack_start(interval_label, False, False, 20) #disable keyboard file generation and setting# interval_label_box.pack_start(interval, True, True, 0) kbimage = Gtk.Image() kbimage.set_from_file("/usr/lib/peppermint/peppermint-control-center/images/keyboard.png") layout_button = Gtk.Button("Click to Set Keyboard Behaviour and Layout") layout_button.connect("clicked", layoutsetter) layout_button_left = Gtk.Label(" ") layout_button_right = Gtk.Label(" ") layout_button_box = Gtk.HBox() layout_button_box.pack_start(layout_button_left, True, True, 30) layout_button_box.pack_start(layout_button, True, True, 0) layout_button_box.pack_start(layout_button_right, True, True, 30) pntopt_label = Gtk.Label() pntopt_label.set_markup("Pointer options") pntopt_void = Gtk.Label(" ") pntopt_label_box = Gtk.HBox() pntopt_label_box.pack_start(pntopt_label, False, False, 10) pntopt_label_box.pack_start(pntopt_void, True, True, 0) acceleration_label = Gtk.Label("Acceleration:") global acceleration acceleration = Gtk.HScale() acceleration.set_range(0, 10) acceleration.set_increments(1, 1) acceleration.set_digits(0) try: acceleration.set_value(get_acceleration()) except: acceleration.set_value(2) acceleration.connect("value-changed", pntr_apply) acceleration_label_box = Gtk.HBox() acceleration_label_box.pack_start(acceleration_label, False, False, 20) acceleration_label_box.pack_start(acceleration, True, True, 0) threshold_label = Gtk.Label("Threshold") global threshold threshold = Gtk.HScale() threshold.set_range(0, 10) threshold.set_increments(1, 1) threshold.set_digits(0) try: threshold.set_value(get_threshold()) except: threshold.set_value(2) threshold.connect("value-changed", pntr_apply) threshold_label_box = Gtk.HBox() threshold_label_box.pack_start(threshold_label, False, False, 20) threshold_label_box.pack_start(threshold, True, True, 0) pntimage = Gtk.Image() pntimage.set_from_file("/usr/lib/peppermint/peppermint-control-center/images/mouse.png") global lefthanded lefthanded = Gtk.CheckButton("Left handed button layout") lefthanded.set_active(get_lefthanded()) lefthanded.connect("toggled", pntr_apply) lefthanded_left = Gtk.Label(" ") lefthanded_right = Gtk.Label(" ") lefthanded_box = Gtk.HBox() lefthanded_box.pack_start(lefthanded_left, True, True, 0) lefthanded_box.pack_start(lefthanded, False, False, 0) lefthanded_box.pack_start(lefthanded_right, True, True, 0) touch_label = Gtk.Label() touch_label.set_markup("Touchpad options") touch_void = Gtk.Label(" ") touch_label_box = Gtk.HBox() touch_label_box.pack_start(touch_label, False, False, 30) touch_label_box.pack_start(touch_void, True, True, 0) global touchenable touchenable = Gtk.CheckButton("Touchpad Enabled") touchenable.set_active(get_touchenable()) touchenable.connect("toggled", pntr_apply) global taptoclick taptoclick = Gtk.CheckButton("Tap-to-Click Enabled") taptoclick.set_active(get_taptoclick()) taptoclick.connect("toggled", pntr_apply) global vertedge vertedge = Gtk.CheckButton("Vertical Edge Scrolling") vertedge.set_active(get_vertedge()) vertedge.connect("toggled", pntr_apply) global horizedge horizedge = Gtk.CheckButton("Horizontal Edge Scrolling") horizedge.set_active(get_horizedge()) horizedge.connect("toggled", pntr_apply) global vtwofinger vtwofinger = Gtk.CheckButton("Two Finger Vertical Scrolling") vtwofinger.set_active(get_vtwofinger()) vtwofinger.connect("toggled", pntr_apply) global htwofinger htwofinger = Gtk.CheckButton("Two Finger Horizontal Scrolling") htwofinger.set_active(get_htwofinger()) htwofinger.connect("toggled", pntr_apply) kbimage_box = Gtk.VBox() kbimage_box.pack_start(kbimage, True, True, 20) kboptions_box = Gtk.VBox() kboptions_box.pack_start(keyopt_label_box, False, False, 4) #commented by mg# kboptions_box.pack_start(delay_label_box, False, False, 4) #commented by mg# kboptions_box.pack_start(interval_label_box, False, False, 4) kboptions_box.pack_start(layout_button_box, False, False, 30) kb_box = Gtk.HBox() kb_box.pack_start(kbimage_box, False, False, 40) kb_box.pack_start(kboptions_box, True, True, 20) pntimage_box = Gtk.VBox() pntimage_box.pack_start(pntimage, True, True, 20) pntoptions_box = Gtk.VBox() pntoptions_box.pack_start(pntopt_label_box, False, False, 4) pntoptions_box.pack_start(acceleration_label_box, False, False, 4) pntoptions_box.pack_start(threshold_label_box, False, False, 4) pntoptions_box.pack_start(lefthanded_box, False, False, 4) pnt_box = Gtk.HBox() pnt_box.pack_start(pntoptions_box, True, True, 20) pnt_box.pack_start(pntimage_box, False, False, 40) touchleft_box = Gtk.VBox() touchleft_box.pack_start(touchenable, False, False, 0) touchleft_box.pack_start(vertedge, False, False, 0) touchleft_box.pack_start(horizedge, False, False, 0) touchright_box = Gtk.VBox() touchright_box.pack_start(taptoclick, False, False, 0) touchright_box.pack_start(vtwofinger, False, False, 0) touchright_box.pack_start(htwofinger, False, False, 0) touch_box = Gtk.HBox() touch_box.pack_start(touchleft_box, False, False, 40) touch_box.pack_start(touchright_box, False, False, 0) page_point.pack_start(kb_box, False, False, 10) page_point.pack_start(pnt_box, False, False, 0) page_point.pack_start(touch_label_box, False, False, 10) page_point.pack_start(touch_box, False, False, 10) ################################## ### 'Keyboard Shortcuts' page. ### ################################## page_short_lab = Gtk.Label("Keyboard Shortcuts") page_short = Gtk.VBox() scroll_short = Gtk.ScrolledWindow() scroll_short.add(page_short) xfce_label = Gtk.Label() xfce_label.set_markup("Window Manager Shortcuts") xfce_void = Gtk.Label(" ") xfce_restore = Gtk.Button("Restore Defaults") xfce_restore.connect("clicked", action_xfce_restore) xfce_label_box = Gtk.HBox() xfce_label_box.pack_start(xfce_label, False, False, 10) xfce_label_box.pack_start(xfce_void, True, True, 0) xfce_label_box.pack_start(xfce_restore, False, False, 10) xfcestore = Gtk.ListStore(str, str) get_xfce = get_xfce_shortcuts() move_directions = ['move_window_workspace', 'move_window_right_key', 'move_window_left_key', 'move_window_up_key', 'up_workspace_key', 'down_workspace_key', 'switch_window_key', 'raise_window_key'] for line in get_xfce: a = line.split() for direction in move_directions: if direction in a[0]: continue xfcestore.append([a[0], a[1]]) xfceview = Gtk.TreeView(model=xfcestore) xfce_renderer_action = Gtk.CellRendererText() xfce_column_action = Gtk.TreeViewColumn("Action", xfce_renderer_action, text=0) xfceview.append_column(xfce_column_action) xfce_renderer_shortcut = Gtk.CellRendererText() xfce_column_shortcut = Gtk.TreeViewColumn("Shortcut", xfce_renderer_shortcut, text=1) xfceview.append_column(xfce_column_shortcut) xfceview.connect("row-activated", edit_xfce_shortcut) global bindstore bindstore = Gtk.ListStore(str, str) get_bind = get_xbindkeys() for line in get_bind: a = line.split("\n") bindstore.append([a[0], a[1]]) bind_label = Gtk.Label() bind_label.set_markup("System Shortcuts") bind_void = Gtk.Label(" ") bind_new = Gtk.Button("Add New") bind_new.connect("clicked", action_bind_new, bindstore) bind_restore = Gtk.Button("Restore Defaults") bind_restore.connect("clicked", action_bind_restore) bind_label_box = Gtk.HBox() bind_label_box.pack_start(bind_label, False, False, 10) bind_label_box.pack_start(bind_void, True, True, 0) bind_label_box.pack_start(bind_new, False, False, 0) bind_label_box.pack_start(bind_restore, False, False, 10) global bindview bindview = Gtk.TreeView(model=bindstore) bind_renderer_action = Gtk.CellRendererText() bind_column_action = Gtk.TreeViewColumn("Action", bind_renderer_action, text=0) bindview.append_column(bind_column_action) bind_renderer_shortcut = Gtk.CellRendererText() bind_column_shortcut = Gtk.TreeViewColumn("Shortcut", bind_renderer_shortcut, text=1) bindview.append_column(bind_column_shortcut) bindview.connect("row-activated", edit_bind_shortcut) page_short.pack_start(bind_label_box, False, False, 10) page_short.pack_start(bindview, True, True, 0) page_short.pack_start(xfce_label_box, False, False, 10) page_short.pack_start(xfceview, True, True, 0) ############################### ### 'Desktop Effects' page. ### ############################### page_effect_lab = Gtk.Label("Desktop Effects") page_effect = Gtk.VBox() scroll_effect = Gtk.ScrolledWindow() scroll_effect.add(page_effect) use_compositing = Gtk.CheckButton() use_compositing.set_active(get_use_compositing()) use_compositing.connect("toggled", set_use_compositing) use_compositing_label = Gtk.Label() use_compositing_label.set_markup("Enable desktop effects") use_compositing_void = Gtk.Label(" ") use_compositing_box = Gtk.HBox() use_compositing_box.pack_start(use_compositing, False, False, 10) use_compositing_box.pack_start(use_compositing_label, False, False, 0) use_compositing_box.pack_start(use_compositing_void, True, True, 0) unredirect_overlays = Gtk.CheckButton("Display fullscreen overlay windows directly") unredirect_overlays.set_active(get_unredirect_overlays()) unredirect_overlays.connect("toggled", set_unredirect_overlays) sync_to_vblank = Gtk.CheckButton("Synchronize drawing to the vertical blank") sync_to_vblank.set_active(get_sync_to_vblank()) sync_to_vblank.connect("toggled", set_sync_to_vblank) show_popup_shadow = Gtk.CheckButton("Show shadows under popup windows") show_popup_shadow.set_active(get_show_popup_shadow()) show_popup_shadow.connect("toggled", set_show_popup_shadow) show_dock_shadow = Gtk.CheckButton("Show shadows under dock windows") show_dock_shadow.set_active(get_show_dock_shadow()) show_dock_shadow.connect("toggled", set_show_dock_shadow) show_frame_shadow = Gtk.CheckButton("Show shadows under regular windows") show_frame_shadow.set_active(get_show_frame_shadow()) show_frame_shadow.connect("toggled", set_show_frame_shadow) frame_opacity_label = Gtk.Label("Opacity of window decorations:") frame_opacity_void = Gtk.Label(" ") frame_opacity_label_box = Gtk.HBox() frame_opacity_label_box.pack_start(frame_opacity_label, False, False, 0) frame_opacity_label_box.pack_start(frame_opacity_void, True, True, 0) frame_opacity_left = Gtk.Label() frame_opacity_left.set_markup("Transparent") frame_opacity_right = Gtk.Label() frame_opacity_right.set_markup("Opaque") frame_opacity = Gtk.HScale() frame_opacity.set_range(0, 100) frame_opacity.set_increments(1, 1) frame_opacity.set_digits(0) try: frame_opacity.set_value(get_frame_opacity()) except: frame_opacity.set_value(100) frame_opacity.connect("value-changed", set_frame_opacity) frame_opacity_box = Gtk.HBox() frame_opacity_box.pack_start(frame_opacity_left, False, False, 15) frame_opacity_box.pack_start(frame_opacity, True, True, 0) frame_opacity_box.pack_start(frame_opacity_right, False, False, 15) inactive_opacity_label = Gtk.Label("Opacity of inactive windows:") inactive_opacity_void = Gtk.Label(" ") inactive_opacity_label_box = Gtk.HBox() inactive_opacity_label_box.pack_start(inactive_opacity_label, False, False, 0) inactive_opacity_label_box.pack_start(inactive_opacity_void, True, True, 0) inactive_opacity_left = Gtk.Label() inactive_opacity_left.set_markup("Transparent") inactive_opacity_right = Gtk.Label() inactive_opacity_right.set_markup("Opaque") inactive_opacity = Gtk.HScale() inactive_opacity.set_range(0, 100) inactive_opacity.set_increments(1, 1) inactive_opacity.set_digits(0) try: inactive_opacity.set_value(get_inactive_opacity()) except: inactive_opacity.set_value(100) inactive_opacity.connect("value-changed", set_inactive_opacity) inactive_opacity_box = Gtk.HBox() inactive_opacity_box.pack_start(inactive_opacity_left, False, False, 15) inactive_opacity_box.pack_start(inactive_opacity, True, True, 0) inactive_opacity_box.pack_start(inactive_opacity_right, False, False, 15) move_opacity_label = Gtk.Label("Opacity of windows during move:") move_opacity_void = Gtk.Label(" ") move_opacity_label_box = Gtk.HBox() move_opacity_label_box.pack_start(move_opacity_label, False, False, 0) move_opacity_label_box.pack_start(move_opacity_void, True, True, 0) move_opacity_left = Gtk.Label() move_opacity_left.set_markup("Transparent") move_opacity_right = Gtk.Label() move_opacity_right.set_markup("Opaque") move_opacity = Gtk.HScale() move_opacity.set_range(0, 100) move_opacity.set_increments(1, 1) move_opacity.set_digits(0) try: move_opacity.set_value(get_move_opacity()) except: move_opacity.set_value(100) move_opacity.connect("value-changed", set_move_opacity) move_opacity_box = Gtk.HBox() move_opacity_box.pack_start(move_opacity_left, False, False, 15) move_opacity_box.pack_start(move_opacity, True, True, 0) move_opacity_box.pack_start(move_opacity_right, False, False, 15) resize_opacity_label = Gtk.Label("Opacity of windows during resize:") resize_opacity_void = Gtk.Label(" ") resize_opacity_label_box = Gtk.HBox() resize_opacity_label_box.pack_start(resize_opacity_label, False, False, 0) resize_opacity_label_box.pack_start(resize_opacity_void, True, True, 0) resize_opacity_left = Gtk.Label() resize_opacity_left.set_markup("Transparent") resize_opacity_right = Gtk.Label() resize_opacity_right.set_markup("Opaque") resize_opacity = Gtk.HScale() resize_opacity.set_range(0, 100) resize_opacity.set_increments(1, 1) resize_opacity.set_digits(0) try: resize_opacity.set_value(get_resize_opacity()) except: resize_opacity.set_value(100) resize_opacity.connect("value-changed", set_resize_opacity) resize_opacity_box = Gtk.HBox() resize_opacity_box.pack_start(resize_opacity_left, False, False, 15) resize_opacity_box.pack_start(resize_opacity, True, True, 0) resize_opacity_box.pack_start(resize_opacity_right, False, False, 15) popup_opacity_label = Gtk.Label("Opacity of popup windows:") popup_opacity_void = Gtk.Label(" ") popup_opacity_label_box = Gtk.HBox() popup_opacity_label_box.pack_start(popup_opacity_label, False, False, 0) popup_opacity_label_box.pack_start(popup_opacity_void, True, True, 0) popup_opacity_left = Gtk.Label() popup_opacity_left.set_markup("Transparent") popup_opacity_right = Gtk.Label() popup_opacity_right.set_markup("Opaque") popup_opacity = Gtk.HScale() popup_opacity.set_range(0, 100) popup_opacity.set_increments(1, 1) popup_opacity.set_digits(0) try: popup_opacity.set_value(get_popup_opacity()) except: popup_opacity.set_value(100) popup_opacity.connect("value-changed", set_popup_opacity) popup_opacity_box = Gtk.HBox() popup_opacity_box.pack_start(popup_opacity_left, False, False, 15) popup_opacity_box.pack_start(popup_opacity, True, True, 0) popup_opacity_box.pack_start(popup_opacity_right, False, False, 15) deimage = Gtk.Image() deimage.set_from_file("/usr/lib/peppermint/peppermint-control-center/images/de.png") deimage_box = Gtk.HBox() deimage_box.pack_start(deimage, True, True, 0) effects_left = Gtk.VBox() effects_left.pack_start(unredirect_overlays, False, False, 0) effects_left.pack_start(sync_to_vblank, False, False, 0) effects_left.pack_start(show_popup_shadow, False, False, 0) effects_left.pack_start(show_dock_shadow, False, False, 0) effects_left.pack_start(show_frame_shadow, False, False, 0) effects_top = Gtk.HBox() effects_top.pack_start(effects_left, False, False, 0) effects_top.pack_start(deimage_box, True, True, 0) global effects_box effects_box = Gtk.VBox() if get_use_compositing() == False: effects_box.set_sensitive(False) effects_box.pack_start(effects_top, False, False, 10) effects_box.pack_start(frame_opacity_label_box, False, False, 0) effects_box.pack_start(frame_opacity_box, False, False, 0) effects_box.pack_start(inactive_opacity_label_box, False, False, 0) effects_box.pack_start(inactive_opacity_box, False, False, 0) effects_box.pack_start(move_opacity_label_box, False, False, 0) effects_box.pack_start(move_opacity_box, False, False, 0) effects_box.pack_start(resize_opacity_label_box, False, False, 0) effects_box.pack_start(resize_opacity_box, False, False, 0) effects_box.pack_start(popup_opacity_label_box, False, False, 0) effects_box.pack_start(popup_opacity_box, False, False, 0) effects_wrapper = Gtk.HBox() effects_wrapper.pack_start(effects_box, True, True, 30) page_effect.pack_start(use_compositing_box, False, False, 10) page_effect.pack_start(effects_wrapper, True, True, 0) ######################## ### 'Advanced' page. ### ######################## page_adv_lab = Gtk.Label("Advanced") page_adv = Gtk.VBox() scroll_adv = Gtk.ScrolledWindow() scroll_adv.add(page_adv) cycling_label = Gtk.Label() cycling_label.set_markup("Window cycling") cycling_void = Gtk.Label(" ") cycling_label_box = Gtk.HBox() cycling_label_box.pack_start(cycling_label, False, False, 10) cycling_label_box.pack_start(cycling_void, True, True, 0) cycle_minimum = Gtk.CheckButton("Skip windows specified to skip the pager/taskbar") cycle_minimum.set_active(get_cycle_minimum()) cycle_minimum.connect("toggled", set_cycle_minimum) cycle_hidden = Gtk.CheckButton("Include hidden/iconified windows") cycle_hidden.set_active(get_cycle_hidden()) cycle_hidden.connect("toggled", set_cycle_minimum) cycle_workspaces = Gtk.CheckButton("Cycle through windows on all workspaces") cycle_workspaces.set_active(get_cycle_workspaces()) cycle_workspaces.connect("toggled", set_cycle_workspaces) cycle_preview = Gtk.CheckButton("Show windows preview in place of icon when cycling") cycle_preview.set_active(get_cycle_preview()) cycle_preview.connect("toggled", set_cycle_preview) cycle_draw_frame = Gtk.CheckButton("Draw frame around selected windows while cycling") cycle_draw_frame.set_active(get_cycle_draw_frame()) cycle_draw_frame.connect("toggled", set_cycle_draw_frame) cycling_section = Gtk.VBox() cycling_section.pack_start(cycle_minimum, False, False, 0) cycling_section.pack_start(cycle_hidden, False, False, 0) cycling_section.pack_start(cycle_workspaces, False, False, 0) cycling_section.pack_start(cycle_preview, False, False, 0) cycling_section.pack_start(cycle_draw_frame, False, False, 0) cycling_section_box = Gtk.HBox() cycling_section_box.pack_start(cycling_section, False, False, 30) cycling_box = Gtk.VBox() cycling_box.pack_start(cycling_label_box, False, False, 4) cycling_box.pack_start(cycling_section_box, False, False, 4) focus_label = Gtk.Label() focus_label.set_markup("Window focus") focus_void = Gtk.Label(" ") focus_label_box = Gtk.HBox() focus_label_box.pack_start(focus_label, False, False, 10) focus_label_box.pack_start(focus_void, True, True, 0) prevent_focus_stealing = Gtk.CheckButton("Activate focus stealing prevention") prevent_focus_stealing.set_active(get_prevent_focus_stealing()) prevent_focus_stealing.connect("toggled", set_prevent_focus_stealing) focus_hint = Gtk.CheckButton("Honor standard ICCCM focus hint") focus_hint.set_active(get_focus_hint()) focus_hint.connect("toggled", set_focus_hint) window_raise_label = Gtk.Label() window_raise_label.set_markup("When a window raises itself:") window_raise_void = Gtk.Label(" ") window_raise_label_box = Gtk.HBox() window_raise_label_box.pack_start(window_raise_label, False, False, 30) window_raise_label_box.pack_start(window_raise_void, True, True, 0) activate_action_box = Gtk.VBox() activate_action_bring = Gtk.RadioButton.new_with_label_from_widget(None, "Bring window on current workspace") activate_action_bring.connect("toggled", set_activate_action, "bring") if get_activate_action() == "bring": activate_action_bring.set_active(True) activate_action_switch = Gtk.RadioButton.new_from_widget(activate_action_bring) activate_action_switch.set_label("Switch to window's workspace") activate_action_switch.connect("toggled", set_activate_action, "switch") if get_activate_action() == "switch": activate_action_switch.set_active(True) activate_action_none = Gtk.RadioButton.new_from_widget(activate_action_bring) activate_action_none.set_label("Do nothing") activate_action_none.connect("toggled", set_activate_action, "none") if get_activate_action() == "none": activate_action_none.set_active(True) activate_action_box.pack_start(activate_action_bring, False, False, 0) activate_action_box.pack_start(activate_action_switch, False, False, 0) activate_action_box.pack_start(activate_action_none, False, False, 0) activate_action_wrapper = Gtk.HBox() activate_action_wrapper.pack_start(activate_action_box, False, False, 50) focus_section = Gtk.VBox() focus_section.pack_start(prevent_focus_stealing, False, False, 0) focus_section.pack_start(focus_hint, False, False, 0) focus_section.pack_start(window_raise_label_box, False, False, 10) focus_section.pack_start(activate_action_wrapper, False, False, 0) focus_section_box = Gtk.HBox() focus_section_box.pack_start(focus_section, False, False, 30) focus_box = Gtk.VBox() focus_box.pack_start(focus_label_box, False, False, 4) focus_box.pack_start(focus_section_box, False, False, 4) accessibility_label = Gtk.Label() accessibility_label.set_markup("Accessibility") accessibility_void = Gtk.Label(" ") accessibility_label_box = Gtk.HBox() accessibility_label_box.pack_start(accessibility_label, False, False, 10) accessibility_label_box.pack_start(accessibility_void, True, True, 0) raise_with_any_button = Gtk.CheckButton("Raise windows when any pointer button is pressed") raise_with_any_button.set_active(get_raise_with_any_button()) raise_with_any_button.connect("toggled", set_raise_with_any_button) borderless_maximize = Gtk.CheckButton("Hide frames of maximized windows") borderless_maximize.set_active(get_borderless_maximize()) borderless_maximize.connect("toggled", set_borderless_maximize) global restore_on_move restore_on_move = Gtk.CheckButton("Restore original size of maximized windows when moving") restore_on_move.set_active(get_restore_on_move()) restore_on_move.connect("toggled", set_restore_on_move) # Depends on restore_on_move global tile_on_move tile_on_move = Gtk.CheckButton("Automatically tile windows when moving toward the screen edge") tile_on_move.set_active(get_tile_on_move()) tile_on_move.connect("toggled", set_tile_on_move) if get_restore_on_move() == True: tile_on_move.set_sensitive(True) else: tile_on_move.set_sensitive(False) snap_resist = Gtk.CheckButton("Use edge resistance instead of window snapping") snap_resist.set_active(get_snap_resist()) snap_resist.connect("toggled", set_snap_resist) # Also disable repeat_urgent_blink global urgent_blink urgent_blink = Gtk.CheckButton("Notify of urgency with blinking window decorations") urgent_blink.set_active(get_urgent_blink()) urgent_blink.connect("toggled", set_urgent_blink) # Depends on urgent_blink global repeat_urgent_blink repeat_urgent_blink = Gtk.CheckButton("Keep urgent windows blinking repeatedly") repeat_urgent_blink.set_active(get_repeat_urgent_blink()) repeat_urgent_blink.connect("toggled", set_repeat_urgent_blink) if get_urgent_blink() == True: repeat_urgent_blink.set_sensitive(True) else: repeat_urgent_blink.set_active(False) repeat_urgent_blink.set_sensitive(False) set_repeat_urgent_blink_off() mousewheel_rollup = Gtk.CheckButton("Scroll on title bar to roll up the window") mousewheel_rollup.set_active(get_mousewheel_rollup()) mousewheel_rollup.connect("toggled", set_mousewheel_rollup) accessibility_section = Gtk.VBox() accessibility_section.pack_start(raise_with_any_button, False, False, 0) accessibility_section.pack_start(borderless_maximize, False, False, 0) accessibility_section.pack_start(restore_on_move, False, False, 0) accessibility_section.pack_start(tile_on_move, False, False, 0) accessibility_section.pack_start(snap_resist, False, False, 0) accessibility_section.pack_start(urgent_blink, False, False, 0) accessibility_section.pack_start(repeat_urgent_blink, False, False, 0) accessibility_section.pack_start(mousewheel_rollup, False, False, 0) accessibility_section_box = Gtk.HBox() accessibility_section_box.pack_start(accessibility_section, False, False, 30) accessibility_box = Gtk.VBox() accessibility_box.pack_start(accessibility_label_box, False, False, 4) accessibility_box.pack_start(accessibility_section_box, False, False, 4) workspaces_label = Gtk.Label() workspaces_label.set_markup("Workspaces") workspaces_void = Gtk.Label(" ") workspaces_label_box = Gtk.HBox() workspaces_label_box.pack_start(workspaces_label, False, False, 10) workspaces_label_box.pack_start(workspaces_void, True, True, 0) scroll_workspaces = Gtk.CheckButton("Scroll on desktop to change workspaces") scroll_workspaces.set_active(get_scroll_workspaces()) scroll_workspaces.connect("toggled", set_scroll_workspaces) wrap_layout = Gtk.CheckButton("Wrap workspaces") wrap_layout.set_active(get_wrap_layout()) wrap_layout.connect("toggled", set_wrap_layout) workspaces_section = Gtk.VBox() workspaces_section.pack_start(scroll_workspaces, False, False, 0) workspaces_section.pack_start(wrap_layout, False, False, 0) workspaces_section_box = Gtk.HBox() workspaces_section_box.pack_start(workspaces_section, False, False, 30) workspaces_box = Gtk.VBox() workspaces_box.pack_start(workspaces_label_box, False, False, 4) workspaces_box.pack_start(workspaces_section_box, False, False, 4) placement_label = Gtk.Label() placement_label.set_markup("Window placement") placement_void = Gtk.Label(" ") placement_label_box = Gtk.HBox() placement_label_box.pack_start(placement_label, False, False, 10) placement_label_box.pack_start(placement_void, True, True, 0) placement_ratio_label = Gtk.Label("Minimum window size to trigger smart placement:") placement_ratio_void = Gtk.Label(" ") placement_ratio_label_box = Gtk.HBox() placement_ratio_label_box.pack_start(placement_ratio_label, False, False, 0) placement_ratio_label_box.pack_start(placement_ratio_void, True, True, 0) placement_ratio_small = Gtk.Label() placement_ratio_small.set_markup("Small") placement_ratio_large = Gtk.Label() placement_ratio_large.set_markup("Large") placement_ratio = Gtk.HScale() placement_ratio.set_range(0, 100) placement_ratio.set_increments(1, 1) placement_ratio.set_digits(0) try: placement_ratio.set_value(get_placement_ratio()) except: placement_ratio.set_value(20) placement_ratio.connect("value-changed", set_placement_ratio) placement_ratio_box = Gtk.HBox() placement_ratio_box.pack_start(placement_ratio_small, False, False, 15) placement_ratio_box.pack_start(placement_ratio, True, True, 0) placement_ratio_box.pack_start(placement_ratio_large, False, False, 15) placement_mode_label = Gtk.Label("By default, place windows:") placement_mode_void = Gtk.Label(" ") placement_mode_label_box = Gtk.HBox() placement_mode_label_box.pack_start(placement_mode_label, False, False, 0) placement_mode_label_box.pack_start(placement_mode_void, False, False, 0) placement_mode_center = Gtk.RadioButton.new_with_label_from_widget(None, "At the center of the screen") placement_mode_center.connect("toggled", set_placement_mode, "center") if get_placement_mode() == "center": placement_mode_center.set_active(True) placement_mode_mouse = Gtk.RadioButton.new_from_widget(placement_mode_center) placement_mode_mouse.set_label("Under the pointer") placement_mode_mouse.connect("toggled", set_placement_mode, "mouse") if get_placement_mode() == "mouse": placement_mode_mouse.set_active(True) placement_mode_box = Gtk.VBox() placement_mode_box.pack_start(placement_mode_center, False, False, 0) placement_mode_box.pack_start(placement_mode_mouse, False, False, 0) placement_mode_wrapper = Gtk.HBox() placement_mode_wrapper.pack_start(placement_mode_box, True, True, 10) placement_section = Gtk.VBox() placement_section.pack_start(placement_ratio_label_box, False, False, 4) placement_section.pack_start(placement_ratio_box, False, False, 4) placement_section.pack_start(placement_mode_label_box, False, False, 4) placement_section.pack_start(placement_mode_wrapper, False, False, 4) placement_section_box = Gtk.HBox() placement_section_box.pack_start(placement_section, True, True, 30) placement_box = Gtk.VBox() placement_box.pack_start(placement_label_box, False, False, 4) placement_box.pack_start(placement_section_box, False, False, 4) page_adv.pack_start(cycling_box, False, False, 10) page_adv.pack_start(focus_box, False, False, 0) page_adv.pack_start(accessibility_box, False, False, 10) page_adv.pack_start(workspaces_box, False, False, 0) page_adv.pack_start(placement_box, False, False, 10) ############################## ### Main window structure. ### ############################## mainbook = Gtk.Notebook() mainbook.append_page(scroll_wman, page_wman_lab) mainbook.append_page(scroll_point, page_point_lab) mainbook.append_page(scroll_short, page_short_lab) mainbook.append_page(scroll_effect, page_effect_lab) mainbook.append_page(scroll_adv, page_adv_lab) mainb = Gtk.VBox(10, 10) mainb.pack_start(mainbook, True, True, 10) mainb1 = Gtk.HBox(10, 10) mainb1.pack_start(mainb, True, True, 10) self.add(mainb1) if __name__ == '__main__': window = ControlCenter() window.connect("delete-event", Gtk.main_quit) window.show_all() Gtk.main()