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 / deskbar / DeskbarApplet.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  14.4 KB  |  388 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. import os
  5. import time
  6. from os.path import *
  7. import gnomeapplet
  8. import gtk
  9. import gtk.gdk as gtk
  10. import gconf
  11. import gobject
  12. from gettext import gettext as _
  13. import deskbar
  14. import deskbar.ui as deskbar
  15. from deskbar.DeskbarHistory import get_deskbar_history
  16. from deskbar.ModuleList import ModuleList
  17. from deskbar.ModuleLoader import ModuleLoader
  18. from deskbar.ui.About import show_about
  19. from deskbar.ui.DeskbarPreferencesUI import show_preferences
  20. from deskbar.DeskbarAppletPreferences import DeskbarAppletPreferences
  21. from deskbar.Keybinder import get_deskbar_keybinder
  22. from deskbar.ui.cuemiac.CuemiacButtonUI import CuemiacButtonUI
  23. from deskbar.ui.entriac.CuemiacEntryUI import CuemiacEntryUI
  24. from deskbar.ui.window.CuemiacWindowUI import CuemiacWindowUI
  25.  
  26. class DeskbarApplet:
  27.     
  28.     def __init__(self, applet):
  29.         self.applet = applet
  30.         self.start_query_id = 0
  31.         self.prefs = DeskbarAppletPreferences(applet)
  32.         self._inited_modules = 0
  33.         self._loaded_modules = 0
  34.         self._match_hashes = { }
  35.         self.middle_click = None
  36.         self.loader = ModuleLoader(deskbar.MODULES_DIRS)
  37.         self.loader.connect('modules-loaded', self.on_modules_loaded)
  38.         self.module_list = ModuleList()
  39.         self.loader.connect('module-loaded', self.module_list.update_row_cb)
  40.         self.loader.connect('module-initialized', self.module_list.module_toggled_cb)
  41.         self.loader.connect('module-initialized', self.on_module_initialized)
  42.         self.loader.connect('module-not-initialized', self.on_module_initialized)
  43.         self.loader.connect('module-stopped', self.module_list.module_toggled_cb)
  44.         self.loader.connect('module-initialized', self._connect_if_async)
  45.         gtk.window_set_default_icon_name('deskbar-applet')
  46.         self.minchars = deskbar.GCONF_CLIENT.get_int(self.prefs.GCONF_MINCHARS)
  47.         if self.minchars == None:
  48.             self.minchars = 1
  49.         
  50.         deskbar.GCONF_CLIENT.notify_add(self.prefs.GCONF_MINCHARS, (lambda x, y, z, a: self.on_minchars_changed(z.value)))
  51.         self.typingdelay = deskbar.GCONF_CLIENT.get_int(self.prefs.GCONF_TYPINGDELAY)
  52.         if self.typingdelay == None:
  53.             self.typingdelay = 250
  54.         
  55.         deskbar.GCONF_CLIENT.notify_add(self.prefs.GCONF_TYPINGDELAY, (lambda x, y, z, a: self.on_typingdelay_changed(z.value)))
  56.         self.clear_entry = deskbar.GCONF_CLIENT.get_bool(self.prefs.GCONF_CLEAR_ENTRY)
  57.         if self.clear_entry == None:
  58.             self.clear_entry = False
  59.         
  60.         deskbar.GCONF_CLIENT.notify_add(self.prefs.GCONF_CLEAR_ENTRY, (lambda x, y, z, a: self.on_clear_entry_changed(z.value)))
  61.         if deskbar.UI_OVERRIDE:
  62.             ui_name = deskbar.UI_OVERRIDE
  63.             deskbar.GCONF_CLIENT.set_string(self.prefs.GCONF_UI_NAME, ui_name)
  64.         else:
  65.             ui_name = deskbar.GCONF_CLIENT.get_string(self.prefs.GCONF_UI_NAME)
  66.             if ui_name == None:
  67.                 ui_name = deskbar.ENTRIAC_UI_NAME
  68.             
  69.         if ui_name == deskbar.CUEMIAC_UI_NAME:
  70.             self.ui = CuemiacButtonUI(applet, self.prefs)
  71.         elif ui_name == deskbar.ENTRIAC_UI_NAME:
  72.             self.ui = CuemiacEntryUI(applet, self.prefs)
  73.         elif ui_name == deskbar.WINDOW_UI_NAME:
  74.             self.ui = CuemiacWindowUI(applet, self.prefs)
  75.             self.ui.connect('show-preferences', self.on_preferences, None)
  76.             self.ui.connect('show-about', self.on_about, None)
  77.             self.ui.connect('clear-history', self.on_clear_history, None)
  78.         
  79.         self.set_up_ui_signals()
  80.         self.ui.set_sensitive(False)
  81.         self.applet.add(self.ui.get_view())
  82.         deskbar.GCONF_CLIENT.notify_add(self.prefs.GCONF_UI_NAME, (lambda x, y, z, a: self.on_ui_changed(z.value)))
  83.         deskbar.GCONF_CLIENT.notify_add(deskbar.GCONF_ENABLED_HANDLERS, (lambda x, y, z, a: self.on_config_handlers(z.value)))
  84.         self.use_selection = deskbar.GCONF_CLIENT.get_bool(self.prefs.GCONF_USE_SELECTION)
  85.         if self.use_selection == None:
  86.             self.use_selection = True
  87.         
  88.         deskbar.GCONF_CLIENT.notify_add(self.prefs.GCONF_USE_SELECTION, (lambda x, y, z, a: self.on_use_selection(z.value)))
  89.         get_deskbar_keybinder().connect('activated', self.on_keybinding_button_press)
  90.         self.applet.connect('button-press-event', self.on_applet_button_press)
  91.         self.applet.connect('button-release-event', self.on_applet_button_release)
  92.         self.applet.connect('destroy', (lambda x: get_deskbar_history().save()))
  93.         self.applet.setup_menu_from_file(deskbar.SHARED_DATA_DIR, 'Deskbar_Applet.xml', None, [
  94.             ('About', self.on_about),
  95.             ('Prefs', self.on_preferences),
  96.             ('Clear', self.on_clear_history)])
  97.         self.applet.show_all()
  98.         self.loader.load_all_async()
  99.  
  100.     
  101.     def _connect_if_async(self, sender, context):
  102.         if context.module.is_async():
  103.             context.module.connect('query-ready', (lambda sender, qstring, matches: []([ (qstring, match) for match in matches ])))
  104.         
  105.  
  106.     
  107.     def on_match_selected(self, sender, text, match):
  108.         print 'Match selected: ', match
  109.         self.on_stop_query()
  110.         match.action(text)
  111.         get_deskbar_history().add(text, match)
  112.         if self.clear_entry:
  113.             gobject.idle_add(self.clear_entry)
  114.         
  115.  
  116.     
  117.     def clear_entry(self):
  118.         entry = self.ui.get_entry()
  119.         if entry != None:
  120.             entry.set_text('')
  121.         
  122.  
  123.     
  124.     def on_start_query(self, sender, qstring):
  125.         if len(qstring) < self.minchars:
  126.             return None
  127.         
  128.         if self.start_query_id != 0:
  129.             gobject.source_remove(self.start_query_id)
  130.         
  131.         self.start_query_id = gobject.timeout_add(self.typingdelay, self.on_start_query_real, sender, qstring)
  132.  
  133.     
  134.     def on_start_query_real(self, sender, qstring):
  135.         self._match_hashes = { }
  136.         results = []
  137.         for modctx in self.module_list:
  138.             if not modctx.enabled:
  139.                 continue
  140.             
  141.             if modctx.module.is_async():
  142.                 modctx.module.query_async(qstring)
  143.                 continue
  144.             
  145.             try:
  146.                 matches = modctx.module.query(qstring)
  147.             except TypeError:
  148.                 matches = modctx.module.query(qstring, deskbar.DEFAULT_RESULTS_PER_HANDLER)
  149.  
  150.             for match in matches:
  151.                 text = qstring
  152.                 match = match
  153.                 if type(match) is tuple:
  154.                     (text, match) = match
  155.                 
  156.                 hsh = match.get_hash(text)
  157.                 if hsh != None:
  158.                     if hsh in self._match_hashes:
  159.                         continue
  160.                     
  161.                     self._match_hashes[hsh] = True
  162.                     results.append((text, match))
  163.                     continue
  164.                 results.append((text, match))
  165.             
  166.         
  167.         if len(results) != 0:
  168.             self.ui.append_matches(results)
  169.         
  170.  
  171.     
  172.     def dispatch_matches(self, matches):
  173.         results = []
  174.         for text, match in matches:
  175.             hsh = match.get_hash(text)
  176.             if hsh != None:
  177.                 if hsh in self._match_hashes:
  178.                     continue
  179.                 
  180.                 self._match_hashes[hsh] = True
  181.                 results.append((text, match))
  182.                 continue
  183.             results.append((text, match))
  184.         
  185.         self.ui.append_matches(results)
  186.  
  187.     
  188.     def on_stop_query(self, sender = None):
  189.         get_deskbar_history().reset()
  190.         if self.start_query_id != 0:
  191.             gobject.source_remove(self.start_query_id)
  192.         
  193.         for modctx in self.module_list:
  194.             if modctx.module.is_async() and modctx.enabled:
  195.                 modctx.module.stop_query()
  196.                 continue
  197.         
  198.  
  199.     
  200.     def on_request_keybinding(self, sender, match, keybinding):
  201.         print 'keybind request:', match, keybinding
  202.  
  203.     
  204.     def on_keyboard_shortcut(self, sender, qstring, shortcut):
  205.         for modctx in self.module_list:
  206.             if not modctx.enabled:
  207.                 continue
  208.             
  209.             match = modctx.module.on_key_press(qstring, shortcut)
  210.             if match != None:
  211.                 self.on_match_selected(sender, qstring, match)
  212.                 break
  213.                 continue
  214.         
  215.  
  216.     
  217.     def on_about(self, component, verb):
  218.         show_about()
  219.  
  220.     
  221.     def on_preferences(self, component, verb):
  222.         show_preferences(self, self.loader, self.module_list)
  223.  
  224.     
  225.     def on_clear_history(self, component, verb):
  226.         get_deskbar_history().clear()
  227.  
  228.     
  229.     def on_config_handlers(self, value):
  230.         if value != None and value.type == gconf.VALUE_LIST:
  231.             enabled_modules = [ h.get_string() for h in value.get_list() ]
  232.             for modctx in self.module_list:
  233.                 if modctx.enabled and modctx.handler not in enabled_modules:
  234.                     self.loader.stop_module(modctx)
  235.                     continue
  236.                 []
  237.             
  238.             self.update_modules_priority(enabled_modules, (lambda modctx: self.loader.initialize_module_async(modctx)))
  239.         
  240.  
  241.     
  242.     def update_modules_priority(self, enabled_modules, callback = None):
  243.         '''
  244. \t\tmodule_list is a module_loader.ModuleList() with loaded modules
  245. \t\tenabled_modules is a list of exported classnames.
  246. \t\t
  247. \t\tUpdate the module priority present in both module_list and enabled_modules according
  248. \t\tto the ordering of enabled_modules. Optionally calls callback when != None on each
  249. \t\tmodule context, in the correct order (from important to less important)
  250. \t\t'''
  251.         high_prio = (len(enabled_modules) - 1) * 100
  252.         for i, mod in enumerate(enabled_modules):
  253.             modctx = _[1]
  254.             modctx = modctx[0]
  255.             modctx.module.set_priority(high_prio - i * 100)
  256.             if callback != None:
  257.                 callback(modctx)
  258.                 continue
  259.             None if len(modctx) != 1 else []
  260.         
  261.         self.module_list.reorder_with_priority(enabled_modules)
  262.  
  263.     
  264.     def on_modules_loaded(self, loader):
  265.         enabled_list = deskbar.GCONF_CLIENT.get_list(deskbar.GCONF_ENABLED_HANDLERS, gconf.VALUE_STRING)
  266.         
  267.         def foreach_enabled(modctx):
  268.             self.loader.initialize_module_async(modctx)
  269.             self._loaded_modules = self._loaded_modules + 1
  270.  
  271.         self.update_modules_priority(enabled_list, foreach_enabled)
  272.         if self._loaded_modules == 0:
  273.             self.ui.set_sensitive(True)
  274.         
  275.  
  276.     
  277.     def on_module_initialized(self, loader, modctx):
  278.         self._inited_modules = self._inited_modules + 1
  279.         if self._inited_modules == self._loaded_modules:
  280.             self.ui.set_sensitive(True)
  281.             get_deskbar_history().load(self.module_list)
  282.         
  283.  
  284.     
  285.     def on_applet_button_press(self, widget, event):
  286.         if event.button == 1:
  287.             self.ui.receive_focus(event.time)
  288.             return True
  289.         
  290.         if event.button == 2:
  291.             self.middle_click = (event.x_root, event.y_root)
  292.         
  293.         return False
  294.  
  295.     
  296.     def on_applet_button_release(self, widget, event):
  297.         if event.button == 2:
  298.             (x, y) = self.middle_click
  299.             diffx = abs(x - event.x_root)
  300.             diffy = abs(y - event.y_root)
  301.             if diffx <= 3 and diffy <= 3:
  302.                 self.ui.middle_click()
  303.             
  304.             self.middle_click = None
  305.         
  306.  
  307.     
  308.     def on_keybinding_button_press(self, widget, time):
  309.         print 'Keybinding activated, focusing UI'
  310.         if self.use_selection:
  311.             clipboard = gtk.clipboard_get(selection = 'PRIMARY')
  312.             text = clipboard.wait_for_text()
  313.             if text:
  314.                 self.ui.get_entry().set_text(text)
  315.             
  316.         
  317.         self.ui.receive_focus(time)
  318.         self.ui.get_entry().select_region(0, -1)
  319.  
  320.     
  321.     def on_history_item_selection(self, item, match, text):
  322.         pass
  323.  
  324.     
  325.     def on_keybinding_changed(self, binder, bound):
  326.         pass
  327.  
  328.     
  329.     def set_up_ui_signals(self):
  330.         self.ui.connect('match-selected', self.on_match_selected)
  331.         self.ui.connect('start-query', self.on_start_query)
  332.         self.ui.connect('stop-query', self.on_stop_query)
  333.         self.ui.connect('request-keybinding', self.on_request_keybinding)
  334.         self.ui.connect('keyboard-shortcut', self.on_keyboard_shortcut)
  335.         self.applet.connect('change-orient', (lambda applet, orient: self.ui.on_change_orient(applet)))
  336.         self.applet.connect('change-size', (lambda applet, orient: self.ui.on_change_size(applet)))
  337.  
  338.     
  339.     def on_minchars_changed(self, value):
  340.         if value is None or value.type != gconf.VALUE_INT:
  341.             return None
  342.         
  343.         self.minchars = value.get_int()
  344.  
  345.     
  346.     def on_typingdelay_changed(self, value):
  347.         if value is None or value.type != gconf.VALUE_INT:
  348.             return None
  349.         
  350.         self.typingdelay = value.get_int()
  351.  
  352.     
  353.     def on_ui_changed(self, value):
  354.         if value is None or value.type != gconf.VALUE_STRING:
  355.             return None
  356.         
  357.         ui_name = value.get_string()
  358.         if ui_name == deskbar.WINDOW_UI_NAME:
  359.             return None
  360.         
  361.         self.ui.close_view()
  362.         self.applet.remove(self.ui.get_view())
  363.         if ui_name == deskbar.CUEMIAC_UI_NAME:
  364.             self.ui = CuemiacButtonUI(self.applet, self.prefs)
  365.         elif ui_name == deskbar.ENTRIAC_UI_NAME:
  366.             self.ui = CuemiacEntryUI(self.applet, self.prefs)
  367.         
  368.         self.set_up_ui_signals()
  369.         self.applet.add(self.ui.get_view())
  370.         self.applet.show_all()
  371.         self.ui.set_sensitive(True)
  372.         print 'Changing UI to:', value.get_string()
  373.  
  374.     
  375.     def on_clear_entry_changed(self, value):
  376.         if value is None or value.type != gconf.VALUE_BOOL:
  377.             return None
  378.         
  379.         self.clear_entry = value.get_bool()
  380.  
  381.     
  382.     def on_use_selection(self, value = None):
  383.         if value != None and value.type == gconf.VALUE_BOOL:
  384.             self.use_selection = value.get_bool()
  385.         
  386.  
  387.  
  388.