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	# 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	"""The layer and table join dialog"""
9
10	__version__ = "$Revision$"
11	# $Source$
12	# $Id$
13
14
15	import sys
16	from wxPython.wx import *
17
18	from Thuban import _
19
20	from Thuban.Model.transientdb import TransientJoinedTable
21	from Thuban.Model.data import DerivedShapeStore
22	from Thuban.UI.tableview import QueryTableFrame
23
24	from common import ThubanBeginBusyCursor, ThubanEndBusyCursor
25
26	ID_LEFT_TABLE = 4001
27	ID_RIGHT_TABLE = 4002
28
29	CHOICE_WIDTH = 150
30
31	class JoinDialog(wxDialog):
32
33	"""Table join dialog.
34
35	Join two tables (left/right) based on the user selected fields.
36	Opens a QueryTableFrame and registers the new table with the session.
37	"""
38
39	def __init__(self, parent, title, session, layer = None):
40	wxDialog.__init__(self, parent, -1, title,
41	style = wxDEFAULT_DIALOG_STYLE\|wxRESIZE_BORDER)
42	self.layer = layer
43
44	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	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
57	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
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	EVT_BUTTON(self, wxID_OK, self.OnJoin)
69
70	if self.choice_left_table is not None:
71	self.choice_left_table.Append(_('Select...'), None)
72	self.choice_right_table.Append(_('Select...'), None)
73
74	for t in session.Tables():
75	if self.choice_left_table is not None:
76	self.choice_left_table.Append(t.Title(), t)
77
78	# 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	self.choice_right_table.Append(t.Title(), t)
83
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	EVT_CHOICE(self, ID_RIGHT_TABLE, self.OnRightTable)
91
92	if self.choice_left_table is not None:
93	self.choice_left_table.SetSelection(0)
94	self.choice_right_table.SetSelection(0)
95	self.button_join.Enable(False)
96
97	topBox = wxBoxSizer(wxVERTICAL)
98
99	sizer = wxFlexGridSizer(2, 4)
100	sizer.Add(wxStaticText(self, -1, _("Table:")), 0, wxALL, 4)
101	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	sizer.Add(wxStaticText(self, -1, _("Table:")), 0, wxALL, 4)
109	sizer.Add(self.choice_right_table, 1,
110	wxEXPAND\|wxALL\|wxALIGN_CENTER_VERTICAL, 4)
111	sizer.Add(wxStaticText(self, -1, _("Field:")), 0, wxALL, 4)
112	sizer.Add(self.choice_left_field, 1,
113	wxEXPAND\|wxALL\|wxALIGN_CENTER_VERTICAL, 4)
114	sizer.Add(wxStaticText(self, -1, _("Field:")), 0, wxALL, 4)
115	sizer.Add(self.choice_right_field, 1,
116	wxEXPAND\|wxALL\|wxALIGN_CENTER_VERTICAL, 4)
117
118	sizer.AddGrowableCol(1)
119	sizer.AddGrowableCol(3)
120
121	topBox.Add(sizer, 0, wxEXPAND\|wxALL, 4)
122
123	sizer = wxBoxSizer(wxHORIZONTAL)
124	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
129	sizer = wxBoxSizer(wxHORIZONTAL)
130	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
135	topBox.Add(sizer, 1, wxALIGN_RIGHT\|wxALIGN_BOTTOM\|wxBOTTOM\|wxTOP, 10)
136
137	self.SetAutoLayout(True)
138	self.SetSizer(topBox)
139	topBox.Fit(self)
140	topBox.SetSizeHints(self)
141
142	# Save same parameters for later use.
143	self.parent = parent
144	self.session = session
145
146	def OnJoin(self, event):
147	"""Get the table and field selections and perform the join."""
148	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
181	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
190	finally:
191	ThubanEndBusyCursor()
192
193	if self.layer is not None:
194	if needed_rows != joined_rows:
195	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	% {"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
206	else:
207	name = joined_table.tablename
208	dialog = QueryTableFrame(self.parent, name,
209	_('Table: %s') % joined_table.Title(),
210	joined_table)
211	self.parent.add_dialog(name, dialog)
212	dialog.Show(True)
213
214	self.Close()
215
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	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
230	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	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
240	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	sel = self.choice_right_table.GetSelection()
246	self.button_join.Enable(sel > 0 and lsel > 0 and sel != lsel)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision