Extensions/ogr/ogrdialog.py

# Copyright (c) 2001, 2003, 2004 by Intevation GmbH     vim:encoding=latin-1:
# Authors:
# Martin Müller <[email protected]>
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.


"""Dialogs to manage database connections"""

import sys, traceback

from wxPython.wx import *

try:
    import ogr
except ImportError:
    ogr = None

from Thuban import _
from Thuban.Model.table import FIELDTYPE_INT
from Extensions.ogr import ogrshapes


ID_DBCHOOSE_RETRIEVE = 9201
ID_DBCHOOSE_OK       = 9202
ID_DBCHOOSE_CANCEL   = 9203
ID_LB_DCLICK         = 9204


class ChooseFileFormat(wxDialog):
    """This dialog lists all available drivers.
    """
    def __init__(self, parent, session):
        """Initialize the dialog.
        """
        wxDialog.__init__(self, parent, -1, _("Choose file format"),
                          style = wxDIALOG_MODAL|wxCAPTION)
        self.session = session
        self.tables = []

        #
        # Build the dialog
        #

        # Sizer for the entire dialog
        top = wxFlexGridSizer(2, 1, 0, 0)

        # Sizer for the main part with the list box
        main_sizer = wxBoxSizer(wxHORIZONTAL)
        top.Add(main_sizer, 1, wxEXPAND, 0)

        # The list box with the drivers
        static_box = wxStaticBoxSizer(wxStaticBox(self, -1, "File formats"),
                                   wxHORIZONTAL)
        self.lb_drivers = wxListBox(self, -1)
        static_box.Add(self.lb_drivers, 0, wxEXPAND, 0)
        main_sizer.Add(static_box, 1, wxEXPAND, 0)

        for i in range(ogr.GetDriverCount()):
            self.lb_drivers.Append(ogr.GetDriver(i).GetName())
        if self.lb_drivers.GetCount() > 0:
            self.lb_drivers.SetSelection(0, True)

        # The standard button box at the bottom of the dialog
        buttons = wxFlexGridSizer(1, 2, 0, 0)
        ok_button = wxButton(self, ID_DBCHOOSE_OK, _("OK"))
        EVT_BUTTON(self, ID_DBCHOOSE_OK, self.OnOK)
        buttons.Add(ok_button, 0, wxALL|wxALIGN_RIGHT, 4)
        cancel_button = wxButton(self, ID_DBCHOOSE_CANCEL, _("Cancel"))
        EVT_BUTTON(self, ID_DBCHOOSE_CANCEL, self.OnCancel)
        buttons.Add(cancel_button, 0, wxALL, 4)
        top.Add(buttons, 1, wxALL|wxALIGN_CENTER_HORIZONTAL, 4)

        # Autosizing
        self.SetAutoLayout(1)
        self.SetSizer(top)
        top.Fit(self)
        top.SetSizeHints(self)
        self.Layout()


    def GetTable(self):
        """no functionality
        """
        return None

    def OnLBDClick(self, event):
        """Close dialog.
        """
        if self.lb_tables.GetSelection() >= 0:
            self.EndModal(wxID_OK)
            self.Show(False)

    def OnOK(self, event):
        """Close dialog.
        """
        self.EndModal(wxID_OK)
        self.Show(False)

    def OnCancel(self, event):
        """Close dialog.
        """
        self.EndModal(wxID_CANCEL)
        self.Show(False)


class ChooseLayer(wxDialog):
    """This dialog lists all the layers contained in the given datasource.

    One layer can be chosen, which is then opened.
    """

    def __init__(self, parent, filename):
        """Initialize the dialog.
        """
        wxDialog.__init__(self, parent, -1, _("Choose layer"),
                          style = wxDIALOG_MODAL|wxCAPTION)
        self.tables = []

        #
        # Build the dialog
        #

        # Sizer for the entire dialog
        top = wxFlexGridSizer(2, 1, 0, 0)

        # Sizer for the main part with the list boxes
        main_sizer = wxBoxSizer(wxHORIZONTAL)
        top.Add(main_sizer, 1, wxEXPAND, 0)

        # The list box with the drivers
        static_box = wxStaticBoxSizer(wxStaticBox(self, -1, _("Layers")),
                                   wxHORIZONTAL)
        self.lb_drivers = wxListBox(self, -1)
        static_box.Add(self.lb_drivers, 0, wxEXPAND, 0)
        main_sizer.Add(static_box, 1, wxEXPAND, 0)

        datasource = ogr.Open(filename)
        self.layer = []
        for i in range(datasource.GetLayerCount()):
            self.layer.append(datasource.GetLayer(i))
            self.lb_drivers.Append(datasource.GetLayer(i).GetName())
        if self.lb_drivers.GetCount() > 0:
            self.lb_drivers.SetSelection(0, True)

        # The standard button box at the bottom of the dialog
        buttons = wxFlexGridSizer(1, 2, 0, 0)
        ok_button = wxButton(self, ID_DBCHOOSE_OK, _("OK"))
        EVT_BUTTON(self, ID_DBCHOOSE_OK, self.OnOK)
        buttons.Add(ok_button, 0, wxALL|wxALIGN_RIGHT, 4)
        cancel_button = wxButton(self, ID_DBCHOOSE_CANCEL, _("Cancel"))
        EVT_BUTTON(self, ID_DBCHOOSE_CANCEL, self.OnCancel)
        buttons.Add(cancel_button, 0, wxALL, 4)
        top.Add(buttons, 1, wxALL|wxALIGN_CENTER_HORIZONTAL, 4)

        # Autosizing
        self.SetAutoLayout(1)
        self.SetSizer(top)
        top.Fit(self)
        top.SetSizeHints(self)
        self.Layout()

    def end_dialog(self, result):
        """If the dialog is closed with OK, set chosen layer as layer 
        to be opened.
        """
        self.result = result
        if result is not None:
            self.EndModal(wxID_OK)
        else:
            self.EndModal(wxID_CANCEL)
        self.Show(False)

    def OnOK(self, event):
        """Dialog closed with OK button.
        """
        self.end_dialog(self.lb_drivers.GetSelection())

    def OnCancel(self, event):
        """Dialog closed with Cancel.
        """
        self.end_dialog(None)

    def GetLayer(self):
        """Return the selected layer."""
        return self.layer[self.lb_drivers.GetSelection()].GetName()


class ChooseOGRDBTableDialog(wxDialog):
    """This dialog opens a datasource from an existing database connection.

    A list of all available database connections is offered. If one connection
    is selected and the button "Retrieve" is clicked, all layers are listed.
    One of these layers can be chosen to be opened.
    An ID column can be chosen, too."""

    def __init__(self, parent, session):
        """Initialize the dialog.
        """
        wxDialog.__init__(self, parent, -1, _("Choose layer from database"),
                          style = wxDIALOG_MODAL|wxCAPTION)
        self.session = session
        self.dbconns = self.session.DBConnections()
        self.tables = []

        #
        # Build the dialog
        #

        # Sizer for the entire dialog
        top = wxFlexGridSizer(2, 1, 0, 0)

        # Sizer for the main part with the list boxes
        main_sizer = wxBoxSizer(wxHORIZONTAL)
        top.Add(main_sizer, 1, wxEXPAND, 0)

        # The list box with the connections
        static_box = wxStaticBoxSizer(wxStaticBox(self, -1, _("Databases")),
                                   wxHORIZONTAL)
        self.lb_connections = wxListBox(self, -1)
        static_box.Add(self.lb_connections, 0, wxEXPAND, 0)
        main_sizer.Add(static_box, 1, wxEXPAND, 0)

        for i in range(len(self.dbconns)):
            self.lb_connections.Append(self.dbconns[i].BriefDescription())
        if self.lb_connections.GetCount() > 0:
            self.lb_connections.SetSelection(0, True)

        # The button box between the connections list box and the table
        # list box
        buttons = wxFlexGridSizer(3, 1, 0, 0)
        buttons.Add(20, 80, 0, wxEXPAND, 0)
        retrieve_button = wxButton(self, ID_DBCHOOSE_RETRIEVE, _("Retrieve"))
        EVT_BUTTON(self, ID_DBCHOOSE_RETRIEVE, self.OnRetrieve)
        buttons.Add(retrieve_button, 0, wxALL
                    |wxALIGN_CENTER_HORIZONTAL|wxALIGN_CENTER_VERTICAL, 4)
        buttons.Add(20, 80, 0, wxEXPAND, 0)
        main_sizer.Add(buttons, 0, wxEXPAND, 0)

        # The list box with the tables
        static_box = wxStaticBoxSizer(wxStaticBox(self, -1, _("Tables")),
                                   wxHORIZONTAL)
        self.lb_tables = wxListBox(self, ID_LB_DCLICK)
        EVT_LISTBOX(self, ID_LB_DCLICK, self.OnTableSelect)
        EVT_LISTBOX_DCLICK(self, ID_LB_DCLICK, self.OnLBDClick)
        static_box.Add(self.lb_tables, 0, wxEXPAND, 0)
        main_sizer.Add(static_box, 1, wxEXPAND, 0)

        # id column and geometry column selection
        box = wxBoxSizer(wxVERTICAL)
        box.Add(wxStaticText(self, -1, _("ID Column")), 0,
                wxALL|wxALIGN_CENTER_VERTICAL, 4)
        self.text_id_column = wxComboBox(self, -1, "")
        box.Add(self.text_id_column, 0,
                wxALL|wxALIGN_CENTER_VERTICAL|wxEXPAND, 4)
        main_sizer.Add(box, 1, wxEXPAND, 0)

        # The standard button box at the bottom of the dialog
        buttons = wxFlexGridSizer(1, 2, 0, 0)
        ok_button = wxButton(self, ID_DBCHOOSE_OK, _("OK"))
        EVT_BUTTON(self, ID_DBCHOOSE_OK, self.OnOK)
        buttons.Add(ok_button, 0, wxALL|wxALIGN_RIGHT, 4)
        cancel_button = wxButton(self, ID_DBCHOOSE_CANCEL, _("Cancel"))
        EVT_BUTTON(self, ID_DBCHOOSE_CANCEL, self.OnCancel)
        buttons.Add(cancel_button, 0, wxALL, 4)
        top.Add(buttons, 1, wxALL|wxALIGN_CENTER_HORIZONTAL, 4)

        # Autosizing
        self.SetAutoLayout(1)
        self.SetSizer(top)
        top.Fit(self)
        top.SetSizeHints(self)
        self.Layout()


    def GetTable(self):
        """Return the chosen DB connection, the table to be opened, 
        the connection string for ogr and the ID column.
        """
        i = self.lb_tables.GetSelection()
        if i >= 0:
            return (self.selected_conn, self.connString, self.tables[i],
                    self.text_id_column.GetValue())
        return None

    def OnRetrieve(self, event):
        """Provide a list of all available layers in the selected datasource.
        """
        i = self.lb_connections.GetSelection()
        if i >= 0:
            self.selected_conn = self.dbconns[i]
            self.connString = "PG: dbname=%s" %self.selected_conn.dbname
            if self.selected_conn.host is not "":
                self.connString = (self.connString + " host=%s"
                                    %self.selected_conn.host)
            if self.selected_conn.user is not "":
                self.connString = (self.connString + " user=%s"
                                    %self.selected_conn.user)
            if self.selected_conn.password is not "":
                self.connString = (self.connString + " password=%s"
                                    %self.selected_conn.password)
            if self.selected_conn.port is not "":
                self.connString = (self.connString + " port= %s"
                                    %self.selected_conn.port)
            ds = ogr.Open(self.connString)
            if ds:
                for i in range(ds.GetLayerCount()):
                    self.tables.append(ds.GetLayer(i).GetName())
                self.lb_tables.Set(self.tables)

    def OnTableSelect(self, event):
        """If a table is selected, list all possible ID columns.
        """
        i = self.lb_tables.GetSelection()
        self.text_id_column.Clear()
        if i >= 0:
            for name, typ in self.selected_conn.table_columns(self.tables[i]):
                if typ == FIELDTYPE_INT:
                    self.text_id_column.Append(name)

    def OnLBDClick(self, event):
        """Close dialog.
        """
        if self.lb_tables.GetSelection() >= 0:
            self.EndModal(wxID_OK)
            self.Show(False)

    def OnOK(self, event):
        """Dialog closed with OK button.
        """
        self.EndModal(wxID_OK)
        self.Show(False)

    def OnCancel(self, event):
        """Dialog closed with Cancel.
        """
        self.EndModal(wxID_CANCEL)
        self.Show(False)


class OGRConnectionDialog(wxDialog):
    """A string can be enteres, which is directly passed to ogr to open a
    datasource.
    """
    def __init__(self, parent, session):
        """Initialize the dialog.
        """
        wxDialog.__init__(self, parent, -1, "Enter string for OGRConnection",
                          style = wxDIALOG_MODAL|wxCAPTION)
        self.session = session

        # Sizer for the entire dialog
        top = wxBoxSizer(wxVERTICAL)

        # The list box with the drivers
        box = wxBoxSizer(wxHORIZONTAL)#wxBox(self, -1, _("OGRConnection")),
                            #       wxHORIZONTAL)
        box.Add(wxStaticText(self, -1, _("URL:")), 0,
                wxALL|wxALIGN_CENTER_VERTICAL, 4)
        self.text_string = wxTextCtrl(self, -1, "")
        box.Add(self.text_string, 0, wxEXPAND, 0)
        top.Add(box, 0, wxEXPAND)

        # The standard button box at the bottom of the dialog
        buttons = wxFlexGridSizer(1, 2, 0, 0)
        ok_button = wxButton(self, ID_DBCHOOSE_OK, _("OK"))
        EVT_BUTTON(self, ID_DBCHOOSE_OK, self.OnOK)
        buttons.Add(ok_button, 0, wxALL|wxALIGN_RIGHT, 4)
        cancel_button = wxButton(self, ID_DBCHOOSE_CANCEL, _("Cancel"))
        EVT_BUTTON(self, ID_DBCHOOSE_CANCEL, self.OnCancel)
        buttons.Add(cancel_button, 0, wxALL, 4)
        top.Add(buttons, 1, wxALL|wxALIGN_CENTER_HORIZONTAL, 4)

        # Autosizing
        self.SetAutoLayout(1)
        self.SetSizer(top)
        top.Fit(self)
        top.SetSizeHints(self)
        self.Layout()

    def RunDialog(self):
        """Run dialog
        """
        self.ShowModal()
        self.Destroy()
        return self.result

    def end_dialog(self, result):
        """Close dialog
        """
        self.result = result
        if result is not None:
            self.EndModal(wxID_OK)
        else:
            self.EndModal(wxID_CANCEL)
        self.Show(False)

    def OnOK(self, event):
        """Dialog closed with OK
        """
        result = {}
        result["string"] = getattr(self, "text_string").GetValue()
        self.end_dialog(result)

    def OnCancel(self, event):
        """Dialog closed with Cancel.
        """
        self.end_dialog(None)

    def GetDatasourceName(self):
        """Return the string to be used for opening the database
        """
        return self.result["string"]

