Thuban/UI/tableview.py

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

__version__ = "$Revision$"

from wxPython.wx import *
from wxPython.grid import *

from Thuban.Lib.connector import Publisher
from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
     FIELDTYPE_STRING
import view
from dialogs import NonModalDialog
from messages import SELECTED_SHAPE

wx_value_type_map = {FIELDTYPE_INT: wxGRID_VALUE_NUMBER,
                     FIELDTYPE_DOUBLE: wxGRID_VALUE_FLOAT,
                     FIELDTYPE_STRING: wxGRID_VALUE_STRING}

ROW_SELECTED = "ROW_SELECTED"


class DataTable(wxPyGridTableBase):

    """Wrapper around a Thuban table object suitable for a wxGrid"""

    def __init__(self, table = None):
        wxPyGridTableBase.__init__(self)
        self.num_cols = 0
        self.num_rows = 0
        self.columns = []
        self.table = None
        self.SetTable(table)

    def SetTable(self, table):
        self.table = table
        self.num_cols = table.field_count()
        self.num_rows = table.record_count()

        self.columns = []
        for i in range(self.num_cols):
            type, name, len, decc = table.field_info(i)
            self.columns.append((name, wx_value_type_map[type], len, decc))

    #
    # required methods for the wxPyGridTableBase interface
    #

    def GetNumberRows(self):
        return self.num_rows

    def GetNumberCols(self):
        return self.num_cols

    def IsEmptyCell(self, row, col):
        return 0

    # Get/Set values in the table.  The Python version of these
    # methods can handle any data-type, (as long as the Editor and
    # Renderer understands the type too,) not just strings as in the
    # C++ version.
    def GetValue(self, row, col):
        record = self.table.read_record(row)
        return record[self.columns[col][0]]

    def SetValue(self, row, col, value):
        pass

    #
    # Some optional methods
    #

    # Called when the grid needs to display labels
    def GetColLabelValue(self, col):
        return self.columns[col][0]

    # Called to determine the kind of editor/renderer to use by
    # default, doesn't necessarily have to be the same type used
    # nativly by the editor/renderer if they know how to convert.
    def GetTypeName(self, row, col):
        return self.columns[col][1]

    # Called to determine how the data can be fetched and stored by the
    # editor and renderer.  This allows you to enforce some type-safety
    # in the grid.
    def CanGetValueAs(self, row, col, typeName):
        # perhaps we should allow conversion int->double?
        return self.GetTypeName(row, col) == typeName

    def CanSetValueAs(self, row, col, typeName):
        return self.CanGetValueAs(row, col, typeName)


class TableGrid(wxGrid, Publisher):

    """A grid view for a Thuban table"""

    def __init__(self, parent, table = None):
        wxGrid.__init__(self, parent, -1)

        self.table = DataTable(table)

        # The second parameter means that the grid is to take ownership
        # of the table and will destroy it when done. Otherwise you
        # would need to keep a reference to it and call its Destroy
        # method later.
        self.SetTable(self.table, true)

        #self.SetMargins(0,0)

        # AutoSizeColumns would allow us to make the grid have optimal
        # column widths automatically but it would cause a traversal of
        # the entire table which for large .dbf files can take a very
        # long time.
        #self.AutoSizeColumns(false)

        self.SetSelectionMode(wxGrid.wxGridSelectRows)

        EVT_GRID_RANGE_SELECT(self, self.OnRangeSelect)
        EVT_GRID_SELECT_CELL(self, self.OnSelectCell)

    def SetTableObject(self, table):
        self.table.SetTable(table)

    def OnRangeSelect(self, event):
        if event.Selecting():
            self.issue(ROW_SELECTED, event.GetTopLeftCoords().GetRow())

    def OnSelectCell(self, event):
        self.issue(ROW_SELECTED, event.GetRow())


class LayerTableGrid(TableGrid):

    """Table grid for the layer tables.

    The LayerTableGrid is basically the same as a TableGrid but it's
    selection is usually coupled to the selected object in the map.
    """

    def select_shape(self, layer, shape):
        """Select the row corresponding to the specified shape and layer

        If layer is not the layer the table is associated with do
        nothing. If shape or layer is None also do nothing.
        """
        if layer is not None and layer.table is self.table.table \
           and shape is not None:
            self.SelectRow(shape)
            self.SetGridCursor(shape, 0)
            self.MakeCellVisible(shape, 0)


class TableFrame(NonModalDialog):

    """Frame that displays a Thuban table in a grid view"""

    def __init__(self, parent, interactor, name, title, table):
        NonModalDialog.__init__(self, parent, interactor, name, title)
        self.table = table
        self.grid = self.make_grid(self.table)

    def make_grid(self, table):
        """Return the table grid to use in the frame.

        The default implementation returns a TableGrid instance.
        Override in derived classes to use different grid classes.
        """
        return TableGrid(self, table)


class LayerTableFrame(TableFrame):

    """Frame that displays a layer table in a grid view

    A LayerTableFrame is TableFrame whose selection is connected to the
    selected object in a map.
    """

    def __init__(self, parent, interactor, name, title, layer, table):
        TableFrame.__init__(self, parent, interactor, name, title, table)
        self.layer = layer
        self.grid.Subscribe(ROW_SELECTED, self.row_selected)
        self.interactor.Subscribe(SELECTED_SHAPE, self.select_shape)

    def make_grid(self, table):
        """Override the derived method to return a LayerTableGrid.
        """
        return LayerTableGrid(self, table)

    def OnClose(self, event):
        self.interactor.Unsubscribe(SELECTED_SHAPE, self.select_shape)
        TableFrame.OnClose(self, event)

    def select_shape(self, layer, shape):
        self.grid.select_shape(layer, shape)

    def row_selected(self, row):
        if self.layer is not None:
            self.interactor.SelectLayerAndShape(self.layer, row)
1	# Copyright (c) 2001, 2002 by Intevation GmbH
2	# Authors:
3	# Bernhard Herzog <[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
10	from wxPython.wx import *
11	from wxPython.grid import *
12
13	from Thuban.Lib.connector import Publisher
14	from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
15	FIELDTYPE_STRING
16	import view
17	from dialogs import NonModalDialog
18	from messages import SELECTED_SHAPE
19
20	wx_value_type_map = {FIELDTYPE_INT: wxGRID_VALUE_NUMBER,
21	FIELDTYPE_DOUBLE: wxGRID_VALUE_FLOAT,
22	FIELDTYPE_STRING: wxGRID_VALUE_STRING}
23
24	ROW_SELECTED = "ROW_SELECTED"
25
26
27	class DataTable(wxPyGridTableBase):
28
29	"""Wrapper around a Thuban table object suitable for a wxGrid"""
30
31	def __init__(self, table = None):
32	wxPyGridTableBase.__init__(self)
33	self.num_cols = 0
34	self.num_rows = 0
35	self.columns = []
36	self.table = None
37	self.SetTable(table)
38
39	def SetTable(self, table):
40	self.table = table
41	self.num_cols = table.field_count()
42	self.num_rows = table.record_count()
43
44	self.columns = []
45	for i in range(self.num_cols):
46	type, name, len, decc = table.field_info(i)
47	self.columns.append((name, wx_value_type_map[type], len, decc))
48
49	#
50	# required methods for the wxPyGridTableBase interface
51	#
52
53	def GetNumberRows(self):
54	return self.num_rows
55
56	def GetNumberCols(self):
57	return self.num_cols
58
59	def IsEmptyCell(self, row, col):
60	return 0
61
62	# Get/Set values in the table. The Python version of these
63	# methods can handle any data-type, (as long as the Editor and
64	# Renderer understands the type too,) not just strings as in the
65	# C++ version.
66	def GetValue(self, row, col):
67	record = self.table.read_record(row)
68	return record[self.columns[col][0]]
69
70	def SetValue(self, row, col, value):
71	pass
72
73	#
74	# Some optional methods
75	#
76
77	# Called when the grid needs to display labels
78	def GetColLabelValue(self, col):
79	return self.columns[col][0]
80
81	# Called to determine the kind of editor/renderer to use by
82	# default, doesn't necessarily have to be the same type used
83	# nativly by the editor/renderer if they know how to convert.
84	def GetTypeName(self, row, col):
85	return self.columns[col][1]
86
87	# Called to determine how the data can be fetched and stored by the
88	# editor and renderer. This allows you to enforce some type-safety
89	# in the grid.
90	def CanGetValueAs(self, row, col, typeName):
91	# perhaps we should allow conversion int->double?
92	return self.GetTypeName(row, col) == typeName
93
94	def CanSetValueAs(self, row, col, typeName):
95	return self.CanGetValueAs(row, col, typeName)
96
97
98	class TableGrid(wxGrid, Publisher):
99
100	"""A grid view for a Thuban table"""
101
102	def __init__(self, parent, table = None):
103	wxGrid.__init__(self, parent, -1)
104
105	self.table = DataTable(table)
106
107	# The second parameter means that the grid is to take ownership
108	# of the table and will destroy it when done. Otherwise you
109	# would need to keep a reference to it and call its Destroy
110	# method later.
111	self.SetTable(self.table, true)
112
113	#self.SetMargins(0,0)
114
115	# AutoSizeColumns would allow us to make the grid have optimal
116	# column widths automatically but it would cause a traversal of
117	# the entire table which for large .dbf files can take a very
118	# long time.
119	#self.AutoSizeColumns(false)
120
121	self.SetSelectionMode(wxGrid.wxGridSelectRows)
122
123	EVT_GRID_RANGE_SELECT(self, self.OnRangeSelect)
124	EVT_GRID_SELECT_CELL(self, self.OnSelectCell)
125
126	def SetTableObject(self, table):
127	self.table.SetTable(table)
128
129	def OnRangeSelect(self, event):
130	if event.Selecting():
131	self.issue(ROW_SELECTED, event.GetTopLeftCoords().GetRow())
132
133	def OnSelectCell(self, event):
134	self.issue(ROW_SELECTED, event.GetRow())
135
136
137	class LayerTableGrid(TableGrid):
138
139	"""Table grid for the layer tables.
140
141	The LayerTableGrid is basically the same as a TableGrid but it's
142	selection is usually coupled to the selected object in the map.
143	"""
144
145	def select_shape(self, layer, shape):
146	"""Select the row corresponding to the specified shape and layer
147
148	If layer is not the layer the table is associated with do
149	nothing. If shape or layer is None also do nothing.
150	"""
151	if layer is not None and layer.table is self.table.table \
152	and shape is not None:
153	self.SelectRow(shape)
154	self.SetGridCursor(shape, 0)
155	self.MakeCellVisible(shape, 0)
156
157
158	class TableFrame(NonModalDialog):
159
160	"""Frame that displays a Thuban table in a grid view"""
161
162	def __init__(self, parent, interactor, name, title, table):
163	NonModalDialog.__init__(self, parent, interactor, name, title)
164	self.table = table
165	self.grid = self.make_grid(self.table)
166
167	def make_grid(self, table):
168	"""Return the table grid to use in the frame.
169
170	The default implementation returns a TableGrid instance.
171	Override in derived classes to use different grid classes.
172	"""
173	return TableGrid(self, table)
174
175
176	class LayerTableFrame(TableFrame):
177
178	"""Frame that displays a layer table in a grid view
179
180	A LayerTableFrame is TableFrame whose selection is connected to the
181	selected object in a map.
182	"""
183
184	def __init__(self, parent, interactor, name, title, layer, table):
185	TableFrame.__init__(self, parent, interactor, name, title, table)
186	self.layer = layer
187	self.grid.Subscribe(ROW_SELECTED, self.row_selected)
188	self.interactor.Subscribe(SELECTED_SHAPE, self.select_shape)
189
190	def make_grid(self, table):
191	"""Override the derived method to return a LayerTableGrid.
192	"""
193	return LayerTableGrid(self, table)
194
195	def OnClose(self, event):
196	self.interactor.Unsubscribe(SELECTED_SHAPE, self.select_shape)
197	TableFrame.OnClose(self, event)
198
199	def select_shape(self, layer, shape):
200	self.grid.select_shape(layer, shape)
201
202	def row_selected(self, row):
203	if self.layer is not None:
204	self.interactor.SelectLayerAndShape(self.layer, row)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision