#copyright ReportLab Inc. 2000

#see license.txt for license details

#history http://cvs.sourceforge.net/cgi-bin/cvsweb.cgi/reportlab/lib/utils.py?cvsroot=reportlab

import string, os, sys, imp

from types import *

from reportlab.lib.logger import warnOnce

SeqTypes = (ListType,TupleType)

if sys.hexversion<0x2030000:

    True = 1

    False = 0

def _findFiles(dirList,ext='.ttf'):

    from os.path import isfile, isdir, join as path_join

    from os import listdir

    ext = ext.lower()

    R = []

    A = R.append

    for D in dirList:

        if not isdir(D): continue

        for fn in listdir(D):

            fn = path_join(D,fn)

            if isfile(fn) and (not ext or fn.lower().endswith(ext)): A(fn)

    return R

try:

    _UserDict = dict

except:

    from UserDict import UserDict as _UserDict

class CIDict(_UserDict):

    def __init__(self,*a,**kw):

        map(self.update, a)

        self.update(kw)

    def update(self,D):

        for k,v in D.items(): self[k] = v

    def __setitem__(self,k,v):

        try:

            k = k.lower()

        except:

            pass

        _UserDict.__setitem__(self,k,v)

    def __getitem__(self,k):

        try:

            k = k.lower()

        except:

            pass

        return _UserDict.__getitem__(self,k)

    def __delitem__(self,k):

        try:

            k = k.lower()

        except:

            pass

        return _UserDict.__delitem__(self,k)

    def get(self,k,dv=None):

        try:

            return self[k]

        except KeyError:

            return dv

    def has_key(self,k):

        try:

            self[k]

            return True

        except:

            return False

    def pop(self,k,*a):

        try:

            k = k.lower()

        except:

            pass

        return _UserDict.pop(*((self,k)+a))

    def setdefault(self,k,*a):

        try:

            k = k.lower()

        except:

            pass

        return _UserDict.setdefault(*((self,k)+a))

if os.name == 'mac':

    #with the Mac, we need to tag the file in a special

    #way so the system knows it is a PDF file.

    #This supplied by Joe Strout

    import macfs, macostools

    _KNOWN_MAC_EXT = {

        'BMP' : ('ogle','BMP '),

        'EPS' : ('ogle','EPSF'),

        'EPSF': ('ogle','EPSF'),

        'GIF' : ('ogle','GIFf'),

        'JPG' : ('ogle','JPEG'),

        'JPEG': ('ogle','JPEG'),

        'PCT' : ('ttxt','PICT'),

        'PICT': ('ttxt','PICT'),

        'PNG' : ('ogle','PNGf'),

        'PPM' : ('ogle','.PPM'),

        'TIF' : ('ogle','TIFF'),

        'TIFF': ('ogle','TIFF'),

        'PDF' : ('CARO','PDF '),

        'HTML': ('MSIE','TEXT'),

        }

    def markfilename(filename,creatorcode=None,filetype=None,ext='PDF'):

        try:

            if creatorcode is None or filetype is None and ext is not None:

                try:

                    creatorcode, filetype = _KNOWN_MAC_EXT[string.upper(ext)]

                except:

                    return

            macfs.FSSpec(filename).SetCreatorType(creatorcode,filetype)

            macostools.touched(filename)

        except:

            pass

else:

    def markfilename(filename,creatorcode=None,filetype=None):

        pass

import reportlab

__RL_DIR=os.path.dirname(reportlab.__file__)    #possibly relative

_RL_DIR=os.path.isabs(__RL_DIR) and __RL_DIR or os.path.abspath(__RL_DIR)

del reportlab

#Attempt to detect if this copy of reportlab is running in a

#file system (as opposed to mostly running in a zip or McMillan

#archive or Jar file).  This is used by test cases, so that

#we can write test cases that don't get activated in a compiled

try:

    __file__

except:

    __file__ = sys.argv[0]

try:

    _isFSD = not __loader__

except:

    _isFSD = os.path.isfile(__file__)   #slight risk of wrong path

    __loader__ = None

_isFSSD = _isFSD and os.path.isfile(os.path.splitext(__file__)[0] +'.py')

def isFileSystemDistro():

    '''return truth if a file system distribution'''

    return _isFSD

def isCompactDistro():

    '''return truth if not a file system distribution'''

    return not _isFSD

def isSourceDistro():

    '''return truth if a source file system distribution'''

    return _isFSSD

