Thuban/UI/tableview.py

# Copyright (c) 2001 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 it's Destroy
        # method later.
        self.SetTable(self.table, true)

        #self.SetMargins(0,0)
        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())

    def select_shape(self, layer, shape):
        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, layer = None,
                 table = None):
        NonModalDialog.__init__(self, parent, interactor, name, title)
        self.layer = layer
        self.table = table
        self.grid = TableGrid(self, table)
        self.grid.Subscribe(ROW_SELECTED, self.row_selected)
        self.interactor.Subscribe(SELECTED_SHAPE, self.select_shape)

    def OnClose(self, event):
        self.interactor.Unsubscribe(SELECTED_SHAPE, self.select_shape)
        NonModalDialog.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 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 it's Destroy
110	# method later.
111	self.SetTable(self.table, true)
112
113	#self.SetMargins(0,0)
114	self.AutoSizeColumns(false)
115
116	self.SetSelectionMode(wxGrid.wxGridSelectRows)
117
118	EVT_GRID_RANGE_SELECT(self, self.OnRangeSelect)
119	EVT_GRID_SELECT_CELL(self, self.OnSelectCell)
120
121	def SetTableObject(self, table):
122	self.table.SetTable(table)
123
124	def OnRangeSelect(self, event):
125	if event.Selecting():
126	self.issue(ROW_SELECTED, event.GetTopLeftCoords().GetRow())
127
128	def OnSelectCell(self, event):
129	self.issue(ROW_SELECTED, event.GetRow())
130
131	def select_shape(self, layer, shape):
132	if layer is not None and layer.table is self.table.table \
133	and shape is not None:
134	self.SelectRow(shape)
135	self.SetGridCursor(shape, 0)
136	self.MakeCellVisible(shape, 0)
137
138
139	class TableFrame(NonModalDialog):
140
141	"""Frame that displays a Thuban table in a grid view"""
142
143	def __init__(self, parent, interactor, name, title, layer = None,
144	table = None):
145	NonModalDialog.__init__(self, parent, interactor, name, title)
146	self.layer = layer
147	self.table = table
148	self.grid = TableGrid(self, table)
149	self.grid.Subscribe(ROW_SELECTED, self.row_selected)
150	self.interactor.Subscribe(SELECTED_SHAPE, self.select_shape)
151
152	def OnClose(self, event):
153	self.interactor.Unsubscribe(SELECTED_SHAPE, self.select_shape)
154	NonModalDialog.OnClose(self, event)
155
156	def select_shape(self, layer, shape):
157	self.grid.select_shape(layer, shape)
158
159	def row_selected(self, row):
160	if self.layer is not None:
161	self.interactor.SelectLayerAndShape(self.layer, row)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision