Extensions/ogr/ogrstart.py

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

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

# Needed wx-toolkit classes
from wxPython.wx import wxFileDialog, wxOPEN, wxMULTIPLE, wxID_OK

# We need os.path
import os

# use _() already now for all strings that may later be translated
from Thuban import _

from Thuban.Model.layer import Layer

# Import ogr related classes
from Extensions.ogr import ogrshapes, ogrdialog
from Extensions.ogr.ogrdialog import ChooseOGRDBTableDialog

from Thuban.UI.menu import Menu
from Thuban.UI.mainwindow import _has_dbconnections, _has_gdal_support

def open_with_ogr(context):
    '''Open a file supported by ogr.
    '''
    canvas = context.mainwindow.canvas
    map = canvas.Map()

    # Get the file to be opened
    dlg = wxFileDialog(canvas, _("Select a data file"),
                           context.application.Path("data"), "",
                           _("Shapefiles (*.shp)") + "|*.shp|" +
                           _("GML files (*.gml)") + "|*.gml|" +
                           _("MapInfo files (*.tab)") + "|*.tab|" +
                           _("DGN files (*.dgn)") + "|*.dgn|" +
                           _("CSV files (*.csv)") + "|*.csv|" +
                           _("All Files (*.*)") + "|*.*|",
                           wxOPEN | wxMULTIPLE)

    if dlg.ShowModal() == wxID_OK:
        filenames = dlg.GetPaths()
        for filename in filenames:
            title = os.path.splitext(os.path.basename(filename))[0]
            has_layers = map.HasLayers()
            layerDlg = ogrdialog.ChooseLayer(canvas, filename)
            if layerDlg.ShowModal() == wxID_OK:
                layername = layerDlg.GetLayer()
                try:
                    session = context.application.Session()
                    store = OpenFileShapestore(session, filename, layername)
                    session.AddShapeStore(store)
                except:
                    # the layer couldn't be opened
                    context.mainwindow.RunMessageBox(("Add Layer"),
                                ("Can't open the file '%s'.")%filename)
                else:
                    if store is not None:
                        layer = Layer(title, store)
                        map.AddLayer(layer)
                        if not has_layers:
                            # if we're adding a layer to an empty map, fit the
                            # new map to the window
                            canvas.FitMapToWindow()
                    context.application.SetPath("data",filename)
        dlg.Destroy()

def select_file_format(context):
    ''' Display all available supported formats.
    '''

    canvas = context.mainwindow.canvas
    file = None
    map = canvas.Map()

    session = context.application.Session()

    dlg = ogrdialog.ChooseFileFormat(canvas, session)

    if dlg.ShowModal() == wxID_OK:
        pass
    dlg.Destroy()

def open_db(context):
    ''' Open a table in a database as a layer.
    '''

    canvas = context.mainwindow.canvas
    map = canvas.Map()

    session = context.application.Session()
    dlg = ChooseOGRDBTableDialog(canvas, session)

    if dlg.ShowModal() == wxID_OK:
        dbconn, connString, dbtable, id_column = dlg.GetTable()
        try:
            store = OpenDBShapestore(session, dbconn, dbtable, id_column,
                                            None)
            session.AddShapeStore(store)

            layer = Layer(dbtable, store)

            has_layers = map.HasLayers()
            map.AddLayer(layer)
            if not has_layers:
                canvas.FitMapToWindow()
        except:
            # Some error occured while initializing the layer
            context.mainwindow.RunMessageBox(_("Add Layer from database"),
                               _("Can't open the database table '%s'")
                               % dbtable)
    dlg.Destroy()

def open_OGRConnection(context):
    """Open a datasource with an OGRConnection string."""
    canvas = context.mainwindow.canvas
    map = canvas.Map()

    session = context.application.Session()
    dlg = ogrdialog.OGRConnectionDialog(canvas, session)

    if dlg.ShowModal() == wxID_OK:
        dsname = dlg.GetDatasourceName()

        layerDlg = ogrdialog.ChooseLayer(canvas, dsname)
        if layerDlg.ShowModal() == wxID_OK:
            layername = layerDlg.GetLayer()
            try:
                store = ogrshapes.OGRShapeStore(session, dsname, layername)
                session.AddShapeStore(store)
            except:
                # the layer couldn't be opened
                context.mainwindow.RunMessageBox(("Add Layer"),
                            ("Can't open the file '%s'.") % dsname)
            else:
                layer = Layer(dsname, store)
                has_layers = map.HasLayers()
                map.AddLayer(layer)
                if not has_layers:
                    # if we're adding a layer to an empty map, fit the
                    # new map to the window
                    canvas.FitMapToWindow()
    dlg.Destroy()