try:

    #raise ImportError

    ### NOTE!  FP_STR SHOULD PROBABLY ALWAYS DO A PYTHON STR() CONVERSION ON ARGS

    ### IN CASE THEY ARE "LAZY OBJECTS".  ACCELLERATOR DOESN'T DO THIS (YET)

    try:

        from _rl_accel import fp_str                # in case of builtin version

    except ImportError:

        from reportlab.lib._rl_accel import fp_str  # specific

except ImportError:

    from math import log

    _log_10 = lambda x,log=log,_log_e_10=log(10.0): log(x)/_log_e_10

    _fp_fmts = "%.0f", "%.1f", "%.2f", "%.3f", "%.4f", "%.5f", "%.6f"

    import re

    _tz_re = re.compile('0+$')

    del re

    def fp_str(*a):

        if len(a)==1 and type(a[0]) in SeqTypes: a = a[0]

        s = []

        A = s.append

        for i in a:

            sa =abs(i)

            if sa<=1e-7: A('0')

            else:

                l = sa<=1 and 6 or min(max(0,(6-int(_log_10(sa)))),6)

                n = _fp_fmts[l]%i

                if l:

                    n = _tz_re.sub('',n)

                    try:

                        if n[-1]=='.': n = n[:-1]

                    except:

                        print i, n

                        raise

                A((n[0]!='0' or len(n)==1) and n or n[1:])

        return string.join(s)

#hack test for comma users

if ',' in fp_str(0.25):

    _FP_STR = fp_str

    def fp_str(*a):

        return string.replace(apply(_FP_STR,a),',','.')

_rl_tempdir=None

def get_rl_tempdir(*subdirs):

    global _rl_tempdir

    if _rl_tempdir is None:

        import tempfile

        _rl_tempdir = os.path.join(tempfile.gettempdir(),'ReportLab_tmp%s' % (sys.platform=='unix' and `os.getuid()` or ''))

    d = _rl_tempdir

    if subdirs: d = os.path.join(*((d,)+subdirs))

    try:

        os.makedirs(d)

    except:

        pass

    return d

def get_rl_tempfile(fn=None):

    if not fn:

        import tempfile

        return tempfile.mktemp('','',get_rl_tempdir())

    else:

        return os.path.join(get_rl_tempdir(),fn)

def recursiveImport(modulename, baseDir=None, noCWD=0, debug=0):

    """Dynamically imports possible packagized module, or raises ImportError"""

    normalize = lambda x: os.path.normcase(os.path.abspath(os.path.normpath(x)))

    path = map(normalize,sys.path)

    if baseDir:

        if type(baseDir) not in SeqTypes:

            tp = [baseDir]

        else:

            tp = filter(None,list(baseDir))

        for p in tp:

            p = normalize(p)

            if p not in path: path.insert(0,p)

    if noCWD:

        for p in ('','.',normalize('.')):

            while p in path:

                if debug: print 'removed "%s" from path' % p

                path.remove(p)

    elif '.' not in path:

            path.insert(0,'.')

    if debug:

        import pprint

        pp = pprint.pprint

        print 'path=',

        pp(path)

    #make import errors a bit more informative

    opath = sys.path

    try:

        sys.path = path

        exec 'import %s\nm = %s\n' % (modulename,modulename) in locals()

        sys.path = opath

        return m

    except ImportError:

        sys.path = opath

        msg = "recursiveimport(%s,baseDir=%s) failed" % (modulename,baseDir)

        if baseDir:

            msg = msg + " under paths '%s'" % `path`

        raise ImportError, msg

def recursiveGetAttr(obj, name):

    "Can call down into e.g. object1.object2[4].attr"

    return eval(name, obj.__dict__)

def recursiveSetAttr(obj, name, value):

    "Can call down into e.g. object1.object2[4].attr = value"

    #get the thing above last.

    tokens = string.split(name, '.')

    #print 'name=%s, tokens=%s' % (name, tokens)

    if len(tokens) == 1:

        setattr(obj, name, value)

    else:

        most = string.join(tokens[:-1], '.')

        last = tokens[-1]

        #print 'most=%s, last=%s' % (most, last)

        parent = recursiveGetAttr(obj, most)

        #print 'parent=%s' % parent

        setattr(parent, last, value)

def import_zlib():

    try:

        import zlib

    except ImportError:

        zlib = None

        from reportlab.rl_config import ZLIB_WARNINGS

        if ZLIB_WARNINGS: warnOnce('zlib not available')

    return zlib

# Image Capability Detection.  Set a flag haveImages

# to tell us if either PIL or Java imaging libraries present.

# define PIL_Image as either None, or an alias for the PIL.Image

