home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / deskbar-applet / handlers / programs.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  13.0 KB  |  356 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import os
  5. import ConfigParser
  6. import cgi
  7. import re
  8. import glob
  9. from os.path import join, isfile, abspath, splitext, expanduser, exists, isdir
  10. from gettext import gettext as _
  11. from deskbar.defs import VERSION
  12. import gobject
  13. import gtk
  14. import deskbar
  15. import deskbar.Indexer as deskbar
  16. import deskbar.Utils as deskbar
  17. import deskbar.Handler as deskbar
  18. import deskbar.Match as deskbar
  19. import deskbar.gnomedesktop as deskbar
  20. from deskbar.Utils import get_xdg_data_dirs
  21. HANDLERS = {
  22.     'ProgramsHandler': {
  23.         'name': _('Programs'),
  24.         'description': _('Launch a program by its name and/or description'),
  25.         'version': VERSION },
  26.     'GnomeDictHandler': {
  27.         'name': _('Dictionary'),
  28.         'description': _('Look up word definitions in the dictionary'),
  29.         'version': VERSION },
  30.     'GnomeSearchHandler': {
  31.         'name': _('Files and Folders Search'),
  32.         'description': _('Find files and folders by searching for a name pattern'),
  33.         'version': VERSION },
  34.     'DevhelpHandler': {
  35.         'name': _('Developer Documentation'),
  36.         'description': _('Search Devhelp for a function name'),
  37.         'version': VERSION } }
  38. EXACT_MATCH_PRIO = 100
  39. EXACT_WORD_PRIO = 50
  40.  
  41. class GenericProgramMatch(deskbar.Match.Match):
  42.     
  43.     def __init__(self, backend, use_arg = False, desktop = None, desktop_file = None, **args):
  44.         deskbar.Match.Match.__init__(self, backend, **args)
  45.         self.desktop_file = desktop_file
  46.         self.use_arg = use_arg
  47.         self._priority = EXACT_WORD_PRIO
  48.         self._icon = deskbar.Utils.load_icon_for_desktop_icon(self.icon)
  49.         self._desktop = desktop
  50.         if desktop == None:
  51.             self._desktop = parse_desktop_filename(desktop_file)
  52.             if self._desktop == None:
  53.                 raise Exception('Desktop file not found, ignoring')
  54.             
  55.         
  56.         exe = re.sub('%\\w+', '', self._desktop.get_string('Exec'))
  57.         i = exe.split(' ')[0].rfind('/')
  58.         if i != -1:
  59.             exe = exe[i + 1:]
  60.         
  61.         self._display_prog = cgi.escape(exe).strip()
  62.  
  63.     
  64.     def get_hash(self, text = None):
  65.         return self._display_prog
  66.  
  67.     
  68.     def action(self, text = None):
  69.         if self.use_arg and text != None:
  70.             args = [
  71.                 self._desktop.get_string('Exec')]
  72.             if hasattr(self, '_args'):
  73.                 args = args + self._args
  74.             
  75.             args = args + text.split(' ')
  76.             gobject.spawn_async(args, flags = gobject.SPAWN_SEARCH_PATH)
  77.         else:
  78.             self._desktop.launch([])
  79.  
  80.     
  81.     def get_category(self):
  82.         return 'actions'
  83.  
  84.     
  85.     def get_verb(self):
  86.         return _('Launch <b>%(name)s</b> (%(prog)s)')
  87.  
  88.     
  89.     def get_name(self, text = None):
  90.         return {
  91.             'name': self.name,
  92.             'prog': self._display_prog }
  93.  
  94.  
  95.  
  96. class GnomeDictMatch(GenericProgramMatch):
  97.     
  98.     def __init__(self, backend, use_arg = True, **args):
  99.         GenericProgramMatch.__init__(self, backend, use_arg = use_arg, **args)
  100.         self._args = [
  101.             '--look-up']
  102.  
  103.     
  104.     def get_verb(self):
  105.         return _('Lookup %s in dictionary') % '<b>%(text)s</b>'
  106.  
  107.  
  108.  
  109. class GnomeSearchMatch(GenericProgramMatch):
  110.     
  111.     def __init__(self, backend, use_arg = True, **args):
  112.         GenericProgramMatch.__init__(self, backend, use_arg = use_arg, **args)
  113.         self._args = [
  114.             '--start',
  115.             '--path',
  116.             expanduser('~'),
  117.             '--named']
  118.  
  119.     
  120.     def get_verb(self):
  121.         return _('Search for file names like %s') % '<b>%(text)s</b>'
  122.  
  123.  
  124.  
  125. class DevhelpMatch(GenericProgramMatch):
  126.     
  127.     def __init__(self, backend, use_arg = True, **args):
  128.         GenericProgramMatch.__init__(self, backend, use_arg = use_arg, **args)
  129.         self._args = [
  130.             '-s']
  131.  
  132.     
  133.     def get_verb(self):
  134.         return _('Search in Devhelp for %s') % '<b>%(text)s</b>'
  135.  
  136.  
  137.  
  138. class SpecialProgramHandler(deskbar.Handler.Handler):
  139.     
  140.     def __init__(self, desktop, icon = gtk.STOCK_EXECUTE):
  141.         deskbar.Handler.Handler.__init__(self, icon)
  142.         self._desktop = desktop
  143.         self._match = None
  144.  
  145.     
  146.     def initialize(self):
  147.         result = parse_desktop_filename(self._desktop, False)
  148.         if result != None:
  149.             self._match = self.create_match(result, self._desktop)
  150.         
  151.  
  152.     
  153.     def create_match(self, desktop, f):
  154.         raise NotImplementedError
  155.  
  156.     
  157.     def query(self, qstring):
  158.         if self._match != None:
  159.             self._match._priority = get_priority_for_name(qstring, self._match._desktop.get_string('Exec'))
  160.             return [
  161.                 self._match]
  162.         else:
  163.             return []
  164.  
  165.  
  166.  
  167. class GnomeDictHandler(SpecialProgramHandler):
  168.     
  169.     def __init__(self):
  170.         SpecialProgramHandler.__init__(self, 'gnome-dictionary.desktop', 'gdict')
  171.  
  172.     
  173.     def create_match(self, desktop, f):
  174.         return GnomeDictMatch(self, name = cgi.escape(desktop.get_localestring(deskbar.gnomedesktop.KEY_NAME)), icon = desktop.get_string(deskbar.gnomedesktop.KEY_ICON), desktop = desktop, desktop_file = f)
  175.  
  176.  
  177.  
  178. class GnomeSearchHandler(SpecialProgramHandler):
  179.     
  180.     def __init__(self):
  181.         SpecialProgramHandler.__init__(self, 'gnome-search-tool.desktop', 'gnome-searchtool')
  182.  
  183.     
  184.     def create_match(self, desktop, f):
  185.         return GnomeSearchMatch(self, name = cgi.escape(desktop.get_localestring(deskbar.gnomedesktop.KEY_NAME)), icon = desktop.get_string(deskbar.gnomedesktop.KEY_ICON), desktop = desktop, desktop_file = f)
  186.  
  187.  
  188.  
  189. class DevhelpHandler(SpecialProgramHandler):
  190.     
  191.     def __init__(self):
  192.         SpecialProgramHandler.__init__(self, 'devhelp.desktop', 'devhelp')
  193.  
  194.     
  195.     def create_match(self, desktop, f):
  196.         return DevhelpMatch(self, name = cgi.escape(desktop.get_localestring(deskbar.gnomedesktop.KEY_NAME)), icon = desktop.get_string(deskbar.gnomedesktop.KEY_ICON), desktop = desktop, desktop_file = f)
  197.  
  198.  
  199.  
  200. class PathProgramMatch(deskbar.Match.Match):
  201.     
  202.     def __init__(self, backend, name = None, use_terminal = False, priority = 0, **args):
  203.         deskbar.Match.Match.__init__(self, backend, name = name, **args)
  204.         self.use_terminal = use_terminal
  205.         self._priority = EXACT_MATCH_PRIO
  206.  
  207.     
  208.     def set_with_terminal(self, terminal):
  209.         self.use_terminal = terminal
  210.  
  211.     
  212.     def get_hash(self, text = None):
  213.         if not self.use_terminal:
  214.             return text
  215.         else:
  216.             return (text, True)
  217.  
  218.     
  219.     def action(self, text = None):
  220.         if self.use_terminal:
  221.             
  222.             try:
  223.                 prog = subprocess.Popen(text.split(' '), stdout = subprocess.PIPE, stderr = subprocess.STDOUT)
  224.                 zenity = subprocess.Popen([
  225.                     'zenity',
  226.                     '--title=' + text,
  227.                     '--window-icon=' + join(deskbar.ART_DATA_DIR, 'generic.png'),
  228.                     '--width=700',
  229.                     '--height=500',
  230.                     '--text-info'], stdin = prog.stdout)
  231.                 gobject.child_watch_add(zenity.pid, (lambda pid, code: pass))
  232.                 gobject.child_watch_add(prog.pid, (lambda pid, code: pass))
  233.                 return None
  234.  
  235.         
  236.         gobject.spawn_async(text.split(' '), flags = gobject.SPAWN_SEARCH_PATH)
  237.  
  238.     
  239.     def get_category(self):
  240.         return 'actions'
  241.  
  242.     
  243.     def get_verb(self):
  244.         return _('Execute %s') % '<b>%(text)s</b>'
  245.  
  246.  
  247.  
  248. class ProgramsHandler(deskbar.Handler.Handler):
  249.     
  250.     def __init__(self):
  251.         deskbar.Handler.Handler.__init__(self, gtk.STOCK_EXECUTE)
  252.         self._indexer = deskbar.Indexer.Indexer()
  253.  
  254.     
  255.     def initialize(self):
  256.         self._scan_desktop_files()
  257.         self._path = _[1]
  258.  
  259.     
  260.     def query(self, query):
  261.         result = self.query_path_programs(query)
  262.         result += self.query_desktop_programs(query)
  263.         return result
  264.  
  265.     
  266.     def query_path_programs(self, query):
  267.         args = query.split(' ')
  268.         match = self._check_program(args[0])
  269.         if match != None:
  270.             return [
  271.                 match]
  272.         else:
  273.             return []
  274.  
  275.     
  276.     def query_desktop_programs(self, query):
  277.         result = []
  278.         for match in self._indexer.look_up(query):
  279.             match._priority = get_priority_for_name(query, match._desktop.get_string('Exec'))
  280.             result.append(match)
  281.         
  282.         return result
  283.  
  284.     
  285.     def on_key_press(self, query, shortcut):
  286.         if shortcut == gtk.keysyms.t:
  287.             match = self._check_program(query.split(' ')[0])
  288.             if match != None:
  289.                 match.set_with_terminal(True)
  290.                 return match
  291.             
  292.         
  293.  
  294.     
  295.     def _check_program(self, program):
  296.         for path in self._path:
  297.             prog_path = join(path, program)
  298.             if exists(prog_path) and isfile(prog_path):
  299.                 return PathProgramMatch(self, program)
  300.                 continue
  301.         
  302.  
  303.     
  304.     def _scan_desktop_files(self):
  305.         for dir in get_xdg_data_dirs():
  306.             for f in glob.glob(join(dir, 'applications', '*.desktop')):
  307.                 result = parse_desktop_file(f)
  308.                 if result != None:
  309.                     match = GenericProgramMatch(self, name = cgi.escape(result.get_localestring(deskbar.gnomedesktop.KEY_NAME)), icon = result.get_string(deskbar.gnomedesktop.KEY_ICON), desktop = result, desktop_file = f)
  310.                     self._indexer.add('%s %s %s %s %s' % (result.get_string('Exec'), result.get_localestring(deskbar.gnomedesktop.KEY_NAME), result.get_localestring(deskbar.gnomedesktop.KEY_COMMENT), result.get_string(deskbar.gnomedesktop.KEY_NAME), result.get_string(deskbar.gnomedesktop.KEY_COMMENT)), match)
  311.                     continue
  312.             
  313.         
  314.  
  315.  
  316.  
  317. def get_priority_for_name(query, name):
  318.     if name.split(' ')[0].endswith(query):
  319.         return EXACT_MATCH_PRIO
  320.     else:
  321.         return EXACT_WORD_PRIO
  322.  
  323.  
  324. def parse_desktop_filename(desktop, only_if_visible = True):
  325.     if desktop[0] == '/' and exists(desktop):
  326.         return parse_desktop_file(desktop, only_if_visible)
  327.     
  328.     for dir in get_xdg_data_dirs():
  329.         f = join(dir, 'applications', desktop)
  330.         if exists(f):
  331.             return parse_desktop_file(f, only_if_visible)
  332.             continue
  333.     
  334.  
  335.  
  336. def parse_desktop_file(desktop, only_if_visible = True):
  337.     
  338.     try:
  339.         desktop = deskbar.gnomedesktop.item_new_from_file(desktop, deskbar.gnomedesktop.LOAD_ONLY_IF_EXISTS)
  340.     except Exception:
  341.         e = None
  342.         print "Couldn't read desktop file:%s:%s" % (desktop, e)
  343.         return None
  344.  
  345.     if desktop == None or desktop.get_entry_type() != deskbar.gnomedesktop.TYPE_APPLICATION:
  346.         return None
  347.     
  348.     if desktop.get_boolean(deskbar.gnomedesktop.KEY_TERMINAL):
  349.         return None
  350.     
  351.     if only_if_visible and desktop.get_boolean(deskbar.gnomedesktop.KEY_NO_DISPLAY):
  352.         return None
  353.     
  354.     return desktop
  355.  
  356.