home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / util / primitives / fmtstr.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  5.8 KB  |  188 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. from collections import defaultdict
  5. from util import Storage
  6.  
  7. class FormattingException(Exception):
  8.     pass
  9.  
  10.  
  11. class fmtstr(object):
  12.     least_lossy = [
  13.         'rtf',
  14.         'singleformat',
  15.         'plaintext']
  16.     
  17.     def plaintext(txt):
  18.         return fmtstr(plaintext = txt)
  19.  
  20.     plaintext = staticmethod(plaintext)
  21.     
  22.     def singleformat(s, format):
  23.         return fmtstr(singleformat = dict(text = s, format = format))
  24.  
  25.     singleformat = staticmethod(singleformat)
  26.     
  27.     def __init__(self, **string_values):
  28.         for k, v in string_values.items():
  29.             if v is None:
  30.                 string_values.pop(k)
  31.                 continue
  32.             string_values[k] = getattr(self, '_transform_' + k, (lambda v: v))(v)
  33.         
  34.         self.string_values = string_values
  35.  
  36.     
  37.     def _transform_singleformat(self, val):
  38.         import wx
  39.         format = val.get('format')
  40.         if format is None:
  41.             return None
  42.         format_primitive = { }
  43.         for k, v in format.items():
  44.             format_primitive[k] = format is None if isinstance(v, wx.Color) else v
  45.         
  46.         val['format'] = format_primitive
  47.         return val
  48.  
  49.     
  50.     def __add__(self, text):
  51.         rtf = self.string_values.get('rtf')
  52.         if rtf is not None:
  53.             return fmtstr(rtf = rtf_append(rtf, text))
  54.         singleformat = self.string_values.get('singleformat')
  55.         if singleformat is not None:
  56.             return fmtstr.singleformat(singleformat['text'] + text, format = singleformat['format'])
  57.         return fmtstr.plainttext(self.format_as('plaintext') + text)
  58.  
  59.     
  60.     def bestFormat(self):
  61.         for fmt in self.least_lossy:
  62.             if fmt in self.string_values:
  63.                 return fmt
  64.         
  65.  
  66.     bestFormat = property(bestFormat)
  67.     
  68.     def asDict(self):
  69.         serialized_dict = { }
  70.         for fmt in self.least_lossy:
  71.             
  72.             try:
  73.                 val = self.string_values[fmt]
  74.             except KeyError:
  75.                 continue
  76.  
  77.             serialized_dict[fmt] = val
  78.         
  79.         return serialized_dict
  80.  
  81.     
  82.     def fromDict(dict):
  83.         return fmtstr(**dict)
  84.  
  85.     fromDict = staticmethod(fromDict)
  86.     
  87.     def __repr__(self):
  88.         
  89.         try:
  90.             r = self.string_values['plaintext']
  91.         except KeyError:
  92.             r = repr(self.string_values)[:40]
  93.  
  94.         return '<fmtstr %r>' % r
  95.  
  96.     
  97.     def format_as(self, type):
  98.         
  99.         try:
  100.             return self.string_values[type]
  101.         except KeyError:
  102.             for encoder in self._encoder_types[type]:
  103.                 
  104.                 try:
  105.                     val = encoder(self)
  106.                 except FormattingException:
  107.                     val = None
  108.  
  109.                 if val is not None:
  110.                     self.string_values[type] = val
  111.                     return val
  112.             
  113.             raise FormattingException('cannot format as %r' % type)
  114.         except:
  115.             val is not None
  116.  
  117.  
  118.     _encoder_types = defaultdict(list)
  119.  
  120.  
  121. try:
  122.     from cgui import RTFToX
  123. except ImportError:
  124.     pass
  125.  
  126. import cgui
  127.  
  128. def register_encoder(output_type, encoder):
  129.     fmtstr._encoder_types[output_type].append(encoder)
  130.  
  131.  
  132. def register_rtf_encoder(fmt):
  133.     
  134.     def encoder(fmtstr):
  135.         rtf = fmtstr.format_as('rtf')
  136.         if rtf is not None:
  137.             return RTFToX().Convert(rtf, fmt, 'rtf')
  138.  
  139.     encoder.__name__ = 'rtf_to_%s_encoder' % fmt
  140.     register_encoder(fmt, encoder)
  141.  
  142.  
  143. def register_plaintext_encoder(fmt):
  144.     
  145.     def encoder(fmtstr):
  146.         plaintext = fmtstr.format_as('plaintext')
  147.         if plaintext is not None:
  148.             return RTFToX().Convert(plaintext, fmt, 'plaintext')
  149.  
  150.     encoder.__name__ = 'plaintext_to_%s_encoder' % fmt
  151.     register_encoder(fmt, encoder)
  152.  
  153.  
  154. def register_singleformat_encoder(fmt):
  155.     
  156.     def encoder(fmtstr):
  157.         singleformat = fmtstr.format_as('singleformat')
  158.         if singleformat is not None:
  159.             StorageToStyle = StorageToStyle
  160.             import gui.uberwidgets.formattedinput2.fontutil
  161.             formatstorage = singleformat['format']
  162.             if not isinstance(formatstorage, Storage):
  163.                 formatstorage = Storage(formatstorage)
  164.             
  165.             textattr = StorageToStyle(formatstorage)
  166.             return RTFToX().Convert(singleformat['text'], fmt, 'plaintext', textattr)
  167.  
  168.     encoder.__name__ = 'singleformat_to_%s_encoder' % fmt
  169.     register_encoder(fmt, encoder)
  170.  
  171.  
  172. def singleformat_to_plaintext(fmtstr):
  173.     return fmtstr.format_as('singleformat')['text']
  174.  
  175. register_encoder('plaintext', singleformat_to_plaintext)
  176. for fmt in cgui.RTFToX.EncoderTypes():
  177.     register_rtf_encoder(fmt)
  178.     register_singleformat_encoder(fmt)
  179.     register_plaintext_encoder(fmt)
  180.  
  181.  
  182. def rtf_append(rtf, text):
  183.     i = rtf.rfind('\\par')
  184.     i = rtf.rfind(' ', 0, i)
  185.     i = rtf.find('\\', i)
  186.     return ''.join((rtf[:i], text, rtf[i:]))
  187.  
  188.