# module, as there are 2 ways to import it

if sys.platform[0:4] == 'java':

    try:

        import javax.imageio

        import java.awt.image

        haveImages = 1

    except:

        haveImages = 0

else:

    try:

        from PIL import Image

    except ImportError:

        try:

            import Image

        except ImportError:

            Image = None

    haveImages = Image is not None

    if haveImages: del Image

__StringIO=None

def getStringIO(buf=None):

    '''unified StringIO instance interface'''

    global __StringIO

    if not __StringIO:

        try:

            from cStringIO import StringIO

        except ImportError:

            from StringIO import StringIO

        __StringIO = StringIO

    return buf is not None and __StringIO(buf) or __StringIO()

class ArgvDictValue:

    '''A type to allow clients of getArgvDict to specify a conversion function'''

    def __init__(self,value,func):

        self.value = value

        self.func = func

def getArgvDict(**kw):

    ''' Builds a dictionary from its keyword arguments with overrides from sys.argv.

        Attempts to be smart about conversions, but the value can be an instance

        of ArgDictValue to allow specifying a conversion function.

    '''

    def handleValue(v,av,func):

        if func:

            v = func(av)

        else:

            t = type(v)

            if t is StringType:

                v = av

            elif t is FloatType:

                v = float(av)

            elif t is IntType:

                v = int(av)

            elif t is ListType:

                v = list(eval(av))

            elif t is TupleType:

                v = tuple(eval(av))

            else:

                raise TypeError, "Can't convert string '%s' to %s" % (av,str(t))

        return v

    A = sys.argv[1:]

    R = {}

    for k, v in kw.items():

        if isinstance(v,ArgvDictValue):

            v, func = v.value, v.func

        else:

            func = None

        handled = 0

        ke = k+'='

        for a in A:

            if string.find(a,ke)==0:

                av = a[len(ke):]

                A.remove(a)

                R[k] = handleValue(v,av,func)

                handled = 1

                break

        if not handled: R[k] = handleValue(v,v,func)

    return R

def getHyphenater(hDict=None):

    try:

        from reportlab.lib.pyHnj import Hyphen

        if hDict is None: hDict=os.path.join(os.path.dirname(__file__),'hyphen.mashed')

        return Hyphen(hDict)

    except ImportError, errMsg:

        if str(errMsg)!='No module named pyHnj': raise

        return None

def _className(self):

    '''Return a shortened class name'''

    try:

        name = self.__class__.__name__

        i=string.rfind(name,'.')

        if i>=0: return name[i+1:]

        return name

    except AttributeError:

        return str(self)

def open_for_read(name,mode='b'):

    '''attempt to open a file or URL for reading'''

    if hasattr(name,'read'): return name

    import urllib

    try:

        t, o = urllib.splittype(name)

        if not t or t=='file': raise ValueError

        o = urllib.urlopen(name)

        return getStringIO(o.read())

    except:

        if 'r' not in mode: mode = 'r'+mode

        try:

            return open(name,mode)

        except IOError:

            t, v = sys.exc_info()[:2]

            if _isFSD or __loader__ is None: raise

            try:

                #we have a __loader__, perhaps the filename starts with

                #the dirname(reportlab.__file__) or is relative

                name = _startswith_rl(name)

                s = __loader__.get_data(name)

                if 'b' not in mode and os.linesep!='\n': s = s.replace(os.linesep,'\n')

                return getStringIO(s)

            except:

                raise t, v

def open_and_read(name,mode='b'):

    return open_for_read(name,mode).read()

def open_and_readlines(name,mode='t'):

    return open_and_read(name,mode).split('\n')

def rl_isfile(fn,os_path_isfile=os.path.isfile):

    if hasattr(fn,'read'): return True

    if os_path_isfile(fn): return True

    if _isFSD or __loader__ is None: return False

    fn = _startswith_rl(fn)

    return fn in __loader__._files.keys()

def rl_isdir(pn,os_path_isdir=os.path.isdir):

    if os_path_isdir(pn): return True

    if _isFSD or __loader__ is None: return False

    pn = _startswith_rl(pn)

    return len(filter(lambda x,pn=pn: x.startswith(pn),__loader__._files.keys()))>0

def rl_get_module(name,dir):

    if sys.modules.has_key(name):

        om = sys.modules[name]

        del sys.modules[name]

    else:

        om = None

    try:

        f = None

        try:

            f, p, desc= imp.find_module(name,[dir])

            return imp.load_module(name,f,p,desc)

        except:

            if isCompactDistro() and not os.path.isabs(dir):