Thuban/UI/join.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.

"""The layer and table join dialog"""

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


import sys
from wxPython.wx import *

from Thuban import _

from Thuban.Model.transientdb import TransientJoinedTable
from Thuban.Model.data import DerivedShapeStore
from Thuban.UI.tableview import QueryTableFrame

from common import ThubanBeginBusyCursor, ThubanEndBusyCursor

ID_LEFT_TABLE = 4001
ID_RIGHT_TABLE = 4002

CHOICE_WIDTH = 150

class JoinDialog(wxDialog):

    """Table join dialog.

    Join two tables (left/right) based on the user selected fields.
    Opens a QueryTableFrame and registers the new table with the session.
    """

    def __init__(self, parent, title, session, layer = None):
        wxDialog.__init__(self, parent, -1, title,
                          style = wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER)
        self.layer = layer

        if not layer:
            self.choice_left_table = wxChoice(self, ID_LEFT_TABLE)
            width, height = self.choice_left_table.GetSizeTuple()
            self.choice_left_table.SetSize(wxSize(CHOICE_WIDTH, height))
            self.left_table = None
        else:
            self.choice_left_table = None
            self.left_table = layer.ShapeStore().Table()

        self.choice_right_table = wxChoice(self, ID_RIGHT_TABLE)
        width, height = self.choice_right_table.GetSizeTuple()
        self.choice_right_table.SetSize(wxSize(CHOICE_WIDTH, height))

        self.choice_left_field = wxChoice(self, -1)
        width, height = self.choice_left_field.GetSizeTuple()
        self.choice_left_field.SetSize(wxSize(CHOICE_WIDTH, height))
        self.choice_right_field = wxChoice(self, -1)
        width, height = self.choice_right_field.GetSizeTuple()
        self.choice_right_field.SetSize(wxSize(CHOICE_WIDTH, height))

        self.button_join = wxButton(self, wxID_OK, _("Join"))
        self.button_join.SetDefault()
        self.button_close = wxButton(self, wxID_CANCEL, _("Close"))

        EVT_BUTTON(self, wxID_OK, self.OnJoin)

        if self.choice_left_table is not None:
            self.choice_left_table.Append('Select ...', None)
        self.choice_right_table.Append('Select ...', None)

        for t in session.Tables():
            if self.choice_left_table is not None:
                self.choice_left_table.Append(t.Title(), t)

            # If there is no choice_left_table then self.left_table will
            # be the keft table so we can simply leave it out on the
            # right side.
            if t is not self.left_table:
                self.choice_right_table.Append(t.Title(), t)

        if self.choice_left_table is None:
            for col in self.left_table.Columns():
                self.choice_left_field.Append(col.name, col)

        if self.choice_left_table is not None:
            EVT_CHOICE(self, ID_LEFT_TABLE, self.OnLeftTable)
        EVT_CHOICE(self, ID_RIGHT_TABLE, self.OnRightTable)

        if self.choice_left_table is not None:
            self.choice_left_table.SetSelection(0)
        self.choice_right_table.SetSelection(0)
        self.button_join.Enable(False)

        topBox = wxBoxSizer(wxVERTICAL)

        sizer = wxFlexGridSizer(2, 4)
        sizer.Add(wxStaticText(self, -1, _("Table:")), 0, wxALL, 4)
        if self.choice_left_table is not None:
            sizer.Add(self.choice_left_table, 1,
                      wxEXPAND|wxALL|wxALIGN_CENTER_VERTICAL, 4)
        else:
            sizer.Add(wxStaticText(self, -1, self.left_table.Title()), 0,
                      wxALL, 4)

        sizer.Add(wxStaticText(self, -1, _("Table:")), 0, wxALL, 4)
        sizer.Add(self.choice_right_table, 1,
                  wxEXPAND|wxALL|wxALIGN_CENTER_VERTICAL, 4)
        sizer.Add(wxStaticText(self, -1, _("Field:")), 0, wxALL, 4)
        sizer.Add(self.choice_left_field, 1,
                  wxEXPAND|wxALL|wxALIGN_CENTER_VERTICAL, 4)
        sizer.Add(wxStaticText(self, -1, _("Field:")), 0, wxALL, 4)
        sizer.Add(self.choice_right_field, 1,
                  wxEXPAND|wxALL|wxALIGN_CENTER_VERTICAL, 4)

        sizer.AddGrowableCol(1)
        sizer.AddGrowableCol(3)

        topBox.Add(sizer, 0, wxEXPAND|wxALL, 4)

        sizer = wxBoxSizer(wxHORIZONTAL)
        self.check_outer_join = wxCheckBox(self,-1,
                                _("Outer Join (preserves left table records)"))
        sizer.Add(self.check_outer_join, 1, wxALL,4)
        topBox.Add(sizer, 0, wxALIGN_LEFT|wxALIGN_TOP, 4)

        sizer = wxBoxSizer(wxHORIZONTAL)
        sizer.Add(self.button_join, 0, wxALIGN_RIGHT|wxALIGN_BOTTOM|wxRIGHT,
                  10)
        sizer.Add(self.button_close, 0, wxALIGN_RIGHT|wxALIGN_BOTTOM|wxRIGHT,
                  10)

        topBox.Add(sizer, 1, wxALIGN_RIGHT|wxALIGN_BOTTOM|wxBOTTOM|wxTOP, 10)

        self.SetAutoLayout(True)
        self.SetSizer(topBox)
        topBox.Fit(self)
        topBox.SetSizeHints(self)

        # Save same parameters for later use.
        self.parent = parent
        self.session = session

    def OnJoin(self, event):
        """Get the table and field selections and perform the join."""
        ThubanBeginBusyCursor()
        try:
            # left
            if self.choice_left_table is not None:
                i = self.choice_left_table.GetSelection()
                left_table = self.choice_left_table.GetClientData(i)
            else:
                left_table = self.left_table
            i = self.choice_left_field.GetSelection()
            left_field  = self.choice_left_field.GetString(i)
            # right
            i = self.choice_right_table.GetSelection()
            right_table = self.choice_right_table.GetClientData(i)
            i = self.choice_right_field.GetSelection()
            right_field  = self.choice_right_field.GetString(i)
    
            outer_join = self.check_outer_join.IsChecked()
    
            try:
                joined_table = TransientJoinedTable(self.session.TransientDB(),
                                                    left_table, left_field,
                                                    right_table, right_field,
                                                    outer_join)
            except:
                dlg = wxMessageDialog(None,
                                      _('Join failed:\n  %s') % sys.exc_info()[1],
                                      _('Info'), wxOK|wxICON_ERROR)
                dlg.ShowModal()
                dlg.Destroy()
                return
    
            joined_table = self.session.AddTable(joined_table)

            if self.layer is not None:
                needed_rows = self.layer.ShapeStore().Table().NumRows()
                joined_rows = joined_table.NumRows()
                if needed_rows == joined_rows:
                    store = DerivedShapeStore(self.layer.ShapeStore(),
                                          joined_table)
                    self.session.AddShapeStore(store)
                    self.layer.SetShapeStore(store)

        finally:
            ThubanEndBusyCursor()

        if self.layer is not None:
            if needed_rows != joined_rows:
                msg = _("The joined table has %(joined)d rows but"
                        " it must have %(needed)d rows"
                        " to be used with the selected layer") \
                        % {"joined": joined_rows,
                           "needed": needed_rows}
                dlg = wxMessageDialog(None, msg, _('Join Failed'),
                                      wxOK|wxICON_ERROR)
                dlg.ShowModal()
                dlg.Destroy()
                return

        else:
            name = joined_table.tablename
            dialog = QueryTableFrame(self.parent, name,
                                     _('Table: %s') % joined_table.Title(),
                                     joined_table)
            self.parent.add_dialog(name, dialog)
            dialog.Show(True)
    
        self.Close()

    def OnClose(self, event):
        """Close the dialog."""
        self.Close()

    def OnLeftTable(self, event):
        """Get the selected table and fill the field choice."""
        i = self.choice_left_table.GetSelection()
        table = self.choice_left_table.GetClientData(i)
        self.choice_left_field.Clear()
        if table is not None:
            for col in table.Columns():
                self.choice_left_field.Append(col.name, col)
        self.update_sensitivity()

    def OnRightTable(self, event):
        """Get the selected table and fill the field choice."""
        i = self.choice_right_table.GetSelection()
        table = self.choice_right_table.GetClientData(i)
        self.choice_right_field.Clear()
        if table is not None:
            for col in table.Columns():
                self.choice_right_field.Append(col.name, col)
        self.update_sensitivity()

    def update_sensitivity(self):
        if self.choice_left_table is not None:
            lsel = self.choice_left_table.GetSelection()
        else:
            lsel = sys.maxint
        sel = self.choice_right_table.GetSelection()
        self.button_join.Enable(sel > 0 and lsel > 0 and sel != lsel)
1	jonathan	888	# 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	bh	1072
8	bh	1542	"""The layer and table join dialog"""
9
10			__version__ = "$Revision$"
11			# $Source$
12			# $Id$
13
14
15	bh	1072	import sys
16	jonathan	888	from wxPython.wx import *
17	bh	1072
18	jonathan	888	from Thuban import _
19	frank	1000
20			from Thuban.Model.transientdb import TransientJoinedTable
21	bh	1072	from Thuban.Model.data import DerivedShapeStore
22			from Thuban.UI.tableview import QueryTableFrame
23
24	frank	1890	from common import ThubanBeginBusyCursor, ThubanEndBusyCursor
25
26	frank	1000	ID_LEFT_TABLE = 4001
27			ID_RIGHT_TABLE = 4002
28	jonathan	888
29	frank	1000	CHOICE_WIDTH = 150
30
31	jonathan	888	class JoinDialog(wxDialog):
32	bh	1072
33	frank	1000	"""Table join dialog.
34	jonathan	888
35	frank	1000	Join two tables (left/right) based on the user selected fields.
36	jan	1022	Opens a QueryTableFrame and registers the new table with the session.
37	frank	1000	"""
38
39	jonathan	888	def __init__(self, parent, title, session, layer = None):
40			wxDialog.__init__(self, parent, -1, title,
41			style = wxDEFAULT_DIALOG_STYLE\|wxRESIZE_BORDER)
42	bh	1072	self.layer = layer
43	jonathan	888
44	bh	1072	if not layer:
45			self.choice_left_table = wxChoice(self, ID_LEFT_TABLE)
46			width, height = self.choice_left_table.GetSizeTuple()
47			self.choice_left_table.SetSize(wxSize(CHOICE_WIDTH, height))
48			self.left_table = None
49			else:
50			self.choice_left_table = None
51			self.left_table = layer.ShapeStore().Table()
52
53	frank	1000	self.choice_right_table = wxChoice(self, ID_RIGHT_TABLE)
54			width, height = self.choice_right_table.GetSizeTuple()
55			self.choice_right_table.SetSize(wxSize(CHOICE_WIDTH, height))
56	jonathan	888
57	frank	1000	self.choice_left_field = wxChoice(self, -1)
58			width, height = self.choice_left_field.GetSizeTuple()
59			self.choice_left_field.SetSize(wxSize(CHOICE_WIDTH, height))
60			self.choice_right_field = wxChoice(self, -1)
61			width, height = self.choice_right_field.GetSizeTuple()
62			self.choice_right_field.SetSize(wxSize(CHOICE_WIDTH, height))
63	jonathan	888
64			self.button_join = wxButton(self, wxID_OK, _("Join"))
65			self.button_join.SetDefault()
66			self.button_close = wxButton(self, wxID_CANCEL, _("Close"))
67
68	frank	1000	EVT_BUTTON(self, wxID_OK, self.OnJoin)
69	jonathan	888
70	bh	1072	if self.choice_left_table is not None:
71			self.choice_left_table.Append('Select ...', None)
72	frank	1000	self.choice_right_table.Append('Select ...', None)
73	bh	1072
74	frank	1000	for t in session.Tables():
75	bh	1072	if self.choice_left_table is not None:
76	bh	1521	self.choice_left_table.Append(t.Title(), t)
77	jonathan	888
78	bh	1072	# If there is no choice_left_table then self.left_table will
79			# be the keft table so we can simply leave it out on the
80			# right side.
81			if t is not self.left_table:
82	bh	1521	self.choice_right_table.Append(t.Title(), t)
83	bh	1072
84			if self.choice_left_table is None:
85			for col in self.left_table.Columns():
86			self.choice_left_field.Append(col.name, col)
87
88			if self.choice_left_table is not None:
89			EVT_CHOICE(self, ID_LEFT_TABLE, self.OnLeftTable)
90	frank	1000	EVT_CHOICE(self, ID_RIGHT_TABLE, self.OnRightTable)
91
92	bh	1072	if self.choice_left_table is not None:
93			self.choice_left_table.SetSelection(0)
94	frank	1000	self.choice_right_table.SetSelection(0)
95	jonathan	888	self.button_join.Enable(False)
96
97			topBox = wxBoxSizer(wxVERTICAL)
98
99			sizer = wxFlexGridSizer(2, 4)
100	frank	1000	sizer.Add(wxStaticText(self, -1, _("Table:")), 0, wxALL, 4)
101	bh	1072	if self.choice_left_table is not None:
102			sizer.Add(self.choice_left_table, 1,
103			wxEXPAND\|wxALL\|wxALIGN_CENTER_VERTICAL, 4)
104			else:
105			sizer.Add(wxStaticText(self, -1, self.left_table.Title()), 0,
106			wxALL, 4)
107
108	frank	1000	sizer.Add(wxStaticText(self, -1, _("Table:")), 0, wxALL, 4)
109			sizer.Add(self.choice_right_table, 1,
110	bh	1072	wxEXPAND\|wxALL\|wxALIGN_CENTER_VERTICAL, 4)
111	frank	1000	sizer.Add(wxStaticText(self, -1, _("Field:")), 0, wxALL, 4)
112			sizer.Add(self.choice_left_field, 1,
113	bh	1072	wxEXPAND\|wxALL\|wxALIGN_CENTER_VERTICAL, 4)
114	frank	1000	sizer.Add(wxStaticText(self, -1, _("Field:")), 0, wxALL, 4)
115			sizer.Add(self.choice_right_field, 1,
116	bh	1072	wxEXPAND\|wxALL\|wxALIGN_CENTER_VERTICAL, 4)
117	jonathan	888
118			sizer.AddGrowableCol(1)
119			sizer.AddGrowableCol(3)
120
121	frank	1010	topBox.Add(sizer, 0, wxEXPAND\|wxALL, 4)
122	jonathan	888
123			sizer = wxBoxSizer(wxHORIZONTAL)
124	frank	1010	self.check_outer_join = wxCheckBox(self,-1,
125			_("Outer Join (preserves left table records)"))
126			sizer.Add(self.check_outer_join, 1, wxALL,4)
127			topBox.Add(sizer, 0, wxALIGN_LEFT\|wxALIGN_TOP, 4)
128	jonathan	888
129	frank	1010	sizer = wxBoxSizer(wxHORIZONTAL)
130	bh	1072	sizer.Add(self.button_join, 0, wxALIGN_RIGHT\|wxALIGN_BOTTOM\|wxRIGHT,
131			10)
132			sizer.Add(self.button_close, 0, wxALIGN_RIGHT\|wxALIGN_BOTTOM\|wxRIGHT,
133			10)
134	jonathan	888
135	frank	1010	topBox.Add(sizer, 1, wxALIGN_RIGHT\|wxALIGN_BOTTOM\|wxBOTTOM\|wxTOP, 10)
136
137	jonathan	888	self.SetAutoLayout(True)
138			self.SetSizer(topBox)
139			topBox.Fit(self)
140			topBox.SetSizeHints(self)
141
142	frank	1000	# Save same parameters for later use.
143			self.parent = parent
144			self.session = session
145	jonathan	888
146	frank	1000	def OnJoin(self, event):
147			"""Get the table and field selections and perform the join."""
148	frank	1890	ThubanBeginBusyCursor()
149			try:
150			# left
151			if self.choice_left_table is not None:
152			i = self.choice_left_table.GetSelection()
153			left_table = self.choice_left_table.GetClientData(i)
154			else:
155			left_table = self.left_table
156			i = self.choice_left_field.GetSelection()
157			left_field = self.choice_left_field.GetString(i)
158			# right
159			i = self.choice_right_table.GetSelection()
160			right_table = self.choice_right_table.GetClientData(i)
161			i = self.choice_right_field.GetSelection()
162			right_field = self.choice_right_field.GetString(i)
163
164			outer_join = self.check_outer_join.IsChecked()
165
166			try:
167			joined_table = TransientJoinedTable(self.session.TransientDB(),
168			left_table, left_field,
169			right_table, right_field,
170			outer_join)
171			except:
172			dlg = wxMessageDialog(None,
173			_('Join failed:\n %s') % sys.exc_info()[1],
174			_('Info'), wxOK\|wxICON_ERROR)
175			dlg.ShowModal()
176			dlg.Destroy()
177			return
178
179			joined_table = self.session.AddTable(joined_table)
180	jonathan	888
181	frank	1890	if self.layer is not None:
182			needed_rows = self.layer.ShapeStore().Table().NumRows()
183			joined_rows = joined_table.NumRows()
184			if needed_rows == joined_rows:
185			store = DerivedShapeStore(self.layer.ShapeStore(),
186			joined_table)
187			self.session.AddShapeStore(store)
188			self.layer.SetShapeStore(store)
189	frank	1010
190	frank	1890	finally:
191			ThubanEndBusyCursor()
192	bh	1007
193	bh	1072	if self.layer is not None:
194			if needed_rows != joined_rows:
195	bh	1572	msg = _("The joined table has %(joined)d rows but"
196			" it must have %(needed)d rows"
197			" to be used with the selected layer") \
198	bh	1072	% {"joined": joined_rows,
199			"needed": needed_rows}
200			dlg = wxMessageDialog(None, msg, _('Join Failed'),
201			wxOK\|wxICON_ERROR)
202			dlg.ShowModal()
203			dlg.Destroy()
204			return
205	frank	1890
206	bh	1072	else:
207	frank	1000	name = joined_table.tablename
208	jan	1022	dialog = QueryTableFrame(self.parent, name,
209	bh	1072	_('Table: %s') % joined_table.Title(),
210			joined_table)
211	frank	1000	self.parent.add_dialog(name, dialog)
212	jan	1035	dialog.Show(True)
213	frank	1890
214	bh	1072	self.Close()
215	frank	1000
216			def OnClose(self, event):
217			"""Close the dialog."""
218			self.Close()
219
220			def OnLeftTable(self, event):
221			"""Get the selected table and fill the field choice."""
222			i = self.choice_left_table.GetSelection()
223			table = self.choice_left_table.GetClientData(i)
224			self.choice_left_field.Clear()
225	bh	1072	if table is not None:
226			for col in table.Columns():
227			self.choice_left_field.Append(col.name, col)
228			self.update_sensitivity()
229	jonathan	888
230	frank	1000	def OnRightTable(self, event):
231			"""Get the selected table and fill the field choice."""
232			i = self.choice_right_table.GetSelection()
233			table = self.choice_right_table.GetClientData(i)
234			self.choice_right_field.Clear()
235	bh	1072	if table is not None:
236			for col in table.Columns():
237			self.choice_right_field.Append(col.name, col)
238			self.update_sensitivity()
239	jonathan	888
240	bh	1072	def update_sensitivity(self):
241			if self.choice_left_table is not None:
242			lsel = self.choice_left_table.GetSelection()
243			else:
244			lsel = sys.maxint
245	frank	1000	sel = self.choice_right_table.GetSelection()
246	bh	1072	self.button_join.Enable(sel > 0 and lsel > 0 and sel != lsel)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision