home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / python2.4 / site-packages / Alacarte / MainWindow.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-07-25  |  20.1 KB  |  609 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import gtk
  5. import gtk.glade as gtk
  6. import gmenu
  7. import gobject
  8. import gnomevfs
  9. import gnome.ui as gnome
  10. import cgi
  11. import os
  12. import gettext
  13. gettext.bindtextdomain('alacarte')
  14. gettext.textdomain('alacarte')
  15. gtk.glade.bindtextdomain('alacarte')
  16. gtk.glade.textdomain('alacarte')
  17. _ = gettext.gettext
  18. from Alacarte.MenuEditor import MenuEditor
  19. from Alacarte.DialogHandler import DialogHandler
  20. from Alacarte import util
  21. import time
  22.  
  23. class MainWindow:
  24.     timer = None
  25.     allow_update = True
  26.     dnd_items = [
  27.         ('ALACARTE_ITEM_ROW', gtk.TARGET_SAME_APP, 0),
  28.         ('text/plain', 0, 1)]
  29.     dnd_menus = [
  30.         ('ALACARTE_MENU_ROW', gtk.TARGET_SAME_APP, 0)]
  31.     dnd_both = [
  32.         dnd_items[0]] + dnd_menus
  33.     drag_data = None
  34.     
  35.     def __init__(self, datadir, version, argv):
  36.         self.file_path = datadir
  37.         self.version = version
  38.         self.editor = MenuEditor()
  39.         gtk.window_set_default_icon_name('alacarte')
  40.         self.tree = gtk.glade.XML(os.path.join(self.file_path, 'alacarte.glade'))
  41.         signals = { }
  42.         for attr in dir(self):
  43.             signals[attr] = getattr(self, attr)
  44.         
  45.         self.tree.signal_autoconnect(signals)
  46.         self.setupMenuTree()
  47.         self.setupItemTree()
  48.         self.dialogs = DialogHandler(self.tree.get_widget('mainwindow'), self.editor, self.file_path)
  49.         self.tree.get_widget('edit_delete').set_sensitive(False)
  50.         self.tree.get_widget('edit_revert_to_original').set_sensitive(False)
  51.         self.tree.get_widget('edit_properties').set_sensitive(False)
  52.         self.tree.get_widget('move_up_button').set_sensitive(False)
  53.         self.tree.get_widget('move_down_button').set_sensitive(False)
  54.         accelgroup = gtk.AccelGroup()
  55.         (keyval, modifier) = gtk.accelerator_parse('<Ctrl>Z')
  56.         accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_mainwindow_undo)
  57.         (keyval, modifier) = gtk.accelerator_parse('<Ctrl><Shift>Z')
  58.         accelgroup.connect_group(keyval, modifier, gtk.ACCEL_VISIBLE, self.on_mainwindow_redo)
  59.         self.tree.get_widget('mainwindow').add_accel_group(accelgroup)
  60.         gnome.ui.authentication_manager_init()
  61.  
  62.     
  63.     def run(self):
  64.         self.loadMenus()
  65.         self.editor.applications.tree.add_monitor(self.menuChanged)
  66.         self.editor.settings.tree.add_monitor(self.menuChanged)
  67.         self.tree.get_widget('mainwindow').show_all()
  68.         gtk.main()
  69.  
  70.     
  71.     def menuChanged(self, *a):
  72.         if self.timer:
  73.             gobject.source_remove(self.timer)
  74.             self.timer = None
  75.         
  76.         self.timer = gobject.timeout_add(3, self.loadUpdates)
  77.  
  78.     
  79.     def loadUpdates(self):
  80.         if not self.allow_update:
  81.             return False
  82.         
  83.         menu_tree = self.tree.get_widget('menu_tree')
  84.         item_tree = self.tree.get_widget('item_tree')
  85.         (items, iter) = item_tree.get_selection().get_selected()
  86.         update_items = False
  87.         (item_id, separator_path) = (None, None)
  88.         if iter:
  89.             update_items = True
  90.             if items[iter][3].get_type() == gmenu.TYPE_DIRECTORY:
  91.                 item_id = os.path.split(items[iter][3].get_desktop_file_path())[1]
  92.                 update_items = True
  93.             elif items[iter][3].get_type() == gmenu.TYPE_ENTRY:
  94.                 item_id = items[iter][3].get_desktop_file_id()
  95.                 update_items = True
  96.             elif items[iter][3].get_type() == gmenu.TYPE_SEPARATOR:
  97.                 item_id = items.get_path(iter)
  98.                 update_items = True
  99.             
  100.         
  101.         (menus, iter) = menu_tree.get_selection().get_selected()
  102.         update_menus = False
  103.         menu_id = None
  104.         if iter:
  105.             if menus[iter][2].get_desktop_file_path():
  106.                 menu_id = os.path.split(menus[iter][2].get_desktop_file_path())[1]
  107.             else:
  108.                 menu_id = menus[iter][2].get_menu_id()
  109.             update_menus = True
  110.         
  111.         self.loadMenus()
  112.         if update_menus:
  113.             menu_tree.get_model().foreach(self.findMenu, menu_id)
  114.             (menus, iter) = menu_tree.get_selection().get_selected()
  115.             if iter:
  116.                 self.on_menu_tree_cursor_changed(menu_tree)
  117.             
  118.         
  119.         if update_items:
  120.             i = 0
  121.             for item in item_tree.get_model():
  122.                 found = False
  123.                 if item[3].get_type() == gmenu.TYPE_ENTRY and item[3].get_desktop_file_id() == item_id:
  124.                     found = True
  125.                 
  126.                 if item[3].get_type() == gmenu.TYPE_DIRECTORY and item[3].get_desktop_file_path():
  127.                     if os.path.split(item[3].get_desktop_file_path())[1] == item_id:
  128.                         found = True
  129.                     
  130.                 
  131.                 if item[3].get_type() == gmenu.TYPE_SEPARATOR:
  132.                     if not isinstance(item_id, tuple):
  133.                         continue
  134.                     
  135.                     if (item_id[0] - 1,) == (i,):
  136.                         found = True
  137.                     elif (item_id[0] + 1,) == (i,):
  138.                         found = True
  139.                     elif (item_id[0],) == (i,):
  140.                         found = True
  141.                     
  142.                 
  143.                 if found:
  144.                     item_tree.get_selection().select_path((i,))
  145.                     self.on_item_tree_cursor_changed(item_tree)
  146.                     break
  147.                 
  148.                 i += 1
  149.             
  150.         
  151.         return False
  152.  
  153.     
  154.     def findMenu(self, menus, path, iter, menu_id):
  155.         if not menus[path][2].get_desktop_file_path():
  156.             if menu_id == menus[path][2].get_menu_id():
  157.                 menu_tree = self.tree.get_widget('menu_tree')
  158.                 menu_tree.expand_to_path(path)
  159.                 menu_tree.get_selection().select_path(path)
  160.                 return True
  161.             
  162.             return False
  163.         
  164.         if os.path.split(menus[path][2].get_desktop_file_path())[1] == menu_id:
  165.             menu_tree = self.tree.get_widget('menu_tree')
  166.             menu_tree.expand_to_path(path)
  167.             menu_tree.get_selection().select_path(path)
  168.             return True
  169.         
  170.  
  171.     
  172.     def setupMenuTree(self):
  173.         self.menu_store = gtk.TreeStore(gtk.gdk.Pixbuf, str, object)
  174.         menus = self.tree.get_widget('menu_tree')
  175.         column = gtk.TreeViewColumn(_('Name'))
  176.         column.set_spacing(4)
  177.         cell = gtk.CellRendererPixbuf()
  178.         column.pack_start(cell, False)
  179.         column.set_attributes(cell, pixbuf = 0)
  180.         cell = gtk.CellRendererText()
  181.         cell.set_fixed_size(-1, 25)
  182.         column.pack_start(cell, True)
  183.         column.set_attributes(cell, markup = 1)
  184.         column.set_sizing(gtk.TREE_VIEW_COLUMN_FIXED)
  185.         menus.append_column(column)
  186.         menus.enable_model_drag_source(gtk.gdk.BUTTON1_MASK, self.dnd_menus, gtk.gdk.ACTION_COPY)
  187.         menus.enable_model_drag_dest(self.dnd_both, gtk.gdk.ACTION_PRIVATE)
  188.  
  189.     
  190.     def setupItemTree(self):
  191.         items = self.tree.get_widget('item_tree')
  192.         column = gtk.TreeViewColumn(_('Show'))
  193.         cell = gtk.CellRendererToggle()
  194.         cell.connect('toggled', self.on_item_tree_show_toggled)
  195.         column.pack_start(cell, True)
  196.         column.set_attributes(cell, active = 0)
  197.         column.set_cell_data_func(cell, self._cell_data_toggle_func)
  198.         items.append_column(column)
  199.         column = gtk.TreeViewColumn(_('Item'))
  200.         column.set_spacing(4)
  201.         cell = gtk.CellRendererPixbuf()
  202.         column.pack_start(cell, False)
  203.         column.set_attributes(cell, pixbuf = 1)
  204.         cell = gtk.CellRendererText()
  205.         cell.set_fixed_size(-1, 25)
  206.         column.pack_start(cell, True)
  207.         column.set_attributes(cell, markup = 2)
  208.         items.append_column(column)
  209.         self.item_store = gtk.ListStore(bool, gtk.gdk.Pixbuf, str, object)
  210.         items.set_model(self.item_store)
  211.         items.enable_model_drag_source(gtk.gdk.BUTTON1_MASK, self.dnd_items, gtk.gdk.ACTION_COPY)
  212.         items.enable_model_drag_dest(self.dnd_items, gtk.gdk.ACTION_PRIVATE)
  213.  
  214.     
  215.     def _cell_data_toggle_func(self, tree_column, renderer, model, treeiter):
  216.         if model[treeiter][3].get_type() == gmenu.TYPE_SEPARATOR:
  217.             renderer.set_property('visible', False)
  218.         else:
  219.             renderer.set_property('visible', True)
  220.  
  221.     
  222.     def loadMenus(self):
  223.         self.menu_store.clear()
  224.         for menu in self.editor.getMenus():
  225.             iters = [
  226.                 None] * 20
  227.             self.loadMenu(iters, menu)
  228.         
  229.         menu_tree = self.tree.get_widget('menu_tree')
  230.         menu_tree.set_model(self.menu_store)
  231.         for menu in self.menu_store:
  232.             menu_tree.expand_to_path(menu.path)
  233.         
  234.         menu_tree.get_selection().select_path((0,))
  235.         self.on_menu_tree_cursor_changed(menu_tree)
  236.  
  237.     
  238.     def loadMenu(self, iters, parent, depth = 0):
  239.         if depth == 0:
  240.             icon = util.getIcon(parent)
  241.             iters[depth] = self.menu_store.append(None, (icon, cgi.escape(parent.get_name()), parent))
  242.         
  243.         depth += 1
  244.         for menu, show in self.editor.getMenus(parent):
  245.             if show:
  246.                 name = cgi.escape(menu.get_name())
  247.             else:
  248.                 name = '<small><i>' + cgi.escape(menu.get_name()) + '</i></small>'
  249.             icon = util.getIcon(menu)
  250.             iters[depth] = self.menu_store.append(iters[depth - 1], (icon, name, menu))
  251.             self.loadMenu(iters, menu, depth)
  252.         
  253.         depth -= 1
  254.  
  255.     
  256.     def loadItems(self, menu, menu_path):
  257.         self.item_store.clear()
  258.         for item, show in self.editor.getItems(menu):
  259.             menu_icon = None
  260.             if item.get_type() == gmenu.TYPE_SEPARATOR:
  261.                 name = '---'
  262.                 icon = None
  263.             elif show:
  264.                 name = cgi.escape(item.get_name())
  265.             else:
  266.                 name = '<small><i>' + cgi.escape(item.get_name()) + '</i></small>'
  267.             icon = util.getIcon(item)
  268.             self.item_store.append((show, icon, name, item))
  269.         
  270.  
  271.     
  272.     def on_new_menu_button_clicked(self, button):
  273.         menu_tree = self.tree.get_widget('menu_tree')
  274.         (menus, iter) = menu_tree.get_selection().get_selected()
  275.         if not iter:
  276.             parent = menus[(0,)][2]
  277.             menu_tree.expand_to_path((0,))
  278.             menu_tree.get_selection().select_path((0,))
  279.         else:
  280.             parent = menus[iter][2]
  281.         values = self.dialogs.newMenuDialog()
  282.         if values:
  283.             self.editor.createMenu(parent, values[0], values[1], values[2])
  284.         
  285.         gobject.timeout_add(3, self.loadUpdates)
  286.  
  287.     
  288.     def on_new_item_button_clicked(self, button):
  289.         menu_tree = self.tree.get_widget('menu_tree')
  290.         (menus, iter) = menu_tree.get_selection().get_selected()
  291.         if not iter:
  292.             parent = menus[(0,)][2]
  293.             menu_tree.expand_to_path((0,))
  294.             menu_tree.get_selection().select_path((0,))
  295.         else:
  296.             parent = menus[iter][2]
  297.         values = self.dialogs.newItemDialog()
  298.         if values:
  299.             self.editor.createItem(parent, values[0], values[1], values[2], values[3], values[4])
  300.         
  301.  
  302.     
  303.     def on_new_separator_button_clicked(self, button):
  304.         item_tree = self.tree.get_widget('item_tree')
  305.         (items, iter) = item_tree.get_selection().get_selected()
  306.         if not iter:
  307.             return None
  308.         else:
  309.             after = items[iter][3]
  310.             menu_tree = self.tree.get_widget('menu_tree')
  311.             (menus, iter) = menu_tree.get_selection().get_selected()
  312.             parent = menus[iter][2]
  313.             self.editor.createSeparator(parent, after = after)
  314.  
  315.     
  316.     def on_edit_delete_activate(self, menu):
  317.         item_tree = self.tree.get_widget('item_tree')
  318.         (items, iter) = item_tree.get_selection().get_selected()
  319.         if not iter:
  320.             return None
  321.         
  322.         item = items[iter][3]
  323.         if item.get_type() == gmenu.TYPE_ENTRY:
  324.             self.editor.deleteItem(item)
  325.         elif item.get_type() == gmenu.TYPE_DIRECTORY:
  326.             self.editor.deleteMenu(item)
  327.         elif item.get_type() == gmenu.TYPE_SEPARATOR:
  328.             self.editor.deleteSeparator(item)
  329.         
  330.  
  331.     
  332.     def on_edit_revert_to_original_activate(self, menu):
  333.         item_tree = self.tree.get_widget('item_tree')
  334.         (items, iter) = item_tree.get_selection().get_selected()
  335.         if not iter:
  336.             return None
  337.         
  338.         item = items[iter][3]
  339.         if item.get_type() == gmenu.TYPE_ENTRY:
  340.             self.editor.revertItem(item)
  341.         elif item.get_type() == gmenu.TYPE_DIRECTORY:
  342.             self.editor.revertMenu(item)
  343.         
  344.  
  345.     
  346.     def on_edit_properties_activate(self, menu):
  347.         item_tree = self.tree.get_widget('item_tree')
  348.         (items, iter) = item_tree.get_selection().get_selected()
  349.         if not iter:
  350.             return None
  351.         
  352.         item = items[iter][3]
  353.         self.allow_update = False
  354.         if item.get_type() == gmenu.TYPE_ENTRY:
  355.             self.dialogs.editItemDialog(items[iter])
  356.         elif item.get_type() == gmenu.TYPE_DIRECTORY:
  357.             self.dialogs.editMenuDialog(items[iter])
  358.         
  359.         self.allow_update = True
  360.         self.loadUpdates()
  361.  
  362.     
  363.     def on_menu_tree_cursor_changed(self, treeview):
  364.         (menus, iter) = treeview.get_selection().get_selected()
  365.         menu_path = menus.get_path(iter)
  366.         item_tree = self.tree.get_widget('item_tree')
  367.         item_tree.get_selection().unselect_all()
  368.         self.loadItems(self.menu_store[menu_path][2], menu_path)
  369.         self.tree.get_widget('edit_delete').set_sensitive(False)
  370.         self.tree.get_widget('edit_revert_to_original').set_sensitive(False)
  371.         self.tree.get_widget('edit_properties').set_sensitive(False)
  372.         self.tree.get_widget('move_up_button').set_sensitive(False)
  373.         self.tree.get_widget('move_down_button').set_sensitive(False)
  374.  
  375.     
  376.     def on_menu_tree_drag_data_get(self, treeview, context, selection, target_id, etime):
  377.         (menus, iter) = treeview.get_selection().get_selected()
  378.         self.drag_data = menus[iter][2]
  379.  
  380.     
  381.     def on_menu_tree_drag_data_received(self, treeview, context, x, y, selection, info, etime):
  382.         menus = treeview.get_model()
  383.         drop_info = treeview.get_dest_row_at_pos(x, y)
  384.         if drop_info:
  385.             (path, position) = drop_info
  386.             types = (gtk.TREE_VIEW_DROP_INTO_OR_BEFORE, gtk.TREE_VIEW_DROP_INTO_OR_AFTER)
  387.             if position not in types:
  388.                 context.finish(False, False, etime)
  389.                 return False
  390.             
  391.             if selection.target in ('ALACARTE_ITEM_ROW', 'ALACARTE_MENU_ROW'):
  392.                 item = self.drag_data
  393.                 new_parent = menus[path][2]
  394.                 treeview.get_selection().select_path(path)
  395.                 if item.get_type() == gmenu.TYPE_ENTRY:
  396.                     self.editor.copyItem(item, new_parent)
  397.                 elif item.get_type() == gmenu.TYPE_DIRECTORY:
  398.                     if self.editor.moveMenu(item, new_parent) == False:
  399.                         self.loadUpdates()
  400.                     
  401.                 else:
  402.                     context.finish(False, False, etime)
  403.                 context.finish(True, True, etime)
  404.             
  405.         
  406.  
  407.     
  408.     def on_item_tree_show_toggled(self, cell, path):
  409.         item = self.item_store[path][3]
  410.         if item.get_type() == gmenu.TYPE_SEPARATOR:
  411.             return None
  412.         
  413.         if self.item_store[path][0]:
  414.             self.editor.setVisible(item, False)
  415.         else:
  416.             self.editor.setVisible(item, True)
  417.  
  418.     
  419.     def on_item_tree_cursor_changed(self, treeview):
  420.         (items, iter) = treeview.get_selection().get_selected()
  421.         item = items[iter][3]
  422.         self.tree.get_widget('edit_delete').set_sensitive(True)
  423.         if self.editor.canRevert(item):
  424.             self.tree.get_widget('edit_revert_to_original').set_sensitive(True)
  425.         else:
  426.             self.tree.get_widget('edit_revert_to_original').set_sensitive(False)
  427.         if not item.get_type() == gmenu.TYPE_SEPARATOR:
  428.             self.tree.get_widget('edit_properties').set_sensitive(True)
  429.         else:
  430.             self.tree.get_widget('edit_properties').set_sensitive(False)
  431.         self.tree.get_widget('move_up_button').set_sensitive(True)
  432.         self.tree.get_widget('move_down_button').set_sensitive(True)
  433.  
  434.     
  435.     def on_item_tree_row_activated(self, treeview, path, column):
  436.         self.on_edit_properties_activate(None)
  437.  
  438.     
  439.     def on_item_tree_popup_menu(self, item_tree, event = None):
  440.         (model, iter) = item_tree.get_selection().get_selected()
  441.         if event:
  442.             if event.button != 3:
  443.                 return None
  444.             
  445.             button = event.button
  446.             event_time = event.time
  447.             info = item_tree.get_path_at_pos(int(event.x), int(event.y))
  448.             if info != None:
  449.                 (path, col, cellx, celly) = info
  450.                 item_tree.grab_focus()
  451.                 item_tree.set_cursor(path, col, 0)
  452.             
  453.         else:
  454.             path = model.get_path(iter)
  455.             button = 0
  456.             event_time = 0
  457.             item_tree.grab_focus()
  458.             item_tree.set_cursor(path, item_tree.get_columns()[0], 0)
  459.         popup = self.tree.get_widget('edit_menu')
  460.         popup.popup(None, None, None, button, event_time)
  461.         return True
  462.  
  463.     
  464.     def on_item_tree_drag_data_get(self, treeview, context, selection, target_id, etime):
  465.         (items, iter) = treeview.get_selection().get_selected()
  466.         self.drag_data = items[iter][3]
  467.  
  468.     
  469.     def on_item_tree_drag_data_received(self, treeview, context, x, y, selection, info, etime):
  470.         items = treeview.get_model()
  471.         types = (gtk.TREE_VIEW_DROP_BEFORE, gtk.TREE_VIEW_DROP_INTO_OR_BEFORE)
  472.         if selection.target == 'ALACARTE_ITEM_ROW':
  473.             drop_info = treeview.get_dest_row_at_pos(x, y)
  474.             before = None
  475.             after = None
  476.             item = self.drag_data
  477.             if drop_info:
  478.                 (path, position) = drop_info
  479.                 if position in types:
  480.                     before = items[path][3]
  481.                 else:
  482.                     after = items[path][3]
  483.             else:
  484.                 path = (len(items) - 1,)
  485.                 after = items[path][3]
  486.             if item.get_type() == gmenu.TYPE_ENTRY:
  487.                 self.editor.moveItem(item, item.get_parent(), before, after)
  488.             elif item.get_type() == gmenu.TYPE_DIRECTORY:
  489.                 if self.editor.moveMenu(item, item.get_parent(), before, after) == False:
  490.                     self.loadUpdates()
  491.                 
  492.             elif item.get_type() == gmenu.TYPE_SEPARATOR:
  493.                 self.editor.moveSeparator(item, item.get_parent(), before, after)
  494.             
  495.             context.finish(True, True, etime)
  496.         elif selection.target == 'text/plain':
  497.             (menus, iter) = self.tree.get_widget('menu_tree').get_selection().get_selected()
  498.             parent = menus[iter][2]
  499.             drop_info = treeview.get_dest_row_at_pos(x, y)
  500.             before = None
  501.             after = None
  502.             if drop_info:
  503.                 (path, position) = drop_info
  504.                 if position in types:
  505.                     before = items[path][3]
  506.                 else:
  507.                     after = items[path][3]
  508.             else:
  509.                 path = (len(items) - 1,)
  510.                 after = items[path][3]
  511.             file_path = gnomevfs.unescape_string(selection.data, '').strip()
  512.             if not file_path.startswith('file:'):
  513.                 return None
  514.             
  515.             file_info = gnomevfs.get_file_info(file_path, gnomevfs.FILE_INFO_GET_MIME_TYPE | gnomevfs.FILE_INFO_FORCE_SLOW_MIME_TYPE | gnomevfs.FILE_INFO_FOLLOW_LINKS | gnomevfs.FILE_INFO_DEFAULT)
  516.             if file_info.mime_type == 'application/x-desktop':
  517.                 handle = gnomevfs.open(file_path)
  518.                 data = handle.read(file_info.size)
  519.                 open('/tmp/alacarte-dnd.desktop', 'w').write(data)
  520.                 parser = util.DesktopParser('/tmp/alacarte-dnd.desktop')
  521.                 self.editor.createItem(parent, parser.get('Icon'), parser.get('Name', self.editor.locale), parser.get('Comment', self.editor.locale), parser.get('Exec'), parser.get('Terminal'), before, after)
  522.             elif file_info.mime_type in ('application/x-shellscript', 'application/x-executable'):
  523.                 self.editor.createItem(parent, None, os.path.split(file_path)[1].strip(), None, file_path.replace('file://', '').strip(), False, before, after)
  524.             
  525.         
  526.  
  527.     
  528.     def on_item_tree_key_press_event(self, item_tree, event):
  529.         if event.keyval == gtk.keysyms.Delete:
  530.             self.on_edit_delete_activate(item_tree)
  531.         
  532.  
  533.     
  534.     def on_move_up_button_clicked(self, button):
  535.         item_tree = self.tree.get_widget('item_tree')
  536.         (items, iter) = item_tree.get_selection().get_selected()
  537.         if not iter:
  538.             return None
  539.         
  540.         path = items.get_path(iter)
  541.         if path[0] == 0:
  542.             return None
  543.         
  544.         item = items[path][3]
  545.         before = items[(path[0] - 1,)][3]
  546.         if item.get_type() == gmenu.TYPE_ENTRY:
  547.             self.editor.moveItem(item, item.get_parent(), before = before)
  548.         elif item.get_type() == gmenu.TYPE_DIRECTORY:
  549.             self.editor.moveMenu(item, item.get_parent(), before = before)
  550.         elif item.get_type() == gmenu.TYPE_SEPARATOR:
  551.             self.editor.moveSeparator(item, item.get_parent(), before = before)
  552.         
  553.  
  554.     
  555.     def on_move_down_button_clicked(self, button):
  556.         item_tree = self.tree.get_widget('item_tree')
  557.         (items, iter) = item_tree.get_selection().get_selected()
  558.         if not iter:
  559.             return None
  560.         
  561.         path = items.get_path(iter)
  562.         if path[0] == len(items) - 1:
  563.             return None
  564.         
  565.         item = items[path][3]
  566.         after = items[path][3]
  567.         if item.get_type() == gmenu.TYPE_ENTRY:
  568.             self.editor.moveItem(item, item.get_parent(), after = after)
  569.         elif item.get_type() == gmenu.TYPE_DIRECTORY:
  570.             self.editor.moveMenu(item, item.get_parent(), after = after)
  571.         elif item.get_type() == gmenu.TYPE_SEPARATOR:
  572.             self.editor.moveSeparator(item, item.get_parent(), after = after)
  573.         
  574.  
  575.     
  576.     def on_mainwindow_undo(self, accelgroup, window, keyval, modifier):
  577.         self.editor.undo()
  578.  
  579.     
  580.     def on_mainwindow_redo(self, accelgroup, window, keyval, modifier):
  581.         self.editor.redo()
  582.  
  583.     
  584.     def on_revert_button_clicked(self, button):
  585.         dialog = self.tree.get_widget('revertdialog')
  586.         dialog.set_transient_for(self.tree.get_widget('mainwindow'))
  587.         dialog.show_all()
  588.         if dialog.run() == gtk.RESPONSE_YES:
  589.             self.editor.revert()
  590.         
  591.         dialog.hide()
  592.  
  593.     
  594.     def on_close_button_clicked(self, button):
  595.         
  596.         try:
  597.             self.tree.get_widget('mainwindow').hide()
  598.         except:
  599.             pass
  600.  
  601.         gobject.timeout_add(10, self.quit)
  602.  
  603.     
  604.     def quit(self):
  605.         self.editor.quit()
  606.         gtk.main_quit()
  607.  
  608.  
  609.