| •1 |
import gi |
| 2 |
gi.require_version('Gtk', '3.0') |
| 3 |
from gi.repository import Gtk |
| 4 |
from gi.repository import GObject |
| 5 |
import re |
| 6 |
from cb_itemtypes import * |
| 7 |
from cbmenu import * |
| 8 |
from cbutil import TabButton, CommandText |
| 9 |
from lxml import etree |
| 10 |
from xdg import BaseDirectory |
| 11 |
import os,re |
| •12 |
import configparser |
| 13 |
import shlex |
| 14 |
|
| 15 |
try: |
| 16 |
import dbus |
| 17 |
except ImportError: |
| 18 |
dbus = None |
| 19 |
|
| •20 |
class CBEditor(Gtk.Window): |
| 21 |
def __init__(self): |
| •22 |
GObject.GObject.__init__(self) |
| 23 |
self.set_title("Compiz Boxmenu Editor") |
| 24 |
self.set_icon_name('cbmenu') |
| 25 |
self.set_border_width(5) |
| 26 |
self.set_size_request(600, 400) |
| •27 |
self.vbox=Gtk.VBox(False, 2) |
| 28 |
self.connect('destroy', Gtk.main_quit) |
| 29 |
hbox_main=Gtk.HPaned() |
| 30 |
|
| •31 |
toolbar=Gtk.Toolbar() |
| 32 |
|
| •33 |
new_button = Gtk.MenuToolButton(Gtk.STOCK_NEW) |
| 34 |
new_button.set_menu(self.make_new_menu()) |
| 35 |
new_button.connect('clicked', self.new_item_dialog) |
| 36 |
new_button.set_tooltip_text("Create a new menu file or menu item") |
| 37 |
|
| •38 |
#edit_button = Gtk.ToolButton(Gtk.STOCK_EDIT) # necessary? |
| 39 |
|
| •40 |
save_button = Gtk.MenuToolButton(Gtk.STOCK_SAVE) |
| 41 |
save_button.set_menu(self.make_save_menu()) |
| 42 |
save_button.connect('clicked', self.save_one) |
| 43 |
save_button.set_tooltip_text("Save the current menu") |
| 44 |
|
| •45 |
generate_button = Gtk.ToolButton(Gtk.STOCK_CONVERT) |
| 46 |
generate_button.connect('clicked', self.generated_item) #need to import other menus |
| 47 |
generate_button.set_tooltip_text('Generate menu entries from a pipemenu script') |
| 48 |
|
| •49 |
delete_button = Gtk.MenuToolButton(Gtk.STOCK_DELETE) |
| 50 |
delete_button.set_menu(self.make_delete_menu()) |
| 51 |
delete_button.connect('clicked', self.delete_item) |
| 52 |
delete_button.set_tooltip_text('Delete the current menu item') |
| 53 |
|
| •54 |
reload_button = Gtk.ToolButton(Gtk.STOCK_REFRESH) |
| 55 |
reload_button.connect('clicked', self.reload_menu) |
| 56 |
reload_button.set_tooltip_text('Reload the daemon') |
| 57 |
|
| •58 |
#settings_button = Gtk.ToolButton(Gtk.STOCK_PREFERENCES) |
| 59 |
#settings_button.connect('clicked', self.show_settings) |
| 60 |
|
| •61 |
about_button = Gtk.ToolButton(Gtk.STOCK_ABOUT) |
| 62 |
about_button.connect('clicked', self.show_about_dialog) |
| 63 |
about_button.set_tooltip_text('Show some information about this program') |
| 64 |
|
| •65 |
sep=Gtk.SeparatorToolItem() |
| 66 |
sep2=Gtk.SeparatorToolItem() |
| 67 |
sep.set_draw(False) |
| 68 |
sep.set_expand(True) |
| 69 |
sep2.set_draw(False) |
| 70 |
sep2.set_expand(True) |
| 71 |
toolbar.insert(new_button, 0) |
| 72 |
#toolbar.insert(edit_button, 1) |
| 73 |
toolbar.insert(save_button, 1) |
| 74 |
toolbar.insert(generate_button, 2) |
| 75 |
toolbar.insert(delete_button, 3) |
| 76 |
toolbar.insert(sep, 4) |
| 77 |
#toolbar.insert(undo_button, 6) |
| 78 |
#toolbar.insert(redo_button, 7) |
| 79 |
toolbar.insert(sep2, 5) |
| 80 |
toolbar.insert(reload_button, 6) |
| 81 |
#toolbar.insert(settings_button, 8) |
| 82 |
toolbar.insert(about_button, 7) |
| 83 |
|
| •84 |
self.vbox.pack_start(toolbar, expand=False, fill=True, padding=0) |
| 85 |
|
| •86 |
listview=Gtk.TreeView() |
| 87 |
self.list_menus() |
| 88 |
listview.set_model(self.menu_list) |
| 89 |
listview.connect('row-activated',self.open_menu_file) |
| •90 |
scrolled=Gtk.ScrolledWindow() |
| 91 |
scrolled.add(listview) |
| 92 |
|
| •93 |
scrolled.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC) |
| 94 |
scrolled.set_size_request(150,-1) |
| 95 |
|
| 96 |
hbox_main.add(scrolled) |
| 97 |
|
| •98 |
cached = Gtk.TreeViewColumn('Cached?') |
| 99 |
listview.append_column(cached) |
| •100 |
cell = Gtk.CellRendererToggle() |
| 101 |
cell.set_activatable(True) |
| 102 |
cell.connect('toggled', self.update_cache) |
| •103 |
cached.pack_start(cell, expand=True) #, True, 0) |
| 104 |
cached.add_attribute(cell, "active", 0) |
| 105 |
|
| •106 |
name = Gtk.TreeViewColumn('Menu') |
| 107 |
listview.append_column(name) |
| •108 |
cell = Gtk.CellRendererText() |
| 109 |
name.pack_start(cell, expand=True) #, True, 0) |
| 110 |
name.add_attribute(cell,"text", 1) |
| 111 |
|
| •112 |
self.tabs=Gtk.Notebook() |
| 113 |
self.tabs.set_size_request(340,240) |
| 114 |
self.tabs.set_scrollable(True) |
| 115 |
self.tabs.connect('switch-page', self.get_current_menu) |
| 116 |
hbox_main.add(self.tabs) |
| 117 |
self.tabs.set_show_tabs(True) |
| •118 |
self.tabs.set_tab_pos(Gtk.PositionType.TOP) |
| 119 |
|
| •120 |
#self.hbox_item=Gtk.HBox(False, 2) |
| 121 |
|
| •122 |
self.vbox.pack_start(hbox_main, expand=True, fill=True, padding=0) |
| 123 |
#self.vbox.pack_end(self.hbox_item, expand=False, fill=False) |
| 124 |
self.add(self.vbox) |
| 125 |
self.show_all() |
| 126 |
|
| 127 |
def make_new_menu(self): |
| •128 |
new_menu=Gtk.Menu() |
| 129 |
for i in elementlist: |
| •130 |
new_item = Gtk.ImageMenuItem(i, Gtk.STOCK_NEW) |
| 131 |
new_item.connect('activate', self.make_new_item, i) |
| 132 |
new_menu.append(new_item) |
| 133 |
new_menu.show_all() |
| 134 |
return new_menu |
| 135 |
|
| 136 |
def make_delete_menu(self): |
| •137 |
delete_menu=Gtk.Menu() |
| 138 |
|
| •139 |
delete_item=Gtk.ImageMenuItem("Current Item") |
| 140 |
delete_item.connect('activate', self.delete_item) |
| 141 |
delete_menu.append(delete_item) |
| 142 |
|
| •143 |
delete_item=Gtk.ImageMenuItem("Current Menu") |
| 144 |
delete_item.connect('activate', self.delete_menu) |
| 145 |
delete_menu.append(delete_item) |
| 146 |
|
| 147 |
delete_menu.show_all() |
| 148 |
return delete_menu |
| 149 |
|
| 150 |
def make_save_menu(self): |
| •151 |
save_menu=Gtk.Menu() |
| 152 |
|
| •153 |
save_item=Gtk.ImageMenuItem("Current Menu") |
| 154 |
save_item.connect('activate', self.save_one) |
| 155 |
save_menu.append(save_item) |
| 156 |
|
| •157 |
save_item=Gtk.ImageMenuItem("All") |
| 158 |
save_item.connect('activate', self.save_all) |
| 159 |
save_menu.append(save_item) |
| 160 |
|
| 161 |
save_menu.show_all() |
| 162 |
return save_menu |
| 163 |
|
| 164 |
def delete_menu(self, widget): |
| •165 |
dialog = Gtk.MessageDialog(self, Gtk.DialogFlags.MODAL, Gtk.MessageType.WARNING, \ |
| 166 |
Gtk.ButtonsType.NONE, \ |
| 167 |
"Are you sure you want to delete the current menu? You cannot recover it after you do this!") |
| •168 |
dialog.add_buttons(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_DELETE, Gtk.ResponseType.ACCEPT) |
| 169 |
response = dialog.run() |
| 170 |
dialog.destroy() |
| •171 |
if response == Gtk.ResponseType.ACCEPT: |
| 172 |
idx=self.tabs.get_current_page() |
| 173 |
menu=self.tabs.get_nth_page(idx) |
| 174 |
for i in self.menu_list: |
| 175 |
if i[2]==menu.filename: |
| 176 |
break |
| 177 |
iter=self.menu_list.get_iter(j) |
| 178 |
self.menu_list.remove(iter) |
| 179 |
os.remove(menu.filename) |
| 180 |
if hasattr(menu, 'currently_editing'): |
| 181 |
menu.currently_editing.destroy() |
| 182 |
self.tabs.remove_page(idx) |
| 183 |
|
| 184 |
def delete_item(self, widget): |
| 185 |
idx=self.tabs.get_current_page() |
| 186 |
menu=self.tabs.get_nth_page(idx) |
| 187 |
menu.on_delete_clicked(self) |
| 188 |
|
| 189 |
def recursive_generate(self, widget, tree, pt=None): |
| 190 |
for element in tree.getchildren(): |
| 191 |
if element.tag=='menu': |
| 192 |
new_row=self.make_new_item(widget, "Menu", nd=element, parent=pt) |
| 193 |
self.recursive_generate(widget, element, pt=new_row) |
| 194 |
elif element.tag=='separator': |
| 195 |
self.make_new_item(widget, "Separator", nd=element, parent=pt) |
| 196 |
else: |
| 197 |
if element.attrib['type']=='windowlist': |
| 198 |
self.make_new_item(widget, "Window List", nd=element, parent=pt) |
| 199 |
elif element.attrib['type']=='viewportlist': |
| 200 |
self.make_new_item(widget, "Viewports List", nd=element, parent=pt) |
| 201 |
elif element.attrib['type']=='desktoplist': |
| 202 |
self.make_new_item(widget, "Desktops List", nd=element, parent=pt) |
| 203 |
elif element.attrib['type']=='documents': |
| 204 |
self.make_new_item(widget, "Recent Documents", nd=element, parent=pt) |
| 205 |
else: |
| 206 |
self.make_new_item(widget, element.attrib['type'].title(), nd=element, parent=pt) |
| 207 |
|
| 208 |
def new_item_dialog(self, widget): |
| •209 |
dialog=Gtk.Dialog('New Item', self,Gtk.DialogFlags.MODAL, \ |
| 210 |
buttons=(Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT, Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT)) |
| 211 |
dialog.set_size_request(250, 250) |
| 212 |
|
| 213 |
dialog.props.border_width = 6 |
| 214 |
dialog.vbox.props.spacing = 6 |
| 215 |
dialog.set_has_separator(False) |
| 216 |
|
| •217 |
model = Gtk.ListStore(str) |
| 218 |
for el in elementlist: |
| 219 |
model.append([el]) |
| 220 |
|
| •221 |
treeview = Gtk.TreeView(model) |
| 222 |
column = Gtk.TreeViewColumn(None, Gtk.CellRendererText(), text=0) |
| 223 |
treeview.set_headers_visible(False) |
| 224 |
treeview.append_column(column) |
| 225 |
|
| 226 |
treeview.connect('row-activated', self.on_row_activated) |
| 227 |
|
| •228 |
scroll = Gtk.ScrolledWindow() |
| 229 |
scroll.add(treeview) |
| •230 |
scroll.props.hscrollbar_policy = Gtk.PolicyType.NEVER |
| 231 |
scroll.props.vscrollbar_policy = Gtk.PolicyType.AUTOMATIC |
| 232 |
dialog.vbox.pack_start(scroll, expand=True, fill=True, padding=0) |
| 233 |
|
| 234 |
dialog.action_area.props.border_width = 0 |
| 235 |
|
| 236 |
dialog.show_all() |
| 237 |
|
| •238 |
if dialog.run() == Gtk.ResponseType.ACCEPT: |
| 239 |
m, r = treeview.get_selection().get_selected() |
| 240 |
if r: |
| 241 |
elementname = m[r][0] |
| 242 |
self.make_new_item(widget, elementname) |
| 243 |
else: |
| 244 |
dialog.destroy() |
| 245 |
return |
| 246 |
dialog.destroy() |
| 247 |
|
| 248 |
def on_row_activated(self, treeview, path, view_column): |
| •249 |
self.response(Gtk.ResponseType.ACCEPT) |
| 250 |
|
| 251 |
def generated_item(self, widget): |
| •252 |
dialog=Gtk.Dialog("Add generated items from pipemenu", self, Gtk.DialogFlags.MODAL, \ |
| 253 |
buttons=(Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT, Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT)) |
| 254 |
input=CommandText(label_text="Command", mode="Pipe Menu" , alternate_mode="Pipe Menu") |
| 255 |
dialog.vbox.add(input) |
| 256 |
dialog.vbox.show_all() |
| 257 |
input.combobox.hide() |
| 258 |
response=dialog.run() |
| •259 |
if response==Gtk.ResponseType.ACCEPT: |
| 260 |
process=subprocess.Popen(shlex.split(os.path.expanduser(input.entry.props.text)), \ |
| 261 |
stdout=subprocess.PIPE) |
| 262 |
try: |
| 263 |
stdout = process.communicate()[0] |
| 264 |
dummy_txt = "<menu name='Dummy'>{}</menu>".format(stdout) |
| 265 |
dummy_menu=etree.fromstring("<menu name='Dummy'>{}</menu>".format(stdout)) |
| 266 |
self.recursive_generate(widget, dummy_menu) |
| 267 |
dialog.destroy() |
| 268 |
except etree.XMLSyntaxError as e: |
| •269 |
message = Gtk.MessageDialog(parent=self, flags=0, |
| 270 |
type=Gtk.MessageType.ERROR, |
| 271 |
buttons=Gtk.ButtonsType.OK, message_format=None) |
| 272 |
msg = ("{}\n\nClick the gear icon in the dialog to check" |
| 273 |
" pipe output.").format(e.msg) |
| 274 |
message.set_markup(msg) |
| 275 |
message.run() |
| 276 |
message.destroy() |
| 277 |
finally: |
| 278 |
dialog.destroy() |
| 279 |
else: |
| 280 |
dialog.destroy() |
| 281 |
|
| 282 |
def make_new_item(self, widget, element_type, nd=None, parent=None): |
| 283 |
if element_type != 'Menu File': |
| 284 |
idx=self.tabs.get_current_page() |
| 285 |
menu=self.tabs.get_nth_page(idx) |
| 286 |
model=menu.treeview.get_model() |
| 287 |
m, r = menu.treeview.get_selection().get_selected() |
| 288 |
sibling = None |
| 289 |
if parent is not None: |
| 290 |
current = model[parent][0] |
| 291 |
if current.node.tag != 'menu': |
| 292 |
sibling = parent |
| 293 |
elif r: |
| 294 |
current = model[r][0] |
| 295 |
if current.node.tag == 'menu': |
| 296 |
parent = r |
| 297 |
else: |
| 298 |
parent = model[r].parent |
| 299 |
if parent is not None: |
| 300 |
parent = parent.iter |
| 301 |
sibling = r |
| 302 |
if parent: |
| 303 |
parentelement = model[parent][0] |
| 304 |
else: |
| 305 |
parentelement = menu.menu |
| 306 |
|
| 307 |
element = elementsbyname[element_type](node=nd) |
| 308 |
if sibling: |
| 309 |
position = parentelement.node.index(current.node) + 1 |
| 310 |
parentelement.node.insert(position, element.node) |
| 311 |
new_row=model.insert_after(parent, sibling, row=(element,)) |
| 312 |
else: |
| 313 |
new_row=model.append(parent, row=(element,)) |
| 314 |
parentelement.node.append(element.node) |
| •315 |
print("New %s created" % element_type) |
| 316 |
return new_row |
| 317 |
else: |
| 318 |
menu_path=BaseDirectory.xdg_config_home + "/compiz/boxmenu" |
| •319 |
dialog=Gtk.Dialog("Add a new file", self, Gtk.DialogFlags.MODAL, \ |
| 320 |
buttons=(Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT, Gtk.STOCK_CANCEL, Gtk.ResponseType.REJECT)) |
| 321 |
input=Gtk.Entry() |
| 322 |
dialog.vbox.add(Gtk.Label("Name of the new menu to be created, with .xml at the end:")) |
| 323 |
dialog.vbox.add(input) |
| 324 |
dialog.vbox.show_all() |
| 325 |
response=dialog.run() |
| •326 |
if response != Gtk.ResponseType.ACCEPT or \ |
| 327 |
input.props.text == "" or \ |
| 328 |
not input.props.text.endswith(".xml"): |
| 329 |
dialog.destroy() |
| 330 |
return |
| 331 |
path="%s/%s" %(menu_path, input.props.text) |
| 332 |
f = open(path, "w") |
| 333 |
f.write("<menu></menu>") |
| 334 |
f.close() |
| 335 |
self.menu_list.append([False,input.props.text, path]) |
| 336 |
dialog.destroy() |
| •337 |
print("New %s created" % element_type) |
| 338 |
|
| 339 |
def save_one(self, widget): |
| 340 |
idx=self.tabs.get_current_page() |
| 341 |
#ignore if tab isn't flagged |
| 342 |
#or if undo stack and redo stoack is empty |
| 343 |
widget=self.tabs.get_nth_page(idx) |
| 344 |
widget.write_menu() |
| 345 |
label=self.tabs.get_tab_label(widget) |
| 346 |
current_text=label.label.get_text() |
| 347 |
label.label.set_text(current_text.replace("*","")) |
| 348 |
|
| 349 |
def save_all(self, widget): |
| •350 |
for i in range(self.tabs.get_n_pages()): |
| 351 |
widget=self.tabs.get_nth_page(i) |
| 352 |
widget.write_menu() |
| 353 |
label=self.tabs.get_tab_label(widget) |
| 354 |
current_text=label.label.get_text() |
| 355 |
label.label.set_text(current_text.replace("*","")) |
| 356 |
|
| 357 |
def get_current_menu(self, notebook, page, page_num): |
| •358 |
for i in range(self.tabs.get_n_pages()): |
| 359 |
widget=self.tabs.get_nth_page(i) |
| 360 |
if hasattr(widget, 'currently_editing'): |
| 361 |
if i != page_num: |
| 362 |
widget.currently_editing.hide() |
| 363 |
else: |
| 364 |
widget.currently_editing.show() |
| 365 |
|
| 366 |
def change_tab_title_del(self, path, a, label): |
| 367 |
if not re.match("\*",label.get_text()): |
| 368 |
label.set_text("*"+label.get_text()) |
| 369 |
|
| 370 |
def change_tab_title(self, path, iter, a, label): |
| 371 |
if not re.match("\*",label.get_text()): |
| 372 |
label.set_text("*"+label.get_text()) |
| 373 |
|
| 374 |
def get_edit_panel(self, treeview, path, view_column, menufile): |
| •375 |
self.vbox.pack_end(menufile.currently_editing, False, True, 0) |
| 376 |
page_num=self.tabs.get_current_page() |
| •377 |
for i in range(self.tabs.get_n_pages()): |
| 378 |
widget=self.tabs.get_nth_page(i) |
| 379 |
if hasattr(widget, 'currently_editing'): |
| 380 |
if i != page_num: |
| 381 |
widget.currently_editing.hide() |
| 382 |
else: |
| 383 |
widget.currently_editing.show() |
| 384 |
|
| 385 |
def get_edit_panel_click(self, widget, menufile): |
| 386 |
self.get_edit_panel(None, None, None, menufile) |
| 387 |
|
| 388 |
def open_menu_file(self,treeview, path, view_column): |
| •389 |
for i in range(self.tabs.get_n_pages()): |
| 390 |
widget=self.tabs.get_nth_page(i) |
| 391 |
if self.menu_list[path[0]][2] == widget.filename: |
| 392 |
return |
| 393 |
|
| 394 |
menufile=MenuFile(self.menu_list[path[0]][2]) |
| 395 |
hbox=TabButton(self.menu_list[path[0]][1]) |
| 396 |
hbox.btn.connect('clicked', self.on_closetab_button_clicked, hbox.label, menufile) |
| 397 |
|
| 398 |
self.tabs.append_page(menufile, hbox) |
| 399 |
menufile.model.connect('row-changed',self.change_tab_title, hbox.label) |
| 400 |
menufile.model.connect('row-deleted',self.change_tab_title_del, hbox.label) |
| 401 |
menufile.model.connect('row-inserted',self.change_tab_title, hbox.label) |
| 402 |
menufile.treeview.connect('row-activated',self.get_edit_panel, menufile) |
| 403 |
menufile.edit_menu.connect('activate', self.get_edit_panel_click, menufile) |
| 404 |
|
| 405 |
def on_closetab_button_clicked(self, sender, widget, menufile): |
| 406 |
pagenum = self.tabs.page_num(menufile) |
| 407 |
menu=self.tabs.get_nth_page(pagenum) |
| 408 |
if re.match("\*",widget.get_text()): |
| •409 |
warning = Gtk.MessageDialog(self, Gtk.DialogFlags.MODAL, Gtk.MessageType.INFO, Gtk.ButtonsType.NONE, 'Close %s with unsaved changes?' % os.path.basename(menu.filename)) |
| 410 |
warning.add_buttons(Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL, Gtk.STOCK_OK, Gtk.ResponseType.ACCEPT) |
| 411 |
if warning.run() != Gtk.ResponseType.ACCEPT: |
| 412 |
warning.destroy() |
| 413 |
return |
| 414 |
warning.destroy() |
| 415 |
if hasattr(menu, 'currently_editing'): |
| 416 |
menu.currently_editing.destroy() |
| 417 |
self.tabs.remove_page(pagenum) |
| 418 |
|
| 419 |
def update_cache(self, widget, path): |
| 420 |
self.menu_list[path][0] = not self.menu_list[path][0] |
| 421 |
parser.remove_section("Files") |
| 422 |
parser.add_section("Files") |
| 423 |
j=0 |
| 424 |
for i in self.menu_list: |
| 425 |
if i[1] == "menu.xml": |
| •426 |
print("Compiz Boxmenu caches menu.xml by default") |
| 427 |
continue |
| 428 |
if i[0]: |
| 429 |
parser.set("Files", "file_%s" % j, i[2]) |
| 430 |
j=j+1 |
| 431 |
parser.write(open(cache_file, 'w')) |
| 432 |
|
| 433 |
def reload_menu(self, widget): |
| 434 |
if bus is not None: |
| 435 |
try: |
| 436 |
bus.get_object('org.compiz_fusion.boxmenu', \ |
| 437 |
'/org/compiz_fusion/boxmenu/menu').reload() |
| 438 |
except dbus.DBusException: |
| 439 |
return |
| 440 |
|
| 441 |
def show_about_dialog(self, widget): |
| •442 |
dialog=Gtk.AboutDialog() |
| 443 |
dialog.set_name("Compiz Boxmenu Editor") |
| 444 |
dialog.set_version("1.1.6") |
| 445 |
dialog.set_authors(["ShadowKyogre","crdlb"]) |
| 446 |
dialog.set_comments("A specialized editor for Compiz Boxmenu's menu files") |
| 447 |
dialog.run() |
| 448 |
dialog.destroy() |
| 449 |
|
| 450 |
def check_cache(self, path): |
| 451 |
for i in cache: |
| 452 |
if os.path.expanduser(i[1]) == path: |
| 453 |
return True |
| 454 |
return False |
| 455 |
|
| 456 |
def list_menus(self): |
| •457 |
self.menu_list=Gtk.ListStore(GObject.TYPE_BOOLEAN, \ |
| 458 |
GObject.TYPE_STRING, \ |
| 459 |
GObject.TYPE_STRING) |
| 460 |
menu_path=BaseDirectory.xdg_config_home + "/compiz/boxmenu" |
| 461 |
for checking in os.listdir(menu_path): |
| 462 |
path="%s/%s" %(menu_path, checking) |
| 463 |
if checking.endswith(".xml"): |
| 464 |
if allnotcache: |
| 465 |
self.menu_list.append([False,checking, path]) |
| 466 |
else: |
| 467 |
self.menu_list.append([self.check_cache(path),checking, path]) |
| 468 |
|
| 469 |
if __name__ == '__main__': |
| 470 |
|
| 471 |
if dbus: |
| 472 |
try: |
| 473 |
bus = dbus.SessionBus() |
| 474 |
except dbus.DBusException: |
| 475 |
bus = None |
| 476 |
else: |
| 477 |
bus = None |
| 478 |
menu_path=BaseDirectory.xdg_config_home + "/compiz/boxmenu" |
| 479 |
if not os.path.exists(menu_path): |
| 480 |
os.makedirs(menu_path) |
| 481 |
elif not os.path.exists(menu_path+"/menu.xml"): |
| 482 |
starting_file=BaseDirectory.load_first_config('compiz/boxmenu/menu.xml') |
| 483 |
from shutil import copyfile |
| 484 |
copyfile(starting_file, menu_path+"/menu.xml") |
| 485 |
try: |
| 486 |
cache_file=menu_path+"/precache.ini" |
| •487 |
parser=configparser.SafeConfigParser() |
| 488 |
parser.readfp(open(cache_file)) |
| 489 |
cache=parser.items("Files") |
| 490 |
allnotcache=False |
| 491 |
except IOError: |
| 492 |
allnotcache=True |
| 493 |
elementlist = ['Launcher', 'Menu', 'Separator', 'Windows List', |
| 494 |
'Desktops List','Viewports List', 'Recent Documents', |
| 495 |
'Reload', 'Menu File'] |
| 496 |
CBEditor() |
| •497 |
Gtk.main() |