def OpenFileShapestore(session, filename, layername):
    """Open a datasource and add the required layer.
    """
    try:
        store = ogrshapes.OGRShapeStore(session, filename, layername)
        return store
    except:
        # Some error occured while initializing the layer
        context.mainwindow.RunMessageBox(_("Open datasource"),
                           _("Can't open the datasource '%s'")
                           % filename)
    else:
        return null

def OpenDBShapestore(session, dbconn, layername, id_column, geo_column):
    """Open a datasource and add the required layer.

    dbconn     - shold be a DBConnection
    layername  - the name of the table which should opened as layer
    id_column  - the column name which should be used as ID column
    geo_column - always None for ogr
    """
    try:
        filename = "PG: dbname=%s" %dbconn.dbname
        if dbconn.host is not "":
            filename = filename + " host=%s" % dbconn.host
        if dbconn.user is not "":
            filename = filename + " user=%s" % dbconn.user
        if dbconn.password is not "":
            filename = filename + " password=%s" % dbconn.password
        if dbconn.port is not "":
            filename = filename + " port=%s" % dbconn.port
        store = ogrshapes.OGRShapeStore(session, filename, layername,
                                        id_column = id_column)
        return store
    except:
        # Some error occured while initializing the layer
        context.mainwindow.RunMessageBox(_("Open datasource"),
                           _("Can't open the datasource '%s'")
                           % filename)

# Thuban has named commands which can be registered in the central
# instance registry.
from Thuban.UI.command import registry, Command

# The instance of the main menu of the Thuban application
# See Thuban/UI/menu.py for the API of the Menu class
from Thuban.UI.mainwindow import main_menu


# find the map menu (create a new if not found)
map_menu = main_menu.FindOrInsertMenu('map', _('Map'))
ogr_menu = Menu("ogr", _("Open layer via OGR"),[])

ogrsupport = ogrshapes.has_ogr_support()

# create new commands and register them
registry.Add(Command('open_ogr_files', 'Open an ogr-file', open_with_ogr,
                     sensitive = _has_gdal_support,
                     helptext = 'Open a file supported from ogr'))

#registry.Add(Command('select_file_format', 'Select a file format',
#                     select_file_format, 
#                     helptext = "Select a file format supported from ogr"))

registry.Add(Command('open_db', 'Open a layer from a database',
                     open_db,
                     sensitive = _has_dbconnections,
                     helptext = "Open a layer from a database, e.g. PostGIS"))

registry.Add(Command('open_OGRConnection',
                     ("Open a datasource with an OGRConnection string"),
                     open_OGRConnection,
                     sensitive = _has_gdal_support, helptext = 
                     "Open a datasource with an OGRConnection string"))

# finally bind the new command with an entry in the extensions menu
ogr_menu.InsertItem("open_ogr_files")
#ogr_menu.InsertItem('select_file_format')
ogr_menu.InsertItem('open_db')
ogr_menu.InsertItem('open_OGRConnection')

