Thuban/Model/resource.py

# Copyright (c) 2003 by Intevation GmbH
# Authors:
# Jonathan Coles <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""Handle resources loaded from files such as projections"""

__version__ = "$Revision$"
# $Source$
# $Id$


import os
import os.path

import Thuban
from Thuban import _

from Thuban.Lib.fileutil import get_application_dir

from Thuban.Model.xmlreader import XMLReader
from Thuban.Model.xmlwriter import XMLWriter
from Thuban.Model.proj import Projection, ProjFile
from xml.sax import SAXParseException

projdir = \
        os.path.join(Thuban.__path__[0], os.pardir, "Resources", "Projections")


PROJ_EXT = ".proj"

has_gdal_support = lambda: False
try:
    # first try to see if our extension module is there. if it 
    # wasn't even compiled, we obviously don't have gdal support.
    import gdalwarp

    # now try to import the python extension. if this doesn't
    # exist then we can't do anything.
    import gdal

    """Return True if the gdal library is available."""
    has_gdal_support = lambda: True
except ImportError:
    pass

def read_proj_file(filename):
    """Read a .proj file and return a ProjFile object and warnings

    The return value is a tuple with the ProjFile object and a list of
    strings with warnings messages that might have been generated by the
    proj ifle parser.

    Raises IOError if the file cannot be opened, OSError if the file
    cannot be read and SAXParseException if the file is not valid XML.
    """
    handler = ProjFileReader()
    handler.read(filename)
    return handler.GetProjFile(), handler.GetWarnings()

def write_proj_file(pf):
    """Write a single .proj file

    Raises IOError if the file cannot be written.
    """

    saver = ProjFileSaver(pf)
    saver.write(pf.GetFilename())


def get_system_proj_file():
    """Return the standard projections and a list with warnings

    The projections read from the default thuban projection file
    (usually in Resources/Projections/defaults.proj). The return value
    is a tuple with the projections in a ProjFile object and a list of
    strings with warning messages. The warnings list is usually empty
    but may contain messages about ignored errors.

    If the file could could not be opened return an empty projection
    file object set to store data in the default file.
    """
    filename = os.path.join(projdir, "defaults.proj")
    try:
        return read_proj_file(filename)
    except (OSError, IOError, SAXParseException), val:
        msg = _('Could not read "%s": %s') % (filename, str(val))
        return ProjFile(filename), [msg]

def get_user_proj_file():
    """Return the user's projections and a list with warnings

    The projections read from the user's thuban projection file (usually
    in ~/.thuban/user.proj). The return value is a tuple with the
    projections in a ProjFile object and a list of strings with warning
    messages. The warnings list is usually empty but may contain
    messages about ignored errors.

    If the file could could not be opened return an empty projection
    file object set to store data in the default file.
    """
    usrdir  = get_application_dir()
    filename = os.path.join(usrdir, "user.proj")
    try:
        return read_proj_file(filename)
    except (OSError, IOError, SAXParseException), val:
        msg = _('Could not read "%s": %s') % (filename, str(val))
        return ProjFile(filename), [msg]


class ProjFileReader(XMLReader):

    def __init__(self):
        XMLReader.__init__(self)
        self.projfile = ProjFile("")
        self.warnings = []

        XMLReader.AddDispatchers(self,
            {'projection': ("start_projection", "end_projection"),
             'parameter':  ("start_parameter", None)})

    def read(self, file_or_filename):
        XMLReader.read(self, file_or_filename)

        self.projfile.SetFilename(XMLReader.GetFilename(self))

    def start_projection(self, name, qname, attrs):
        self.params = []
        name = self.encode(attrs.get((None, 'name')))
        if name is None:
            name = _("Unknown")
        self.name = name

    def end_projection(self, name, qname):
        try:
            proj = Projection(self.params, self.name)
        except IOError, val:
            self.warnings.append(_('Error in projection "%s": %s')
                                 % (self.name, str(val)))
        else:
            self.projfile.Add(proj)

    def start_parameter(self, name, qname, attrs):
        s = attrs.get((None, 'value'))
        s = str(s) # we can't handle unicode in proj
        self.params.append(s)

    def GetProjFile(self):
        return self.projfile

    def GetWarnings(self):
        """Return the list of warning messages that may have been produced"""
        return self.warnings


class ProjFileSaver(XMLWriter):

    def __init__(self, pf):
        XMLWriter.__init__(self)
        self.__pf = pf

    def write(self, file_or_filename):
        XMLWriter.write(self, file_or_filename)

        self.write_header("projectionlist", "projfile.dtd")
        self.write_projfile(self.__pf)
        self.close()

    def write_projfile(self, pf):

        self.open_element("projectionlist")

        for p in pf.GetProjections():
            self.open_element("projection", {"name": p.GetName()})

            for param in p.GetAllParameters():
                self.write_element("parameter", {"value": param})

            self.close_element("projection")

        self.close_element("projectionlist")


1	# Copyright (c) 2003 by Intevation GmbH
2	# Authors:
3	# Jonathan Coles <[email protected]>
4	#
5	# This program is free software under the GPL (>=v2)
6	# Read the file COPYING coming with Thuban for details.
7
8	"""Handle resources loaded from files such as projections"""
9
10	__version__ = "$Revision$"
11	# $Source$
12	# $Id$
13
14
15	import os
16	import os.path
17
18	import Thuban
19	from Thuban import _
20
21	from Thuban.Lib.fileutil import get_application_dir
22
23	from Thuban.Model.xmlreader import XMLReader
24	from Thuban.Model.xmlwriter import XMLWriter
25	from Thuban.Model.proj import Projection, ProjFile
26	from xml.sax import SAXParseException
27
28	projdir = \
29	os.path.join(Thuban.__path__[0], os.pardir, "Resources", "Projections")
30
31
32	PROJ_EXT = ".proj"
33
34	has_gdal_support = lambda: False
35	try:
36	# first try to see if our extension module is there. if it
37	# wasn't even compiled, we obviously don't have gdal support.
38	import gdalwarp
39
40	# now try to import the python extension. if this doesn't
41	# exist then we can't do anything.
42	import gdal
43
44	"""Return True if the gdal library is available."""
45	has_gdal_support = lambda: True
46	except ImportError:
47	pass
48
49	def read_proj_file(filename):
50	"""Read a .proj file and return a ProjFile object and warnings
51
52	The return value is a tuple with the ProjFile object and a list of
53	strings with warnings messages that might have been generated by the
54	proj ifle parser.
55
56	Raises IOError if the file cannot be opened, OSError if the file
57	cannot be read and SAXParseException if the file is not valid XML.
58	"""
59	handler = ProjFileReader()
60	handler.read(filename)
61	return handler.GetProjFile(), handler.GetWarnings()
62
63	def write_proj_file(pf):
64	"""Write a single .proj file
65
66	Raises IOError if the file cannot be written.
67	"""
68
69	saver = ProjFileSaver(pf)
70	saver.write(pf.GetFilename())
71
72
73	def get_system_proj_file():
74	"""Return the standard projections and a list with warnings
75
76	The projections read from the default thuban projection file
77	(usually in Resources/Projections/defaults.proj). The return value
78	is a tuple with the projections in a ProjFile object and a list of
79	strings with warning messages. The warnings list is usually empty
80	but may contain messages about ignored errors.
81
82	If the file could could not be opened return an empty projection
83	file object set to store data in the default file.
84	"""
85	filename = os.path.join(projdir, "defaults.proj")
86	try:
87	return read_proj_file(filename)
88	except (OSError, IOError, SAXParseException), val:
89	msg = _('Could not read "%s": %s') % (filename, str(val))
90	return ProjFile(filename), [msg]
91
92	def get_user_proj_file():
93	"""Return the user's projections and a list with warnings
94
95	The projections read from the user's thuban projection file (usually
96	in ~/.thuban/user.proj). The return value is a tuple with the
97	projections in a ProjFile object and a list of strings with warning
98	messages. The warnings list is usually empty but may contain
99	messages about ignored errors.
100
101	If the file could could not be opened return an empty projection
102	file object set to store data in the default file.
103	"""
104	usrdir = get_application_dir()
105	filename = os.path.join(usrdir, "user.proj")
106	try:
107	return read_proj_file(filename)
108	except (OSError, IOError, SAXParseException), val:
109	msg = _('Could not read "%s": %s') % (filename, str(val))
110	return ProjFile(filename), [msg]
111
112
113	class ProjFileReader(XMLReader):
114
115	def __init__(self):
116	XMLReader.__init__(self)
117	self.projfile = ProjFile("")
118	self.warnings = []
119
120	XMLReader.AddDispatchers(self,
121	{'projection': ("start_projection", "end_projection"),
122	'parameter': ("start_parameter", None)})
123
124	def read(self, file_or_filename):
125	XMLReader.read(self, file_or_filename)
126
127	self.projfile.SetFilename(XMLReader.GetFilename(self))
128
129	def start_projection(self, name, qname, attrs):
130	self.params = []
131	name = self.encode(attrs.get((None, 'name')))
132	if name is None:
133	name = _("Unknown")
134	self.name = name
135
136	def end_projection(self, name, qname):
137	try:
138	proj = Projection(self.params, self.name)
139	except IOError, val:
140	self.warnings.append(_('Error in projection "%s": %s')
141	% (self.name, str(val)))
142	else:
143	self.projfile.Add(proj)
144
145	def start_parameter(self, name, qname, attrs):
146	s = attrs.get((None, 'value'))
147	s = str(s) # we can't handle unicode in proj
148	self.params.append(s)
149
150	def GetProjFile(self):
151	return self.projfile
152
153	def GetWarnings(self):
154	"""Return the list of warning messages that may have been produced"""
155	return self.warnings
156
157
158	class ProjFileSaver(XMLWriter):
159
160	def __init__(self, pf):
161	XMLWriter.__init__(self)
162	self.__pf = pf
163
164	def write(self, file_or_filename):
165	XMLWriter.write(self, file_or_filename)
166
167	self.write_header("projectionlist", "projfile.dtd")
168	self.write_projfile(self.__pf)
169	self.close()
170
171	def write_projfile(self, pf):
172
173	self.open_element("projectionlist")
174
175	for p in pf.GetProjections():
176	self.open_element("projection", {"name": p.GetName()})
177
178	for param in p.GetAllParameters():
179	self.write_element("parameter", {"value": param})
180
181	self.close_element("projection")
182
183	self.close_element("projectionlist")
184
185
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision