2572 lines
96 KiB
Plaintext
2572 lines
96 KiB
Plaintext
|
#!/usr/bin/env python3
|
||
|
#
|
||
|
# by Kendall Weaver <kendall@peppermintos.com>
|
||
|
# for Peppermint OS <http://peppermintos.com>
|
||
|
#
|
||
|
# 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(' <property name="title_font" type="string" value="', '')
|
||
|
b = a.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", "<Alt>")
|
||
|
c = b.replace("Mod4", "<Super>")
|
||
|
d = c.replace("Control", "<Control>")
|
||
|
e = d.replace("Shift", "<Shift>")
|
||
|
return e.replace("+", "")
|
||
|
|
||
|
|
||
|
# Return the xfce4 format to native xbindkeys format.
|
||
|
def unbindformat(a):
|
||
|
b = a.replace("<Alt>", "Alt + ")
|
||
|
c = b.replace("<Super>", "Mod4 + ")
|
||
|
d = c.replace("<Control>", "Control + ")
|
||
|
e = d.replace("<Shift>", "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>", "Control+")
|
||
|
new2 = new1.replace("<Alt>", "Alt+")
|
||
|
new3 = new2.replace("<Super>", "Mod4+")
|
||
|
new4 = new3.replace("<Shift>", "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>", "Control+")
|
||
|
new2 = new1.replace("<Alt>", "Alt+")
|
||
|
new3 = new2.replace("<Super>", "Mod4+")
|
||
|
new4 = new3.replace("<Shift>", "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("<b>Are you sure you want to perform this action?</b>")
|
||
|
|
||
|
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 + "<Shift>"
|
||
|
if _control.get_active():
|
||
|
newshortcut = newshortcut + "<Control>"
|
||
|
if _super.get_active():
|
||
|
newshortcut = newshortcut + "<Super>"
|
||
|
if _alt.get_active():
|
||
|
newshortcut = newshortcut + "<Alt>"
|
||
|
|
||
|
if _shift.get_active() == False and _control.get_active() == False and _super.get_active() == False and \
|
||
|
_alt.get_active() == False:
|
||
|
assign_void.set_markup("<b>Specify modifier(s)</b>")
|
||
|
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("<b>Invalid character</b>")
|
||
|
|
||
|
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("<b>Theme</b>")
|
||
|
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("<b>Title font</b>")
|
||
|
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("<b>Title alignment</b>")
|
||
|
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("<b>Number of workspaces:</b>")
|
||
|
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("<b>Focus model</b>")
|
||
|
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("<i>Short</i>")
|
||
|
focus_delay_long = Gtk.Label()
|
||
|
focus_delay_long.set_markup("<i>Long</i>")
|
||
|
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("<b>New window focus</b>")
|
||
|
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("<b>Raise on focus</b>")
|
||
|
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("<i>Short</i>")
|
||
|
raise_delay_long = Gtk.Label()
|
||
|
raise_delay_long.set_markup("<i>Long</i>")
|
||
|
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("<b>Raise on click</b>")
|
||
|
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("<b>Window Snapping</b>")
|
||
|
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("<i>Small</i>")
|
||
|
snap_width_wide = Gtk.Label()
|
||
|
snap_width_wide.set_markup("<i>Wide</i>")
|
||
|
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("<b>Wrap workspaces when reaching the screen edge</b>")
|
||
|
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("<i>Small</i>")
|
||
|
wrap_resistance_wide = Gtk.Label()
|
||
|
wrap_resistance_wide.set_markup("<i>Wide</i>")
|
||
|
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("<b>Hide content of windows</b>")
|
||
|
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("<b>Title bar double click action</b>")
|
||
|
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("<b>Keyboard options</b>")
|
||
|
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("<b>Pointer options</b>")
|
||
|
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("<b>Touchpad options</b>")
|
||
|
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("<b>Window Manager Shortcuts</b>")
|
||
|
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("<b>System Shortcuts</b>")
|
||
|
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("<b>Enable desktop effects</b>")
|
||
|
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("<i>Transparent</i>")
|
||
|
frame_opacity_right = Gtk.Label()
|
||
|
frame_opacity_right.set_markup("<i>Opaque</i>")
|
||
|
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("<i>Transparent</i>")
|
||
|
inactive_opacity_right = Gtk.Label()
|
||
|
inactive_opacity_right.set_markup("<i>Opaque</i>")
|
||
|
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("<i>Transparent</i>")
|
||
|
move_opacity_right = Gtk.Label()
|
||
|
move_opacity_right.set_markup("<i>Opaque</i>")
|
||
|
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("<i>Transparent</i>")
|
||
|
resize_opacity_right = Gtk.Label()
|
||
|
resize_opacity_right.set_markup("<i>Opaque</i>")
|
||
|
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("<i>Transparent</i>")
|
||
|
popup_opacity_right = Gtk.Label()
|
||
|
popup_opacity_right.set_markup("<i>Opaque</i>")
|
||
|
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("<b>Window cycling</b>")
|
||
|
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("<b>Window focus</b>")
|
||
|
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("<i>When a window raises itself:</i>")
|
||
|
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("<b>Accessibility</b>")
|
||
|
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("<b>Workspaces</b>")
|
||
|
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("<b>Window placement</b>")
|
||
|
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("<i>Small</i>")
|
||
|
placement_ratio_large = Gtk.Label()
|
||
|
placement_ratio_large.set_markup("<i>Large</i>")
|
||
|
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()
|