# Add ogr menu to map menu
map_menu.InsertItem(ogr_menu, after = "rasterlayer_add")
1	nhueffme	2435	# Copyright (c) 2004 by Intevation GmbH
2			# Authors:
3			# Nina Hüffmeyer <[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			__version__ = "$Revision$"
9			# $Source$
10			# $Id$
11
12			# Needed wx-toolkit classes
13	nhueffme	2577	from wxPython.wx import wxFileDialog, wxOPEN, wxMULTIPLE, wxID_OK
14	nhueffme	2435
15			# We need os.path
16			import os
17
18			# use _() already now for all strings that may later be translated
19			from Thuban import _
20
21			from Thuban.Model.layer import Layer
22
23			# Import ogr related classes
24	nhueffme	2493	from Extensions.ogr import ogrshapes, ogrdialog
25	nhueffme	2549	from Extensions.ogr.ogrdialog import ChooseOGRDBTableDialog
26	nhueffme	2435
27	nhueffme	2559	from Thuban.UI.menu import Menu
28	nhueffme	2577	from Thuban.UI.mainwindow import _has_dbconnections, _has_gdal_support
29	nhueffme	2559
30	nhueffme	2435	def open_with_ogr(context):
31	nhueffme	2549	'''Open a file supported by ogr.
32	nhueffme	2493	'''
33			canvas = context.mainwindow.canvas
34			map = canvas.Map()
35	nhueffme	2435
36	nhueffme	2493	# Get the file to be opened
37			dlg = wxFileDialog(canvas, _("Select a data file"),
38	nhueffme	2577	context.application.Path("data"), "",
39			_("Shapefiles (.shp)") + "\|.shp\|" +
40			_("GML files (.gml)") + "\|.gml\|" +
41			_("MapInfo files (.tab)") + "\|.tab\|" +
42			_("DGN files (.dgn)") + "\|.dgn\|" +
43			_("CSV files (.csv)") + "\|.csv\|" +
44			_("All Files (.)") + "\|.\|",
45	nhueffme	2435	wxOPEN \| wxMULTIPLE)
46
47	nhueffme	2493	if dlg.ShowModal() == wxID_OK:
48			filenames = dlg.GetPaths()
49			for filename in filenames:
50			title = os.path.splitext(os.path.basename(filename))[0]
51			has_layers = map.HasLayers()
52	nhueffme	2549	layerDlg = ogrdialog.ChooseLayer(canvas, filename)
53			if layerDlg.ShowModal() == wxID_OK:
54			layername = layerDlg.GetLayer()
55	nhueffme	2577	try:
56			session = context.application.Session()
57			store = OpenFileShapestore(session, filename, layername)
58			session.AddShapeStore(store)
59			except:
60			# the layer couldn't be opened
61			context.mainwindow.RunMessageBox(("Add Layer"),
62	nhueffme	2493	("Can't open the file '%s'.")%filename)
63	nhueffme	2577	else:
64			if store is not None:
65			layer = Layer(title, store)
66			map.AddLayer(layer)
67			if not has_layers:
68			# if we're adding a layer to an empty map, fit the
69			# new map to the window
70			canvas.FitMapToWindow()
71			context.application.SetPath("data",filename)
72	nhueffme	2435	dlg.Destroy()
73
74	nhueffme	2549	def select_file_format(context):
75			''' Display all available supported formats.
76			'''
77	nhueffme	2435
78	nhueffme	2549	canvas = context.mainwindow.canvas
79			file = None
80			map = canvas.Map()
81	nhueffme	2435
82	nhueffme	2549	session = context.application.Session()
83
84			dlg = ogrdialog.ChooseFileFormat(canvas, session)
85
86			if dlg.ShowModal() == wxID_OK:
87	nhueffme	2577	pass
88	nhueffme	2549	dlg.Destroy()
89
90			def open_db(context):
91			''' Open a table in a database as a layer.
92			'''
93
94			canvas = context.mainwindow.canvas
95			map = canvas.Map()
96	nhueffme	2559
97	nhueffme	2577	session = context.application.Session()
98	nhueffme	2549	dlg = ChooseOGRDBTableDialog(canvas, session)
99
100			if dlg.ShowModal() == wxID_OK:
101	nhueffme	2577	dbconn, connString, dbtable, id_column = dlg.GetTable()
102	nhueffme	2549	try:
103	nhueffme	2577	store = OpenDBShapestore(session, dbconn, dbtable, id_column,
104			None)
105	nhueffme	2549	session.AddShapeStore(store)
106
107			layer = Layer(dbtable, store)
108
109			has_layers = map.HasLayers()
110			map.AddLayer(layer)
111			if not has_layers:
112			canvas.FitMapToWindow()
113			except:
114			# Some error occured while initializing the layer
115			context.mainwindow.RunMessageBox(_("Add Layer from database"),
116			_("Can't open the database table '%s'")
117			% dbtable)
118			dlg.Destroy()
119
120	nhueffme	2577	def open_OGRConnection(context):
121			"""Open a datasource with an OGRConnection string."""
122			canvas = context.mainwindow.canvas
123			map = canvas.Map()
124	nhueffme	2549
125	nhueffme	2577	session = context.application.Session()
126			dlg = ogrdialog.OGRConnectionDialog(canvas, session)
127	nhueffme	2549
128	nhueffme	2577	if dlg.ShowModal() == wxID_OK:
129			dsname = dlg.GetDatasourceName()
130
131			layerDlg = ogrdialog.ChooseLayer(canvas, dsname)
132			if layerDlg.ShowModal() == wxID_OK:
133			layername = layerDlg.GetLayer()
134			try:
135			store = ogrshapes.OGRShapeStore(session, dsname, layername)
136			session.AddShapeStore(store)
137			except:
138			# the layer couldn't be opened
139			context.mainwindow.RunMessageBox(("Add Layer"),
140			("Can't open the file '%s'.") % dsname)
141			else:
142			layer = Layer(dsname, store)
143			has_layers = map.HasLayers()
144			map.AddLayer(layer)
145			if not has_layers:
146			# if we're adding a layer to an empty map, fit the
147			# new map to the window
148			canvas.FitMapToWindow()
149			dlg.Destroy()
150
151			def OpenFileShapestore(session, filename, layername):
152			"""Open a datasource and add the required layer.
153			"""
154			try:
155			store = ogrshapes.OGRShapeStore(session, filename, layername)
156			return store
157			except:
158			# Some error occured while initializing the layer
159			context.mainwindow.RunMessageBox(_("Open datasource"),
160			_("Can't open the datasource '%s'")
161			% filename)
162			else:
163			return null
164
165			def OpenDBShapestore(session, dbconn, layername, id_column, geo_column):
166			"""Open a datasource and add the required layer.
167
168			dbconn - shold be a DBConnection
169			layername - the name of the table which should opened as layer
170			id_column - the column name which should be used as ID column
171			geo_column - always None for ogr
172			"""
173			try:
174			filename = "PG: dbname=%s" %dbconn.dbname
175			if dbconn.host is not "":
176			filename = filename + " host=%s" % dbconn.host
177			if dbconn.user is not "":
178			filename = filename + " user=%s" % dbconn.user
179			if dbconn.password is not "":
180			filename = filename + " password=%s" % dbconn.password
181			if dbconn.port is not "":
182			filename = filename + " port=%s" % dbconn.port
183			store = ogrshapes.OGRShapeStore(session, filename, layername,
184			id_column = id_column)
185			return store
186			except:
187			# Some error occured while initializing the layer
188			context.mainwindow.RunMessageBox(_("Open datasource"),
189			_("Can't open the datasource '%s'")
190			% filename)
191
192	nhueffme	2435	# Thuban has named commands which can be registered in the central
193			# instance registry.
194			from Thuban.UI.command import registry, Command
195
196			# The instance of the main menu of the Thuban application
197			# See Thuban/UI/menu.py for the API of the Menu class
198			from Thuban.UI.mainwindow import main_menu
199
200	nhueffme	2559
201	nhueffme	2577	# find the map menu (create a new if not found)
202	nhueffme	2559	map_menu = main_menu.FindOrInsertMenu('map', _('Map'))
203			ogr_menu = Menu("ogr", _("Open layer via OGR"),[])
204
205	nhueffme	2577	ogrsupport = ogrshapes.has_ogr_support()
206	nhueffme	2559
207	nhueffme	2493	# create new commands and register them
208			registry.Add(Command('open_ogr_files', 'Open an ogr-file', open_with_ogr,
209	nhueffme	2577	sensitive = _has_gdal_support,
210	nhueffme	2493	helptext = 'Open a file supported from ogr'))
211	nhueffme	2435
212	nhueffme	2577	#registry.Add(Command('select_file_format', 'Select a file format',
213			# select_file_format,
214			# helptext = "Select a file format supported from ogr"))
215	nhueffme	2435
216	nhueffme	2549	registry.Add(Command('open_db', 'Open a layer from a database',
217			open_db,
218	nhueffme	2577	sensitive = _has_dbconnections,
219	nhueffme	2549	helptext = "Open a layer from a database, e.g. PostGIS"))
220
221	nhueffme	2577	registry.Add(Command('open_OGRConnection',
222			("Open a datasource with an OGRConnection string"),
223			open_OGRConnection,
224			sensitive = _has_gdal_support, helptext =
225			"Open a datasource with an OGRConnection string"))
226
227	nhueffme	2435	# finally bind the new command with an entry in the extensions menu
228	nhueffme	2559	ogr_menu.InsertItem("open_ogr_files")
229	nhueffme	2577	#ogr_menu.InsertItem('select_file_format')
230	nhueffme	2549	ogr_menu.InsertItem('open_db')
231	nhueffme	2577	ogr_menu.InsertItem('open_OGRConnection')
232	nhueffme	2493
233	nhueffme	2559	# Add ogr menu to map menu
234			map_menu.InsertItem(ogr_menu, after = "rasterlayer_add")
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision