def __init__(self, setting_path, folder):
self.win = Gtk.Window()
self.win.set_default_size(800, 500)
#HeadBar
self.head = Gtk.HeaderBar()
self.head.props.show_close_button = True
self.head.props.title = g("PlankSetting")
self.win.set_titlebar(self.head)
#instance
self.ins = Window(setting_path, folder)
self.themes = Theme(setting_path, folder)
self.adda = AddApps(setting_path, folder)
self.box = Gtk.VBox()
self.menu = Gtk.MenuBar()
self.menu.set_hexpand(True)
self.plankmenu = Gtk.MenuItem(g("Menu"))
self.menu.append(self.plankmenu)
self.m = Gtk.Menu()
self.plankmenu.set_submenu(self.m)
""" Translate """
self.tra = Gtk.MenuItem(g("Translate this Application"))
self.tra.connect('activate', self.translation)
self.m.append(self.tra)
""" Report a bug """
self.bug = Gtk.MenuItem(g("Report a bug"))
self.bug.connect('activate', self.report)
self.m.append(self.bug)
""" About """
self.abt = Gtk.MenuItem(g("About"))
self.abt.connect('activate', self.about)
self.m.append(self.abt)
""" Exit """
self.xit = Gtk.MenuItem(g("Exit"))
self.xit.connect('activate', self.destroy)
self.m.append(self.xit)
""" Tabs """
self.tab = Gtk.Notebook()
self.tab.append_page(self.ins.scroll, Gtk.Label(g("General")))
self.tab.append_page(self.themes.box, Gtk.Label(g("Themes")))
self.tab.append_page(self.adda.box, Gtk.Label(g("Group Apps")))
self.head.pack_start(self.menu)
self.box.pack_end(self.tab, True, True, 25)
#self.win = HeaderBarWindow()
self.win.add(self.box)
self.win.show_all()
self.win.connect("destroy", self.destroy)
def addgroup(self, widget):
self.dialog = Gtk.Dialog(title=g("New Group"), buttons=(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OK, Gtk.ResponseType.OK))
label = Gtk.Label(g("Enter the Group name"))
entry = Gtk.Entry()
box = self.dialog.get_content_area()
box.add(label)
box.add(entry)
box.show_all()
response = self.dialog.run()
if response == Gtk.ResponseType.OK:
if len(entry.get_text()) > 0:
with open(self.dockitems + entry.get_text() + ".dockitem", 'w') as rf:
rf.write("[PlankItemsDockItemPreferences]\nLauncher=file://" + self.groupdir + entry.get_text())
self.makedire(self.groupdir + entry.get_text())
self.refresh(self.liststore, self.groupdir)
self.dialog.destroy()
def addfunc(self, widget):
f = widget.get_filename()
bn = os.path.basename(f)
name = bn[:bn.find(".")+1]
path = self.theme_path + '/' + name
newpath = self.theme_path + '/' + name[:name.find('_')].capitalize()
if f.find('.') != -1:
if f[f.find('.')+1:] == 'rar':
try:
with RarFile(f, 'r') as fi:
if (len(fi.namelist()) == 2) and ('dock.theme' in fi.namelist()) and ('hover.theme' in fi.namelist()):
fi.extractall(self.theme_path+'/'+name[:name.find('_')].capitalize(), fi.namelist())
os.system("unrar x {0} {1}".format(f, self.theme_path))
except:
msg = Gtk.MessageDialog(message_type = Gtk.MessageType.WARNING, message_format = g("You dont have a UNRAR program\nPlease make sure to install it before!"))
msg.run()
msg.destroy()
elif f[f.find('.')+1:] == 'tar':
with tarfile.TarFile(f, 'r') as fi:
if (len(fi.getnames()) == 2) and ('dock.theme' in fi.getnames()) and ('hover.theme' in fi.getnames()):
fi.extractall(self.theme_path+'/'+name[:name.find('_')].capitalize(), fi.namelist())
elif f[f.find('.')+1:] == 'tar.bz2':
with tarfile.open(f, 'r') as fi:
i = 0
for a in fi.getmembers():
if (name+'/'+a.name == 'dock.theme') or (name+'/'+a.name == 'hover.theme'):
i += 1
fi.extractall(self.theme_path, fi.getmembers())
elif f[f.find('.')+1:] == 'tar.gz':
with tarfile.open(f, 'r') as fi:
i = 0
for a in fi.getmembers():
if (name+'/'+a.name == 'dock.theme') or (name+'/'+a.name == 'hover.theme'):
i += 1
fi.extractall(self.theme_path, fi.getmembers())
elif f[f.find('.')+1:] == 'zip':
try:
with zipfile.ZipFile(f, 'r') as fi:
if (len(fi.namelist()) == 2) and ('dock.theme' in fi.namelist()) and ('hover.theme' in fi.namelist()):
fi.extractall(self.theme_path+'/'+name[:name.find('_')].capitalize(), fi.namelist())
except:
msg = Gtk.MessageDialog(message_type = Gtk.MessageType.WARNING, message_format = g("You dont have a UNZIP program\nPlease make sure to install it before!"))
msg.run()
msg.destroy()
else:
msg = Gtk.MessageDialog(message_type = Gtk.MessageType.WARNING, message_format = g("The theme format is not supported!"))
msg.run()
msg.destroy()
try:
os.rename(path, newpath)
except:
pass
self.refresh(self.liststore)
def about(self, widget):
about = Gtk.AboutDialog()
about.set_program_name(g("PlankSetting"))
about.set_logo(
GdkPixbuf
.Pixbuf.new_from_file("/usr/share/pixmaps/planksetting.png"))
about.set_icon(
GdkPixbuf.Pixbuf
.new_from_file("/usr/share/pixmaps/planksetting_logo.png"))
about.set_version("0.1.3.1")
about.set_comments(
g("A stupid application to customize plank dock easily."))
about.set_copyright("Copyright (c) 2014-2015 Karim Oulad Chalha")
about.set_website("http://karim88.github.io/PlankSetting/")
about.set_website_label(g("PlankSetting website"))
about.set_authors(["Karim Oulad Chalha"])
about.set_license(g("GPL v3"))
about.set_translator_credits(g("translator-credits"))
about.run()
about.destroy()
def __init__(self, setting_path, folder):
self.theme_path = os.path.expanduser("~") + "/.local/share/plank/themes"
self.sys_theme_path = "/usr/share/plank/themes"
self.setting = setting_path + folder + "/settings"
self.win = Gtk.Window()
self.scroll = Gtk.ScrolledWindow()
self.liststore = Gtk.ListStore(str)
self.refresh(self.liststore)
self.treeview = Gtk.TreeView(model=self.liststore)
self.treeviewcolumn = Gtk.TreeViewColumn(g("Themes"))
self.treeview.append_column(self.treeviewcolumn)
self.cellrenderertext = Gtk.CellRendererText()
self.treeviewcolumn.pack_start(self.cellrenderertext, True)
self.treeviewcolumn.add_attribute(self.cellrenderertext, "text", 0)
self.select = self.treeview.get_selection()
self.read_file()
self.select.connect("changed", self.on_tree_selection_changed)
self.button = Gtk.ButtonBox()
self.button.set_spacing(15)
self.b = Gtk.FileChooserButton()
self.b.set_tooltip_text(g("Add a theme"))
self.b.connect('file-set', self.addfunc)
self.button.add(self.b)
self.b1 = Gtk.Button(stock=Gtk.STOCK_REMOVE)
self.b1.set_tooltip_text(g("Remove a theme"))
self.b1.connect('clicked', self.delfunc)
self.button.add(self.b1)
self.scroll.add(self.treeview)
self.box = Gtk.VBox()
self.box.pack_start(self.scroll, True, True, 15)
self.box.pack_start(self.button, False, False, 15)
def toggled(widget):
value = 0
if widget.get_active():
if widget.get_label() == g("Hide")or widget.get_label()== g("Left") or widget.get_label() == g("Panel mode"):
value = 0
elif widget.get_label() == g("Intelligently hide") or widget.get_label() == g("Right") or widget.get_label() == g("Right aligned"):
value = 1
elif widget.get_label() == g("Auto hide") or widget.get_label() == g("Top") or widget.get_label() == g("Left aligned"):
value = 2
elif widget.get_label() == g("Dodge") or widget.get_label() == g("Bottom") or widget.get_label() == g("Centered"):
value = 3
if nmbr == 1:
write_func(read_func(self.setting), self.setting, "HideMode", value)
elif nmbr == 2:
write_func(read_func(self.setting), self.setting, "Position", value)
elif nmbr == 3:
write_func(read_func(self.setting), self.setting, "Alignment", value)
elif nmbr == 4:
write_func(read_func(self.setting), self.setting, "ItemsAlignment", value)
def delfunc(self, widget):
model, treeiter = self.select.get_selected()
sys = False
try:
if model[treeiter][0] in os.listdir(self.theme_path):
rmtheme = self.theme_path+'/'+model[treeiter][0]
else:
rmtheme = self.sys_theme_path+'/'+model[treeiter][0]
sys = True
msg = Gtk.MessageDialog(None, 0, Gtk.MessageType.WARNING, Gtk.ButtonsType.OK_CANCEL, g("Do you really wanna remove the theme {} ?").format(model[treeiter][0]))
resp = msg.run()
if resp == Gtk.ResponseType.OK:
if sys:
os.system("gksu 'rm -r {0}'".format(rmtheme))
else:
shutil.rmtree(rmtheme)
msg.destroy()
except:
pass
self.refresh(self.liststore)
def __init__(self, setting_path, folder):
self.win = Gtk.Window()
self.setting = setting_path + folder + "/settings"
self.scroll = Gtk.ScrolledWindow()
#Whether to show only windows of the current workspace.
self.label1 = Gtk.Label(g("Show windows"))
self.label1.set_tooltip_text(
g("Show only windows of the current workspace."))
self.switch = Gtk.Switch()
self.switch.connect("notify::active", self.switched)
#The size of dock icons (in pixels).
self.label2 = Gtk.Label(g("Dock size"))
self.label2.set_tooltip_text(g("The size of dock icons (in pixels)."))
self.adjustment = Gtk.Adjustment(32, 16, 48, 1, 5, 0)
self.spinbutton = Gtk.SpinButton(adjustment=self.adjustment)
self.spinbutton.connect("value-changed", self.spinb_chenged)
#If 0, the dock won't hide. If 1,
#the dock intelligently hides. If 2, the dock auto-hides.
#If 3, the dock dodges active maximized windows.
self.label3 = Gtk.Label(g("Display mode"))
self.label3.set_tooltip_text(g("The display of the dock."))
self.display = self.radios(
g("Don't hide"), g("Intelligently hide"),
g("Auto hide"), g("Dodge"), 1)
#Time (in ms) to wait before unhiding the dock.
self.label4 = Gtk.Label(g("Waiting time"))
self.label4.set_tooltip_text(
g("Time (in ms) to wait before unhiding the dock."))
self.adj = Gtk.Adjustment(0, 0, 60, 1, 5, 0)
self.spintime = Gtk.SpinButton(adjustment=self.adj)
self.spintime.connect("value-changed", self.spint_chenged)
#The monitor number for the dock. Use -1 to keep on the primary monitor.
self.label5 = Gtk.Label(g("The monitor number for the dock."))
#The position for the dock on the monitor.
#If 0, left. If 1, right. If 2, top. If 3, bottom.
self.label6 = Gtk.Label(g("Position"))
self.label6.set_tooltip_text(
g("The position for the dock on the monitor."))
self.pos = self.radios(g("Left"), g("Right"), g("Top"), g("Bottom"), 2)
#The dock's position offset from center (in percent).
self.label7 = Gtk.Label(g("Offset"))
self.label7.set_tooltip_text(
g("The dock's position offset from center (in percent)."))
self.adj1 = Gtk.Adjustment(0, 0, 100, 1, 5, 0)
self.offset = Gtk.SpinButton(adjustment=self.adj1)
self.offset.connect("value-changed", self.offset_chenged)
#The alignment for the dock on the monitor's edge.
#If 0, panel-mode. If 1, right-aligned.
#If 2, left-aligned. If 3, centered.
self.label8 = Gtk.Label(g("Alignment"))
self.label8.set_tooltip_text(
g("The alignment for the dock on the monitor's edge."))
self.alignment = self.radios(
g("Panel mode"), g("Right aligned"),
g("Left aligned"), g("Centered"), 3)
#The alignment of the items in this dock if panel-mode is used.
#If 1, right-aligned. If 2, left-aligned. If 3, centered.
self.label9 = Gtk.Label(g("Item alignment"))
self.label9.set_tooltip_text(
g("The alignment of the items in this dock."))
self.itemalig = self.radios(
g("Panel mode"), g("Right aligned"),
g("Left aligned"), g("Centered"), 4)
#Whether to prevent drag'n'drop actions and lock items on the dock.
self.label10 = Gtk.Label(g("Drag'n'drop"))
self.label10.set_tooltip_text(
g("Prevent drag'n'drop actions and lock items on the dock."))
self.drag = Gtk.Switch()
self.drag.connect("notify::active", self.switched1)
#################
self.read_file()
#################
self.table = Gtk.VBox()
self.table.pack_start(self.fbox(self.label1, self.switch),
False, False, 5)
self.table.pack_start(self.fbox(self.label2, self.spinbutton),
False, False, 5)
self.table.pack_start(self.fbox(self.label3, self.display[0]),
False, False, 5)
self.table.pack_start(self.fbox(self.label4, self.spintime),
False, False, 5)
self.table.pack_start(self.fbox(self.label5),
False, False, 5)
self.table.pack_start(self.fbox(self.label6, self.pos[0]),
False, False, 5)
self.table.pack_start(self.fbox(self.label7, self.offset),
False, False, 5)
self.table.pack_start(self.fbox(self.label8, self.alignment[0]),
False, False, 5)
self.table.pack_start(self.fbox(self.label9, self.itemalig[0]),
False, False, 5)
self.table.pack_start(self.fbox(self.label10, self.drag),
False, False, 5)
self.scroll.add(self.table)
g = gettext.gettext
setting_path = os.listdir(os.path.expanduser("~") + "/.config/plank")
folder = ""
def choosed(widget):
folder = widget.get_label()
win.hide()
main = Mainwin(os.path.expanduser("~") + "/.config/plank/", folder)
main.main()
if __name__ == "__main__":
if len(setting_path) > 1:
win = Gtk.Window()
label = Gtk.Label(g("Choose the dock:"))
box = Gtk.VBox()
box.pack_start(label, False, False, 5)
for a in setting_path:
button = Gtk.Button(a)
button.connect('clicked', choosed)
box.pack_start(button, False, False, 5)
win.add(box)
win.show_all()
Gtk.main()
else:
for a in setting_path:
folder = a
main = Mainwin(os.path.expanduser("~") + "/.config/plank/", folder)
main.main()
def __init__(self, path_setting, folder):
self.selectedgroup, self.selectedapp = str(), str()
self.appname, self.appnom = str(), str()
self.groupdir = os.path.expanduser("~") + "/.config/plank/" + folder + "/groupapps/"
self.dockitems = os.path.expanduser("~") + "/.config/plank/" + folder + "/launchers/"
self.makedire(self.groupdir)
self.win = Gtk.Window()
#self.scroll = Gtk.ScrolledWindow()
self.box = Gtk.VBox()
self.hb1 = Gtk.HBox()
self.hb2 = Gtk.HBox()
### Listview
self.liststore = Gtk.ListStore(str)
self.refresh(self.liststore, self.groupdir)
self.treeview = Gtk.TreeView(model=self.liststore)
self.treeviewcolumn = Gtk.TreeViewColumn(g("Group of Apps"))
self.treeview.append_column(self.treeviewcolumn)
self.cellrenderertext = Gtk.CellRendererText()
self.treeviewcolumn.pack_start(self.cellrenderertext, True)
self.treeviewcolumn.add_attribute(self.cellrenderertext, "text", 0)
self.select = self.treeview.get_selection()
self.select.connect("changed", self.on_selection_changed)
self.store = Gtk.ListStore(str)
self.view = Gtk.TreeView(model=self.store)
self.viewcolumn = Gtk.TreeViewColumn(g("Application"))
self.view.append_column(self.viewcolumn)
self.cellrenderertext = Gtk.CellRendererText()
self.viewcolumn.pack_start(self.cellrenderertext, True)
self.viewcolumn.add_attribute(self.cellrenderertext, "text", 0)
self.select1 = self.view.get_selection()
self.select1.connect("changed", self.on_tree_selection_changed)
# self.listbox = Gtk.ListBox()
# for g in os.listdir(self.groupdir):
# self.listbox.add(Gtk.Label(g))
# self.listbox.connect("row-activated", self.groupsel)
self.hb1.pack_start(self.treeview, True, True, 5)
self.hb1.pack_end(self.view, True, True, 5)
### Button
self.addg = Gtk.Button(stock=Gtk.STOCK_ADD)
self.addg.connect('clicked', self.addgroup)
self.addg.set_tooltip_text(g("Add a Group"))
#
self.delg = Gtk.Button(stock=Gtk.STOCK_REMOVE)
self.delg.set_sensitive(False)
self.delg.connect('clicked', self.delgroup)
self.delg.set_tooltip_text(g("Delete a Group"))
#
self.addapp = Gtk.Button(stock=Gtk.STOCK_ADD)
self.addapp.set_sensitive(False)
self.addapp.connect('clicked', self.appchooser)
self.addapp.set_tooltip_text(g("Add a Application"))
#
self.delapp = Gtk.Button(stock=Gtk.STOCK_REMOVE)
self.delapp.set_sensitive(False)
self.delapp.connect('clicked', self.delapplication)
self.delapp.set_tooltip_text(g("Delete a Application"))
self.hb2.pack_start(self.addg, False, False, 5)
self.hb2.pack_start(self.delg, False, False, 5)
self.hb2.pack_end(self.delapp, False, False, 5)
self.hb2.pack_end(self.addapp, False, False, 5)
self.box.pack_start(self.hb1, True, True, 15)
self.box.pack_start(self.hb2, False, False, 15)