1	bernhard	2713	# Copyright (c) 2001, 2003, 2004 by Intevation GmbH vim:encoding=latin-1:
2	nhueffme	2554	# Authors:
3	bernhard	2713	# Martin Müller <[email protected]>
4	nhueffme	2554	# Bernhard Herzog <[email protected]>
5			#
6			# This program is free software under the GPL (>=v2)
7			# Read the file COPYING coming with Thuban for details.
8
9
10			"""Dialogs to manage database connections"""
11
12			import sys, traceback
13
14			from wxPython.wx import *
15
16			try:
17			import ogr
18			except ImportError:
19	nhueffme	2577	ogr = None
20	nhueffme	2554
21			from Thuban import _
22			from Thuban.Model.table import FIELDTYPE_INT
23			from Extensions.ogr import ogrshapes
24
25
26			ID_DBCHOOSE_RETRIEVE = 9201
27			ID_DBCHOOSE_OK = 9202
28			ID_DBCHOOSE_CANCEL = 9203
29			ID_LB_DCLICK = 9204
30
31
32			class ChooseFileFormat(wxDialog):
33	nhueffme	2577	"""This dialog lists all available drivers.
34			"""
35	nhueffme	2554	def __init__(self, parent, session):
36	nhueffme	2577	"""Initialize the dialog.
37			"""
38	nhueffme	2554	wxDialog.__init__(self, parent, -1, _("Choose file format"),
39			style = wxDIALOG_MODAL\|wxCAPTION)
40			self.session = session
41			self.tables = []
42
43			#
44			# Build the dialog
45			#
46
47			# Sizer for the entire dialog
48			top = wxFlexGridSizer(2, 1, 0, 0)
49
50	nhueffme	2577	# Sizer for the main part with the list box
51	nhueffme	2554	main_sizer = wxBoxSizer(wxHORIZONTAL)
52			top.Add(main_sizer, 1, wxEXPAND, 0)
53
54			# The list box with the drivers
55	nhueffme	2577	static_box = wxStaticBoxSizer(wxStaticBox(self, -1, "File formats"),
56	nhueffme	2554	wxHORIZONTAL)
57			self.lb_drivers = wxListBox(self, -1)
58			static_box.Add(self.lb_drivers, 0, wxEXPAND, 0)
59			main_sizer.Add(static_box, 1, wxEXPAND, 0)
60
61			for i in range(ogr.GetDriverCount()):
62			self.lb_drivers.Append(ogr.GetDriver(i).GetName())
63			if self.lb_drivers.GetCount() > 0:
64			self.lb_drivers.SetSelection(0, True)
65
66			# The standard button box at the bottom of the dialog
67			buttons = wxFlexGridSizer(1, 2, 0, 0)
68			ok_button = wxButton(self, ID_DBCHOOSE_OK, _("OK"))
69			EVT_BUTTON(self, ID_DBCHOOSE_OK, self.OnOK)
70			buttons.Add(ok_button, 0, wxALL\|wxALIGN_RIGHT, 4)
71			cancel_button = wxButton(self, ID_DBCHOOSE_CANCEL, _("Cancel"))
72			EVT_BUTTON(self, ID_DBCHOOSE_CANCEL, self.OnCancel)
73			buttons.Add(cancel_button, 0, wxALL, 4)
74			top.Add(buttons, 1, wxALL\|wxALIGN_CENTER_HORIZONTAL, 4)
75
76			# Autosizing
77			self.SetAutoLayout(1)
78			self.SetSizer(top)
79			top.Fit(self)
80			top.SetSizeHints(self)
81			self.Layout()
82
83
84			def GetTable(self):
85	nhueffme	2577	"""no functionality
86			"""
87	nhueffme	2554	return None
88
89			def OnLBDClick(self, event):
90	nhueffme	2577	"""Close dialog.
91			"""
92	nhueffme	2554	if self.lb_tables.GetSelection() >= 0:
93			self.EndModal(wxID_OK)
94			self.Show(False)
95
96			def OnOK(self, event):
97	nhueffme	2577	"""Close dialog.
98			"""
99	nhueffme	2554	self.EndModal(wxID_OK)
100			self.Show(False)
101
102			def OnCancel(self, event):
103	nhueffme	2577	"""Close dialog.
104			"""
105	nhueffme	2554	self.EndModal(wxID_CANCEL)
106			self.Show(False)
107
108
109			class ChooseLayer(wxDialog):
110	nhueffme	2577	"""This dialog lists all the layers contained in the given datasource.
111	nhueffme	2554
112	nhueffme	2577	One layer can be chosen, which is then opened.
113			"""
114
115	nhueffme	2554	def __init__(self, parent, filename):
116	nhueffme	2577	"""Initialize the dialog.
117			"""
118	nhueffme	2554	wxDialog.__init__(self, parent, -1, _("Choose layer"),
119			style = wxDIALOG_MODAL\|wxCAPTION)
120			self.tables = []
121
122			#
123			# Build the dialog
124			#
125
126			# Sizer for the entire dialog
127			top = wxFlexGridSizer(2, 1, 0, 0)
128
129			# Sizer for the main part with the list boxes
130			main_sizer = wxBoxSizer(wxHORIZONTAL)
131			top.Add(main_sizer, 1, wxEXPAND, 0)
132
133			# The list box with the drivers
134			static_box = wxStaticBoxSizer(wxStaticBox(self, -1, _("Layers")),
135			wxHORIZONTAL)
136			self.lb_drivers = wxListBox(self, -1)
137			static_box.Add(self.lb_drivers, 0, wxEXPAND, 0)
138			main_sizer.Add(static_box, 1, wxEXPAND, 0)
139
140			datasource = ogr.Open(filename)
141			self.layer = []
142	nhueffme	2559	for i in range(datasource.GetLayerCount()):
143	nhueffme	2554	self.layer.append(datasource.GetLayer(i))
144			self.lb_drivers.Append(datasource.GetLayer(i).GetName())
145			if self.lb_drivers.GetCount() > 0:
146			self.lb_drivers.SetSelection(0, True)
147
148			# The standard button box at the bottom of the dialog
149			buttons = wxFlexGridSizer(1, 2, 0, 0)
150			ok_button = wxButton(self, ID_DBCHOOSE_OK, _("OK"))
151			EVT_BUTTON(self, ID_DBCHOOSE_OK, self.OnOK)
152			buttons.Add(ok_button, 0, wxALL\|wxALIGN_RIGHT, 4)
153			cancel_button = wxButton(self, ID_DBCHOOSE_CANCEL, _("Cancel"))
154			EVT_BUTTON(self, ID_DBCHOOSE_CANCEL, self.OnCancel)
155			buttons.Add(cancel_button, 0, wxALL, 4)
156			top.Add(buttons, 1, wxALL\|wxALIGN_CENTER_HORIZONTAL, 4)
157
158			# Autosizing
159			self.SetAutoLayout(1)
160			self.SetSizer(top)
161			top.Fit(self)
162			top.SetSizeHints(self)
163			self.Layout()
164
165			def end_dialog(self, result):
166	nhueffme	2577	"""If the dialog is closed with OK, set chosen layer as layer
167			to be opened.
168			"""
169	nhueffme	2554	self.result = result
170			if result is not None:
171			self.EndModal(wxID_OK)
172			else:
173			self.EndModal(wxID_CANCEL)
174			self.Show(False)
175
176			def OnOK(self, event):
177	nhueffme	2577	"""Dialog closed with OK button.
178			"""
179	nhueffme	2554	self.end_dialog(self.lb_drivers.GetSelection())
180
181			def OnCancel(self, event):
182	nhueffme	2577	"""Dialog closed with Cancel.
183			"""
184	nhueffme	2554	self.end_dialog(None)
185
186			def GetLayer(self):
187	nhueffme	2577	"""Return the selected layer."""
188	nhueffme	2554	return self.layer[self.lb_drivers.GetSelection()].GetName()
189
190
191			class ChooseOGRDBTableDialog(wxDialog):
192	nhueffme	2577	"""This dialog opens a datasource from an existing database connection.
193	nhueffme	2554
194	nhueffme	2577	A list of all available database connections is offered. If one connection
195			is selected and the button "Retrieve" is clicked, all layers are listed.
196			One of these layers can be chosen to be opened.
197			An ID column can be chosen, too."""
198
199	nhueffme	2554	def __init__(self, parent, session):
200	nhueffme	2577	"""Initialize the dialog.
201			"""
202	nhueffme	2554	wxDialog.__init__(self, parent, -1, _("Choose layer from database"),
203			style = wxDIALOG_MODAL\|wxCAPTION)
204			self.session = session
205			self.dbconns = self.session.DBConnections()
206			self.tables = []
207
208			#
209			# Build the dialog
210			#
211
212			# Sizer for the entire dialog
213			top = wxFlexGridSizer(2, 1, 0, 0)
214
215			# Sizer for the main part with the list boxes
216			main_sizer = wxBoxSizer(wxHORIZONTAL)
217			top.Add(main_sizer, 1, wxEXPAND, 0)
218
219			# The list box with the connections
220			static_box = wxStaticBoxSizer(wxStaticBox(self, -1, _("Databases")),
221			wxHORIZONTAL)
222			self.lb_connections = wxListBox(self, -1)
223			static_box.Add(self.lb_connections, 0, wxEXPAND, 0)
224			main_sizer.Add(static_box, 1, wxEXPAND, 0)
225
226			for i in range(len(self.dbconns)):
227			self.lb_connections.Append(self.dbconns[i].BriefDescription())
228			if self.lb_connections.GetCount() > 0:
229			self.lb_connections.SetSelection(0, True)
230
231			# The button box between the connections list box and the table
232			# list box
233			buttons = wxFlexGridSizer(3, 1, 0, 0)
234			buttons.Add(20, 80, 0, wxEXPAND, 0)
235			retrieve_button = wxButton(self, ID_DBCHOOSE_RETRIEVE, _("Retrieve"))
236			EVT_BUTTON(self, ID_DBCHOOSE_RETRIEVE, self.OnRetrieve)
237			buttons.Add(retrieve_button, 0, wxALL
238			\|wxALIGN_CENTER_HORIZONTAL\|wxALIGN_CENTER_VERTICAL, 4)
239			buttons.Add(20, 80, 0, wxEXPAND, 0)
240			main_sizer.Add(buttons, 0, wxEXPAND, 0)
241
242			# The list box with the tables
243			static_box = wxStaticBoxSizer(wxStaticBox(self, -1, _("Tables")),
244			wxHORIZONTAL)
245			self.lb_tables = wxListBox(self, ID_LB_DCLICK)
246			EVT_LISTBOX(self, ID_LB_DCLICK, self.OnTableSelect)
247			EVT_LISTBOX_DCLICK(self, ID_LB_DCLICK, self.OnLBDClick)
248			static_box.Add(self.lb_tables, 0, wxEXPAND, 0)
249			main_sizer.Add(static_box, 1, wxEXPAND, 0)
250
251	nhueffme	2577	# id column and geometry column selection
252			box = wxBoxSizer(wxVERTICAL)
253			box.Add(wxStaticText(self, -1, _("ID Column")), 0,
254			wxALL\|wxALIGN_CENTER_VERTICAL, 4)
255			self.text_id_column = wxComboBox(self, -1, "")
256			box.Add(self.text_id_column, 0,
257			wxALL\|wxALIGN_CENTER_VERTICAL\|wxEXPAND, 4)
258			main_sizer.Add(box, 1, wxEXPAND, 0)
259
260	nhueffme	2554	# The standard button box at the bottom of the dialog
261			buttons = wxFlexGridSizer(1, 2, 0, 0)
262			ok_button = wxButton(self, ID_DBCHOOSE_OK, _("OK"))
263			EVT_BUTTON(self, ID_DBCHOOSE_OK, self.OnOK)
264			buttons.Add(ok_button, 0, wxALL\|wxALIGN_RIGHT, 4)
265			cancel_button = wxButton(self, ID_DBCHOOSE_CANCEL, _("Cancel"))
266			EVT_BUTTON(self, ID_DBCHOOSE_CANCEL, self.OnCancel)
267			buttons.Add(cancel_button, 0, wxALL, 4)
268			top.Add(buttons, 1, wxALL\|wxALIGN_CENTER_HORIZONTAL, 4)
269
270			# Autosizing
271			self.SetAutoLayout(1)
272			self.SetSizer(top)
273			top.Fit(self)
274			top.SetSizeHints(self)
275			self.Layout()
276
277
278			def GetTable(self):
279	nhueffme	2577	"""Return the chosen DB connection, the table to be opened,
280			the connection string for ogr and the ID column.
281			"""
282	nhueffme	2554	i = self.lb_tables.GetSelection()
283			if i >= 0:
284	nhueffme	2577	return (self.selected_conn, self.connString, self.tables[i],
285			self.text_id_column.GetValue())
286	nhueffme	2554	return None
287
288			def OnRetrieve(self, event):
289	nhueffme	2577	"""Provide a list of all available layers in the selected datasource.
290			"""
291	nhueffme	2554	i = self.lb_connections.GetSelection()
292			if i >= 0:
293			self.selected_conn = self.dbconns[i]
294	nhueffme	2577	self.connString = "PG: dbname=%s" %self.selected_conn.dbname
295			if self.selected_conn.host is not "":
296			self.connString = (self.connString + " host=%s"
297			%self.selected_conn.host)
298			if self.selected_conn.user is not "":
299			self.connString = (self.connString + " user=%s"
300			%self.selected_conn.user)
301			if self.selected_conn.password is not "":
302			self.connString = (self.connString + " password=%s"
303			%self.selected_conn.password)
304			if self.selected_conn.port is not "":
305			self.connString = (self.connString + " port= %s"
306			%self.selected_conn.port)
307			ds = ogr.Open(self.connString)
308	nhueffme	2559	if ds:
309			for i in range(ds.GetLayerCount()):
310			self.tables.append(ds.GetLayer(i).GetName())
311			self.lb_tables.Set(self.tables)
312	nhueffme	2554
313			def OnTableSelect(self, event):
314	nhueffme	2577	"""If a table is selected, list all possible ID columns.
315			"""
316	nhueffme	2554	i = self.lb_tables.GetSelection()
317	nhueffme	2577	self.text_id_column.Clear()
318			if i >= 0:
319			for name, typ in self.selected_conn.table_columns(self.tables[i]):
320			if typ == FIELDTYPE_INT:
321			self.text_id_column.Append(name)
322	nhueffme	2554
323			def OnLBDClick(self, event):
324	nhueffme	2577	"""Close dialog.
325			"""
326	nhueffme	2554	if self.lb_tables.GetSelection() >= 0:
327			self.EndModal(wxID_OK)
328			self.Show(False)
329
330			def OnOK(self, event):
331	nhueffme	2577	"""Dialog closed with OK button.
332			"""
333	nhueffme	2554	self.EndModal(wxID_OK)
334			self.Show(False)
335
336			def OnCancel(self, event):
337	nhueffme	2577	"""Dialog closed with Cancel.
338			"""
339	nhueffme	2554	self.EndModal(wxID_CANCEL)
340			self.Show(False)
341
342
343	nhueffme	2577	class OGRConnectionDialog(wxDialog):
344			"""A string can be enteres, which is directly passed to ogr to open a
345			datasource.
346			"""
347			def __init__(self, parent, session):
348			"""Initialize the dialog.
349			"""
350			wxDialog.__init__(self, parent, -1, "Enter string for OGRConnection",
351			style = wxDIALOG_MODAL\|wxCAPTION)
352			self.session = session
353
354			# Sizer for the entire dialog
355			top = wxBoxSizer(wxVERTICAL)
356
357			# The list box with the drivers
358			box = wxBoxSizer(wxHORIZONTAL)#wxBox(self, -1, _("OGRConnection")),
359			# wxHORIZONTAL)
360			box.Add(wxStaticText(self, -1, _("URL:")), 0,
361			wxALL\|wxALIGN_CENTER_VERTICAL, 4)
362			self.text_string = wxTextCtrl(self, -1, "")
363			box.Add(self.text_string, 0, wxEXPAND, 0)
364			top.Add(box, 0, wxEXPAND)
365
366			# The standard button box at the bottom of the dialog
367			buttons = wxFlexGridSizer(1, 2, 0, 0)
368			ok_button = wxButton(self, ID_DBCHOOSE_OK, _("OK"))
369			EVT_BUTTON(self, ID_DBCHOOSE_OK, self.OnOK)
370			buttons.Add(ok_button, 0, wxALL\|wxALIGN_RIGHT, 4)
371			cancel_button = wxButton(self, ID_DBCHOOSE_CANCEL, _("Cancel"))
372			EVT_BUTTON(self, ID_DBCHOOSE_CANCEL, self.OnCancel)
373			buttons.Add(cancel_button, 0, wxALL, 4)
374			top.Add(buttons, 1, wxALL\|wxALIGN_CENTER_HORIZONTAL, 4)
375
376			# Autosizing
377			self.SetAutoLayout(1)
378			self.SetSizer(top)
379			top.Fit(self)
380			top.SetSizeHints(self)
381			self.Layout()
382
383			def RunDialog(self):
384			"""Run dialog
385			"""
386			self.ShowModal()
387			self.Destroy()
388			return self.result
389
390			def end_dialog(self, result):
391			"""Close dialog
392			"""
393			self.result = result
394			if result is not None:
395			self.EndModal(wxID_OK)
396			else:
397			self.EndModal(wxID_CANCEL)
398			self.Show(False)
399
400			def OnOK(self, event):
401			"""Dialog closed with OK
402			"""
403			result = {}
404			result["string"] = getattr(self, "text_string").GetValue()
405			self.end_dialog(result)
406
407			def OnCancel(self, event):
408			"""Dialog closed with Cancel.
409			"""
410			self.end_dialog(None)
411
412			def GetDatasourceName(self):
413			"""Return the string to be used for opening the database
414			"""
415			return self.result["string"]
416
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision