home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / lib / gedit-2 / plugins / snippets / Library.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-04-20  |  28.6 KB  |  952 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. import os
  5. import weakref
  6. import sys
  7. import tempfile
  8. import re
  9. import gtk
  10. import ElementTree as et
  11. from Helper import *
  12.  
  13. class NamespacedId:
  14.     
  15.     def __init__(self, namespace, id):
  16.         if not id:
  17.             self.id = None
  18.         elif namespace:
  19.             self.id = namespace + '-'
  20.         else:
  21.             self.id = 'global-'
  22.         self.id += id
  23.  
  24.  
  25.  
  26. class SnippetData:
  27.     PROPS = {
  28.         'tag': '',
  29.         'text': '',
  30.         'description': 'New snippet',
  31.         'accelerator': '',
  32.         'drop-targets': '' }
  33.     
  34.     def __init__(self, node, library):
  35.         self.priv_id = node.attrib.get('id')
  36.         self.set_library(library)
  37.         self.valid = False
  38.         self.set_node(node)
  39.  
  40.     
  41.     def can_modify(self):
  42.         if self.library:
  43.             pass
  44.         return isinstance(self.library(), SnippetsUserFile)
  45.  
  46.     
  47.     def set_library(self, library):
  48.         if library:
  49.             self.library = weakref.ref(library)
  50.         else:
  51.             self.library = None
  52.         self.id = NamespacedId(self.language(), self.priv_id).id
  53.  
  54.     
  55.     def set_node(self, node):
  56.         if self.can_modify():
  57.             self.node = node
  58.         else:
  59.             self.node = None
  60.         self.init_snippet_data(node)
  61.  
  62.     
  63.     def init_snippet_data(self, node):
  64.         if node == None:
  65.             return None
  66.         self.override = node.attrib.get('override')
  67.         self.properties = { }
  68.         props = SnippetData.PROPS.copy()
  69.         for child in node:
  70.             if child.tag in props:
  71.                 del props[child.tag]
  72.                 if child.tag == 'accelerator' and child.text != None:
  73.                     (keyval, mod) = gtk.accelerator_parse(child.text)
  74.                     if gtk.accelerator_valid(keyval, mod):
  75.                         child.text = gtk.accelerator_name(keyval, mod)
  76.                     else:
  77.                         child.text = ''
  78.                 
  79.                 if self.can_modify():
  80.                     self.properties[child.tag] = child
  81.                 elif not child.text:
  82.                     pass
  83.                 self.properties[child.tag] = ''
  84.                 continue
  85.         
  86.         for prop in props:
  87.             if self.can_modify():
  88.                 child = et.SubElement(node, prop)
  89.                 child.text = props[prop]
  90.                 self.properties[prop] = child
  91.                 continue
  92.             self.properties[prop] = props[prop]
  93.         
  94.         self.check_validation()
  95.  
  96.     
  97.     def check_validation(self):
  98.         if not self['tag'] and not self['accelerator'] and not self['drop-targets']:
  99.             return False
  100.         library = Library()
  101.         (keyval, mod) = gtk.accelerator_parse(self['accelerator'])
  102.         if not library.valid_tab_trigger(self['tag']) and not self['accelerator']:
  103.             pass
  104.         self.valid = library.valid_accelerator(keyval, mod)
  105.  
  106.     
  107.     def _format_prop(self, prop, value):
  108.         if prop == 'drop-targets' and value != '':
  109.             return re.split('\\s*[,;]\\s*', value)
  110.         return value
  111.  
  112.     
  113.     def __getitem__(self, prop):
  114.         if prop in self.properties:
  115.             if self.can_modify():
  116.                 if not self.properties[prop].text:
  117.                     pass
  118.                 return self._format_prop(prop, '')
  119.             if not self.properties[prop]:
  120.                 pass
  121.             return self._format_prop(prop, '')
  122.         prop in self.properties
  123.         return self._format_prop(prop, '')
  124.  
  125.     
  126.     def __setitem__(self, prop, value):
  127.         if prop not in self.properties:
  128.             return None
  129.         if isinstance(value, list):
  130.             value = ','.join(value)
  131.         
  132.         if not self.can_modify() and self.properties[prop] != value:
  133.             self._override()
  134.         
  135.         if self.can_modify() and self.properties[prop].text != value:
  136.             if self.library():
  137.                 self.library().tainted = True
  138.             
  139.             oldvalue = self.properties[prop].text
  140.             self.properties[prop].text = value
  141.             if prop == 'tag' and prop == 'accelerator' or prop == 'drop-targets':
  142.                 container = Library().container(self.language())
  143.                 container.prop_changed(self, prop, oldvalue)
  144.             
  145.         
  146.         self.check_validation()
  147.  
  148.     
  149.     def language(self):
  150.         if self.library and self.library():
  151.             return self.library().language
  152.         return None
  153.  
  154.     
  155.     def is_override(self):
  156.         if self.override:
  157.             pass
  158.         return Library().overridden[self.override]
  159.  
  160.     
  161.     def to_xml(self):
  162.         return self._create_xml()
  163.  
  164.     
  165.     def _create_xml(self, parent = None, update = False, attrib = { }):
  166.         if parent != None:
  167.             element = et.SubElement(parent, 'snippet', attrib)
  168.         else:
  169.             element = et.Element('snippet')
  170.         for p in self.properties:
  171.             prop = et.SubElement(element, p)
  172.             prop.text = self[p]
  173.             if update:
  174.                 self.properties[p] = prop
  175.                 continue
  176.         
  177.         return element
  178.  
  179.     
  180.     def _override(self):
  181.         target = Library().get_user_library(self.language())
  182.         element = self._create_xml(target.root, True, {
  183.             'override': self.id })
  184.         override = SnippetData(element, self.library())
  185.         override.set_node(None)
  186.         override.id = self.id
  187.         self.node = element
  188.         self.override = self.id
  189.         self.id = None
  190.         self.set_library(target)
  191.         target.tainted = True
  192.         Library().overridden[self.override] = override
  193.  
  194.     
  195.     def revert(self, snippet):
  196.         userlib = self.library()
  197.         self.set_library(snippet.library())
  198.         userlib.remove(self.node)
  199.         self.set_node(None)
  200.         self.properties = snippet.properties
  201.         self.id = snippet.id
  202.         self.override = None
  203.  
  204.  
  205.  
  206. class SnippetsTreeBuilder(et.TreeBuilder):
  207.     
  208.     def __init__(self, start = None, end = None):
  209.         et.TreeBuilder.__init__(self)
  210.         self.set_start(start)
  211.         self.set_end(end)
  212.  
  213.     
  214.     def set_start(self, start):
  215.         self._start_cb = start
  216.  
  217.     
  218.     def set_end(self, end):
  219.         self._end_cb = end
  220.  
  221.     
  222.     def start(self, tag, attrs):
  223.         result = et.TreeBuilder.start(self, tag, attrs)
  224.         if self._start_cb:
  225.             self._start_cb(result)
  226.         
  227.         return result
  228.  
  229.     
  230.     def end(self, tag):
  231.         result = et.TreeBuilder.end(self, tag)
  232.         if self._end_cb:
  233.             self._end_cb(result)
  234.         
  235.         return result
  236.  
  237.  
  238.  
  239. class LanguageContainer:
  240.     
  241.     def __init__(self, language):
  242.         self.language = language
  243.         self.snippets = []
  244.         self.snippets_by_prop = {
  245.             'tag': { },
  246.             'accelerator': { },
  247.             'drop-targets': { } }
  248.         self.accel_group = gtk.AccelGroup()
  249.         self._refs = 0
  250.  
  251.     
  252.     def _add_prop(self, snippet, prop, value = 0):
  253.         if value == 0:
  254.             value = snippet[prop]
  255.         
  256.         if not value or value == '':
  257.             return None
  258.         snippets_debug('Added ', prop, ' ', value, ' to ', str(self.language))
  259.         if prop == 'accelerator':
  260.             (keyval, mod) = gtk.accelerator_parse(value)
  261.             self.accel_group.connect_group(keyval, mod, 0, Library().accelerator_activated)
  262.         
  263.         snippets = self.snippets_by_prop[prop]
  264.         if not isinstance(value, list):
  265.             value = [
  266.                 value]
  267.         
  268.         for val in value:
  269.             if val in snippets:
  270.                 snippets[val].append(snippet)
  271.                 continue
  272.             snippets[val] = [
  273.                 snippet]
  274.         
  275.  
  276.     
  277.     def _remove_prop(self, snippet, prop, value = 0):
  278.         if value == 0:
  279.             value = snippet[prop]
  280.         
  281.         if not value or value == '':
  282.             return None
  283.         snippets_debug('Removed ', prop, ' ', value, ' from ', str(self.language))
  284.         if prop == 'accelerator':
  285.             (keyval, mod) = gtk.accelerator_parse(value)
  286.             self.accel_group.disconnect_key(keyval, mod)
  287.         
  288.         snippets = self.snippets_by_prop[prop]
  289.         if not isinstance(value, list):
  290.             value = [
  291.                 value]
  292.         
  293.         for val in value:
  294.             
  295.             try:
  296.                 snippets[val].remove(snippet)
  297.             continue
  298.             True
  299.             continue
  300.  
  301.         
  302.  
  303.     
  304.     def append(self, snippet):
  305.         tag = snippet['tag']
  306.         accelerator = snippet['accelerator']
  307.         self.snippets.append(snippet)
  308.         self._add_prop(snippet, 'tag')
  309.         self._add_prop(snippet, 'accelerator')
  310.         self._add_prop(snippet, 'drop-targets')
  311.         return snippet
  312.  
  313.     
  314.     def remove(self, snippet):
  315.         
  316.         try:
  317.             self.snippets.remove(snippet)
  318.         except:
  319.             True
  320.  
  321.         self._remove_prop(snippet, 'tag')
  322.         self._remove_prop(snippet, 'accelerator')
  323.         self._remove_prop(snippet, 'drop-targets')
  324.  
  325.     
  326.     def prop_changed(self, snippet, prop, oldvalue):
  327.         snippets_debug('PROP CHANGED (', prop, ')', oldvalue)
  328.         self._remove_prop(snippet, prop, oldvalue)
  329.         self._add_prop(snippet, prop)
  330.  
  331.     
  332.     def from_prop(self, prop, value):
  333.         snippets = self.snippets_by_prop[prop]
  334.         if prop == 'drop-targets':
  335.             s = []
  336.             for key, val in snippets.items():
  337.                 if not value.startswith(key):
  338.                     continue
  339.                 
  340.                 for snippet in snippets[key]:
  341.                     if snippet not in s:
  342.                         s.append(snippet)
  343.                         continue
  344.                 
  345.             
  346.             return s
  347.         if value in snippets:
  348.             return snippets[value]
  349.         return []
  350.  
  351.     
  352.     def ref(self):
  353.         self._refs += 1
  354.         return True
  355.  
  356.     
  357.     def unref(self):
  358.         if self._refs > 0:
  359.             self._refs -= 1
  360.         
  361.         return self._refs != 0
  362.  
  363.  
  364.  
  365. class SnippetsSystemFile:
  366.     
  367.     def __init__(self, path = None):
  368.         self.path = path
  369.         self.loaded = False
  370.         self.language = None
  371.         self.ok = True
  372.         self.need_id = True
  373.  
  374.     
  375.     def load_error(self, message):
  376.         sys.stderr.write('An error occurred loading ' + self.path + ':\n')
  377.         sys.stderr.write(message + '\nSnippets in this file will not be available, please correct or remove the file.\n')
  378.  
  379.     
  380.     def _add_snippet(self, element):
  381.         if not (self.need_id) or element.attrib.get('id'):
  382.             self.loading_elements.append(element)
  383.         
  384.  
  385.     
  386.     def set_language(self, element):
  387.         self.language = element.attrib.get('language')
  388.         if self.language:
  389.             self.language = self.language.lower()
  390.         
  391.  
  392.     
  393.     def _set_root(self, element):
  394.         self.set_language(element)
  395.  
  396.     
  397.     def _preprocess_element(self, element):
  398.         if not self.loaded:
  399.             if not element.tag == 'snippets':
  400.                 self.load_error("Root element should be `snippets' instead of `%s'" % element.tag)
  401.                 return False
  402.             self._set_root(element)
  403.             self.loaded = True
  404.         elif element.tag != 'snippet' and not (self.insnippet):
  405.             self.load_error("Element should be `snippet' instead of `%s'" % element.tag)
  406.             return False
  407.         self.insnippet = True
  408.         return True
  409.  
  410.     
  411.     def _process_element(self, element):
  412.         if element.tag == 'snippet':
  413.             self._add_snippet(element)
  414.             self.insnippet = False
  415.         
  416.         return True
  417.  
  418.     
  419.     def ensure(self):
  420.         if not (self.ok) or self.loaded:
  421.             return None
  422.         self.load()
  423.  
  424.     
  425.     def parse_xml(self, readsize = 16384):
  426.         if not self.path:
  427.             return None
  428.         elements = []
  429.         builder = (SnippetsTreeBuilder,)(((lambda node: elements.append((node, True))),), (lambda node: elements.append((node, False))))
  430.         parser = et.XMLTreeBuilder(target = builder)
  431.         self.insnippet = False
  432.         
  433.         try:
  434.             f = open(self.path, 'r')
  435.             while True:
  436.                 data = f.read(readsize)
  437.                 if not data:
  438.                     break
  439.                 
  440.                 parser.feed(data)
  441.                 for element in elements:
  442.                     yield element
  443.                 
  444.                 del elements[:]
  445.             f.close()
  446.         except IOError:
  447.             self.path
  448.             self.path
  449.             self.ok = False
  450.         except:
  451.             self.path
  452.  
  453.  
  454.     
  455.     def load(self):
  456.         if not self.ok:
  457.             return None
  458.         snippets_debug('Loading library (' + str(self.language) + '): ' + self.path)
  459.         self.loaded = False
  460.         self.ok = False
  461.         self.loading_elements = []
  462.         for element in self.parse_xml():
  463.             if element[1]:
  464.                 if not self._preprocess_element(element[0]):
  465.                     del self.loading_elements[:]
  466.                     return None
  467.                 continue
  468.             self._preprocess_element(element[0])
  469.             if not self._process_element(element[0]):
  470.                 del self.loading_elements[:]
  471.                 return None
  472.         
  473.         for element in self.loading_elements:
  474.             snippet = Library().add_snippet(self, element)
  475.         
  476.         del self.loading_elements[:]
  477.         self.ok = True
  478.  
  479.     
  480.     def ensure_language(self):
  481.         if not self.loaded:
  482.             self.ok = False
  483.             for element in self.parse_xml(256):
  484.                 if element[1]:
  485.                     if element[0].tag == 'snippets':
  486.                         self.set_language(element[0])
  487.                         self.ok = True
  488.                     
  489.                     break
  490.                     continue
  491.             
  492.         
  493.  
  494.     
  495.     def unload(self):
  496.         snippets_debug('Unloading library (' + str(self.language) + '): ' + self.path)
  497.         self.language = None
  498.         self.loaded = False
  499.         self.ok = True
  500.  
  501.  
  502.  
  503. class SnippetsUserFile(SnippetsSystemFile):
  504.     
  505.     def __init__(self, path = None):
  506.         SnippetsSystemFile.__init__(self, path)
  507.         self.tainted = False
  508.         self.need_id = False
  509.  
  510.     
  511.     def _set_root(self, element):
  512.         SnippetsSystemFile._set_root(self, element)
  513.         self.root = element
  514.  
  515.     
  516.     def add_prop(self, node, tag, data):
  517.         if data[tag]:
  518.             prop = et.SubElement(node, tag)
  519.             prop.text = data[tag]
  520.             return prop
  521.         return None
  522.  
  523.     
  524.     def new_snippet(self, properties = None):
  525.         if not (self.ok) or self.root == None:
  526.             return None
  527.         element = et.SubElement(self.root, 'snippet')
  528.         if properties:
  529.             for prop in properties:
  530.                 sub = et.SubElement(element, prop)
  531.                 sub.text = properties[prop]
  532.             
  533.         
  534.         self.tainted = True
  535.         return Library().add_snippet(self, element)
  536.  
  537.     
  538.     def set_language(self, element):
  539.         SnippetsSystemFile.set_language(self, element)
  540.         filename = os.path.basename(self.path).lower()
  541.         if not (self.language) and filename == 'global.xml':
  542.             self.modifier = True
  543.         elif self.language and filename == self.language + '.xml':
  544.             self.modifier = True
  545.         else:
  546.             self.modifier = False
  547.  
  548.     
  549.     def create_root(self, language):
  550.         if self.loaded:
  551.             snippets_debug('Not creating root, already loaded')
  552.             return None
  553.         if language:
  554.             root = et.Element('snippets', {
  555.                 'language': language })
  556.             self.path = os.path.join(Library().userdir, language.lower() + '.xml')
  557.         else:
  558.             root = et.Element('snippets')
  559.             self.path = os.path.join(Library().userdir, 'global.xml')
  560.         self._set_root(root)
  561.         self.loaded = True
  562.         self.ok = True
  563.         self.tainted = True
  564.         self.save()
  565.  
  566.     
  567.     def remove(self, element):
  568.         
  569.         try:
  570.             self.root.remove(element)
  571.             self.tainted = True
  572.         except:
  573.             return None
  574.  
  575.         
  576.         try:
  577.             first = self.root[0]
  578.         except:
  579.             Library().remove_library(self)
  580.  
  581.  
  582.     
  583.     def save(self):
  584.         if not (self.ok) and self.root == None or not (self.tainted):
  585.             return None
  586.         path = os.path.dirname(self.path)
  587.         
  588.         try:
  589.             if not os.path.isdir(path):
  590.                 os.makedirs(path, 493)
  591.         except OSError:
  592.             not (self.tainted)
  593.             not (self.tainted)
  594.             sys.stderr.write('Error in making dirs\n')
  595.         except:
  596.             not (self.tainted)
  597.  
  598.         
  599.         try:
  600.             write_xml(self.root, self.path, ('text', 'accelerator'))
  601.             self.tainted = False
  602.         except IOError:
  603.             not (self.tainted)
  604.             not (self.tainted)
  605.             sys.stderr.write('Could not save user snippets file to ' + self.path + '\n')
  606.         except:
  607.             not (self.tainted)
  608.  
  609.  
  610.     
  611.     def unload(self):
  612.         SnippetsSystemFile.unload(self)
  613.         self.root = None
  614.  
  615.  
  616.  
  617. class Singleton(object):
  618.     _instance = None
  619.     
  620.     def __new__(cls, *args, **kwargs):
  621.         if not cls._instance:
  622.             cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
  623.             cls._instance.__init_once__()
  624.         
  625.         return cls._instance
  626.  
  627.  
  628.  
  629. class Library(Singleton):
  630.     
  631.     def __init_once__(self):
  632.         self._accelerator_activated_cb = None
  633.         self.loaded = False
  634.         self.check_buffer = gtk.TextBuffer()
  635.  
  636.     
  637.     def set_dirs(self, userdir, systemdirs):
  638.         self.userdir = userdir
  639.         self.systemdirs = systemdirs
  640.         self.libraries = { }
  641.         self.containers = { }
  642.         self.overridden = { }
  643.         self.loaded_ids = []
  644.         self.loaded = False
  645.  
  646.     
  647.     def set_accelerator_callback(self, cb):
  648.         self._accelerator_activated_cb = cb
  649.  
  650.     
  651.     def accelerator_activated(self, group, obj, keyval, mod):
  652.         if self._accelerator_activated_cb:
  653.             self._accelerator_activated_cb(group, obj, keyval, mod)
  654.         
  655.  
  656.     
  657.     def add_snippet(self, library, element):
  658.         container = self.container(library.language)
  659.         overrided = self.overrided(library, element)
  660.         if overrided:
  661.             overrided.set_library(library)
  662.             snippets_debug('Snippet is overriden: ' + overrided['description'])
  663.             return None
  664.         snippet = SnippetData(element, library)
  665.         if snippet.id in self.loaded_ids:
  666.             snippets_debug('Not added snippet ' + str(library.language) + '::' + snippet['description'] + ' (duplicate)')
  667.             return None
  668.         snippet = container.append(snippet)
  669.         snippets_debug('Added snippet ' + str(library.language) + '::' + snippet['description'])
  670.         if snippet.id:
  671.             self.loaded_ids.append(snippet.id)
  672.         
  673.         return snippet
  674.  
  675.     
  676.     def container(self, language):
  677.         language = self.normalize_language(language)
  678.         if language not in self.containers:
  679.             self.containers[language] = LanguageContainer(language)
  680.         
  681.         return self.containers[language]
  682.  
  683.     
  684.     def get_user_library(self, language):
  685.         target = None
  686.         if language in self.libraries:
  687.             for library in self.libraries[language]:
  688.                 if isinstance(library, SnippetsUserFile) and library.modifier:
  689.                     target = library
  690.                     continue
  691.                 if not isinstance(library, SnippetsUserFile):
  692.                     break
  693.                     continue
  694.             
  695.         
  696.         if not target:
  697.             snippets_debug('Creating a new user file for language ' + str(language))
  698.             target = SnippetsUserFile()
  699.             target.create_root(language)
  700.             self.add_library(target)
  701.         
  702.         return target
  703.  
  704.     
  705.     def new_snippet(self, language, properties = None):
  706.         language = self.normalize_language(language)
  707.         library = self.get_user_library(language)
  708.         return library.new_snippet(properties)
  709.  
  710.     
  711.     def revert_snippet(self, snippet):
  712.         if not snippet.can_modify() or snippet.override not in self.overridden:
  713.             return None
  714.         revertto = self.overridden[snippet.override]
  715.         del self.overridden[snippet.override]
  716.         if revertto:
  717.             snippet.revert(revertto)
  718.             if revertto.id:
  719.                 self.loaded_ids.append(revertto.id)
  720.             
  721.         
  722.  
  723.     
  724.     def remove_snippet(self, snippet):
  725.         if not snippet.can_modify() or snippet.is_override():
  726.             return None
  727.         userlib = snippet.library()
  728.         userlib.remove(snippet.node)
  729.         container = self.containers[userlib.language]
  730.         container.remove(snippet)
  731.  
  732.     
  733.     def overrided(self, library, element):
  734.         id = NamespacedId(library.language, element.attrib.get('id')).id
  735.         if id in self.overridden:
  736.             snippet = SnippetData(element, None)
  737.             snippet.set_node(None)
  738.             self.overridden[id] = snippet
  739.             return snippet
  740.         return None
  741.  
  742.     
  743.     def add_override(self, snippet):
  744.         snippets_debug('Add override:', snippet.override)
  745.         if snippet.override not in self.overridden:
  746.             self.overridden[snippet.override] = None
  747.         
  748.  
  749.     
  750.     def add_library(self, library):
  751.         library.ensure_language()
  752.         if not library.ok:
  753.             snippets_debug('Library in wrong format, ignoring')
  754.             return False
  755.         snippets_debug('Adding library (' + str(library.language) + '): ' + library.path)
  756.         if library.language in self.libraries:
  757.             if isinstance(library, SnippetsUserFile):
  758.                 self.libraries[library.language].insert(0, library)
  759.             else:
  760.                 self.libraries[library.language].append(library)
  761.         else:
  762.             self.libraries[library.language] = [
  763.                 library]
  764.         return True
  765.  
  766.     
  767.     def remove_library(self, library):
  768.         if not library.ok:
  769.             return None
  770.         if library.path and os.path.isfile(library.path):
  771.             os.unlink(library.path)
  772.         
  773.         
  774.         try:
  775.             self.libraries[library.language].remove(library)
  776.         except KeyError:
  777.             True
  778.  
  779.         container = self.containers[library.language]
  780.         for snippet in list(container.snippets):
  781.             if snippet.library() == library:
  782.                 container.remove(snippet)
  783.                 continue
  784.         
  785.  
  786.     
  787.     def add_user_library(self, path):
  788.         library = SnippetsUserFile(path)
  789.         return self.add_library(library)
  790.  
  791.     
  792.     def add_system_library(self, path):
  793.         library = SnippetsSystemFile(path)
  794.         return self.add_library(library)
  795.  
  796.     
  797.     def find_libraries(self, path, searched, addcb):
  798.         snippets_debug('Finding in: ' + path)
  799.         if not os.path.isdir(path):
  800.             return searched
  801.         files = os.listdir(path)
  802.         searched.append(path)
  803.         for f in files:
  804.             f = os.path.realpath(os.path.join(path, f))
  805.             if os.path.isfile(f):
  806.                 addcb(f)
  807.                 continue
  808.             os.path.isdir(path)
  809.         
  810.         return searched
  811.  
  812.     
  813.     def normalize_language(self, language):
  814.         if language:
  815.             return language.lower()
  816.         return language
  817.  
  818.     
  819.     def remove_container(self, language):
  820.         for snippet in self.containers[language].snippets:
  821.             if snippet.id in self.loaded_ids:
  822.                 self.loaded_ids.remove(snippet.id)
  823.             
  824.             if snippet.override in self.overridden:
  825.                 del self.overridden[snippet.override]
  826.                 continue
  827.         
  828.         del self.containers[language]
  829.  
  830.     
  831.     def get_accel_group(self, language):
  832.         language = self.normalize_language(language)
  833.         container = self.container(language)
  834.         self.ensure(language)
  835.         return container.accel_group
  836.  
  837.     
  838.     def save(self, language):
  839.         language = self.normalize_language(language)
  840.         if language in self.libraries:
  841.             for library in self.libraries[language]:
  842.                 if isinstance(library, SnippetsUserFile):
  843.                     library.save()
  844.                     continue
  845.             
  846.         
  847.  
  848.     
  849.     def ref(self, language):
  850.         language = self.normalize_language(language)
  851.         snippets_debug('Ref:', language)
  852.         self.container(language).ref()
  853.  
  854.     
  855.     def unref(self, language):
  856.         language = self.normalize_language(language)
  857.         snippets_debug('Unref:', language)
  858.         if language in self.containers:
  859.             if not self.containers[language].unref() and language in self.libraries:
  860.                 for library in self.libraries[language]:
  861.                     library.unload()
  862.                 
  863.                 self.remove_container(language)
  864.             
  865.         
  866.  
  867.     
  868.     def ensure(self, language):
  869.         self.ensure_files()
  870.         language = self.normalize_language(language)
  871.         for lang in (None, language):
  872.             if lang in self.libraries:
  873.                 self.container(lang)
  874.                 for library in self.libraries[lang]:
  875.                     library.ensure()
  876.                 
  877.         
  878.  
  879.     
  880.     def ensure_files(self):
  881.         if self.loaded:
  882.             return None
  883.         searched = []
  884.         searched = self.find_libraries(self.userdir, searched, self.add_user_library)
  885.         for d in self.systemdirs:
  886.             searched = self.find_libraries(d, searched, self.add_system_library)
  887.         
  888.         self.loaded = True
  889.  
  890.     
  891.     def valid_accelerator(self, keyval, mod):
  892.         mod &= gtk.accelerator_get_default_mod_mask()
  893.         if not mod and gdk.keyval_to_unicode(keyval):
  894.             pass
  895.         return keyval in range(gtk.keysyms.F1, gtk.keysyms.F12 + 1)
  896.  
  897.     
  898.     def valid_tab_trigger(self, trigger):
  899.         if not trigger:
  900.             return True
  901.         if trigger.isdigit():
  902.             return False
  903.         self.check_buffer.set_text(trigger)
  904.         (start, end) = self.check_buffer.get_bounds()
  905.         text = self.check_buffer.get_text(start, end)
  906.         s = start.copy()
  907.         e = end.copy()
  908.         end.backward_word_start()
  909.         start.forward_word_end()
  910.         if (s.equal(end) or e.equal(start)) and len(text) == 1:
  911.             if not text.isalnum():
  912.                 pass
  913.         return not text.isspace()
  914.  
  915.     
  916.     def _from_prop(self, prop, value, language = None):
  917.         self.ensure_files()
  918.         result = []
  919.         language = self.normalize_language(language)
  920.         if language not in self.containers:
  921.             return []
  922.         self.ensure(language)
  923.         result = self.containers[language].from_prop(prop, value)
  924.         if len(result) == 0 and language and None in self.containers:
  925.             result = self.containers[None].from_prop(prop, value)
  926.         
  927.         return result
  928.  
  929.     
  930.     def get_snippets(self, language = None):
  931.         self.ensure_files()
  932.         language = self.normalize_language(language)
  933.         if language not in self.libraries:
  934.             return []
  935.         snippets = []
  936.         self.ensure(language)
  937.         return list(self.containers[language].snippets)
  938.  
  939.     
  940.     def from_accelerator(self, accelerator, language = None):
  941.         return self._from_prop('accelerator', accelerator, language)
  942.  
  943.     
  944.     def from_tag(self, tag, language = None):
  945.         return self._from_prop('tag', tag, language)
  946.  
  947.     
  948.     def from_drop_target(self, drop_target, language = None):
  949.         return self._from_prop('drop-targets', drop_target, language)
  950.  
  951.  
  952.