Thuban/UI/controls.py

# Copyright (c) 2001, 2002, 2003 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.


"""Common Thuban specific control widgets"""

__version__ = "$Revision$"

from wxPython.wx import wxListCtrl, wxLC_REPORT, wxLIST_AUTOSIZE_USEHEADER, \
     EVT_LIST_ITEM_SELECTED, true, false
from wxPython.grid import wxPyGridTableBase, wxGrid, wxGRID_VALUE_STRING, \
     wxGridTableMessage, wxGRIDTABLE_NOTIFY_ROWS_APPENDED, \
     wxGRIDTABLE_NOTIFY_ROWS_DELETED, wxGRIDTABLE_REQUEST_VIEW_GET_VALUES

from Thuban import _

# FIXME: the wx_value_type_map should be moved from tableview to a
# separate module
from tableview import wx_value_type_map


class RecordListCtrl(wxListCtrl):

    """List Control showing a single record from a thuban table"""

    def __init__(self, parent, id):
        wxListCtrl.__init__(self, parent, id, style = wxLC_REPORT)

        self.InsertColumn(0, _("Field"))
        self.SetColumnWidth(0, 200)
        self.InsertColumn(1, _("Value"))
        self.SetColumnWidth(1, 100)

        # vaues maps row numbers to the corresponding python values
        self.values = {}

    def fill_list(self, table, shape):
        """Fill self with the contents shape's record from table"""
        self.DeleteAllItems()
        values = {}

        if shape is not None:
            names = []
            for col in table.Columns():
                names.append(col.name)
            record = table.ReadRowAsDict(shape)

            for i in range(len(names)):
                name = names[i]
                value = record[name]
                self.InsertStringItem(i, name)
                self.SetStringItem(i, 1, str(value))
                values[i] = value

        self.values = values

class SelectableRecordListCtrl(RecordListCtrl):

    def __init__(self, parent, id):
        RecordListCtrl.__init__(self, parent, id)

        # selected is the index of the selected record or -1 if none is
        # selected
        self.selected = -1
        EVT_LIST_ITEM_SELECTED(self, self.GetId(), self.OnItemSelected)

    def OnItemSelected(self, event):
        """Event handler. Update the selected instvar"""
        self.selected = event.m_itemIndex

    def GetValue(self):
        """Return the currently selected value. None if no value is selected"""
        if self.selected >= 0:
            return self.values[self.selected]
        else:
            return None


class RecordTable(wxPyGridTableBase):

    """Wrapper that makes a Thuban table record look like a table for a
       wxGrid
    """

    def __init__(self, table = None, record = None):
        wxPyGridTableBase.__init__(self)
        self.num_cols = 1
        self.num_rows = 0
        self.table = None
        self.record_index = record
        self.record = None
        self.SetTable(table, record)

    def SetTable(self, table, record_index):
        old_num_rows = self.num_rows
        if record_index is not None:
            self.table = table
            self.record_index = record_index
            self.record = table.ReadRowAsDict(record_index)

            # we have one row for each field in the table
            self.num_rows = table.NumColumns()

            # extract the field types and names of the row we're showing.
            self.rows = []
            for i in range(self.num_rows):
                col = table.Column(i)
                self.rows.append((col.name, wx_value_type_map[col.type]))
            self.notify_get_values()
        else:
            # make the grid empty
            self.num_rows = 0
            self.rows = []

        # notify the views if the number of rows has changed
        if self.num_rows > old_num_rows:
            self.notify_append_rows(self.num_rows - old_num_rows)
        elif self.num_rows < old_num_rows:
            self.notify_delete_rows(0, old_num_rows - self.num_rows)

    def notify_append_rows(self, num):
        """Tell the view that num rows were appended"""
        self.send_view_message(wxGRIDTABLE_NOTIFY_ROWS_APPENDED, num)

    def notify_delete_rows(self, start, num):
        """Tell the view that num rows were deleted starting at start"""
        self.send_view_message(wxGRIDTABLE_NOTIFY_ROWS_DELETED, start, num)

    def notify_get_values(self):
        """Tell the view that the grid's values have to be updated"""
        self.send_view_message(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)

    def send_view_message(self, msgid, *args):
        """Send the message msgid to the view with arguments args"""
        view = self.GetView()
        if view:
            #print "send_view_message", msgid, args
            msg = apply(wxGridTableMessage, (self, msgid) + args)
            view.ProcessTableMessage(msg)

    #
    # 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 row >= self.num_rows or col >= self.num_cols

    # 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):
        if row < self.num_rows:
            return self.record[self.rows[row][0]]
        return ""

    def SetValue(self, row, col, value):
        if row < self.num_rows:
            name = self.rows[row][0]
            self.record[name] = value
            self.table.write_record(self.record_index, {name: value})

    #
    # Some optional methods
    #

    # Called when the grid needs to display labels
    def GetColLabelValue(self, col):
        return _("Value")

    def GetRowLabelValue(self, row):
        if row < self.num_rows:
            return self.rows[row][0]
        return ""

    # 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):
        # for some reason row and col may be negative sometimes, but
        # it's probably a wx bug (filed as #593189 on sourceforge)
        if 0 <= row < self.num_rows:
            return self.rows[row][1]
        return wxGRID_VALUE_STRING

    # 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 RecordGridCtrl(wxGrid):

    """Grid view for a RecordTable"""

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

        self.table = RecordTable(table, record)

        # 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.AutoSizeColumn(0, true)

        #self.SetSelectionMode(wxGrid.wxGridSelectRows)

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

    def SetTableRecord(self, table, record):
        self.table.SetTable(table, record)
1	# Copyright (c) 2001, 2002, 2003 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
9	"""Common Thuban specific control widgets"""
10
11	__version__ = "$Revision$"
12
13	from wxPython.wx import wxListCtrl, wxLC_REPORT, wxLIST_AUTOSIZE_USEHEADER, \
14	EVT_LIST_ITEM_SELECTED, true, false
15	from wxPython.grid import wxPyGridTableBase, wxGrid, wxGRID_VALUE_STRING, \
16	wxGridTableMessage, wxGRIDTABLE_NOTIFY_ROWS_APPENDED, \
17	wxGRIDTABLE_NOTIFY_ROWS_DELETED, wxGRIDTABLE_REQUEST_VIEW_GET_VALUES
18
19	from Thuban import _
20
21	# FIXME: the wx_value_type_map should be moved from tableview to a
22	# separate module
23	from tableview import wx_value_type_map
24
25
26
27	class RecordListCtrl(wxListCtrl):
28
29	"""List Control showing a single record from a thuban table"""
30
31	def __init__(self, parent, id):
32	wxListCtrl.__init__(self, parent, id, style = wxLC_REPORT)
33
34	self.InsertColumn(0, _("Field"))
35	self.SetColumnWidth(0, 200)
36	self.InsertColumn(1, _("Value"))
37	self.SetColumnWidth(1, 100)
38
39	# vaues maps row numbers to the corresponding python values
40	self.values = {}
41
42	def fill_list(self, table, shape):
43	"""Fill self with the contents shape's record from table"""
44	self.DeleteAllItems()
45	values = {}
46
47	if shape is not None:
48	names = []
49	for col in table.Columns():
50	names.append(col.name)
51	record = table.ReadRowAsDict(shape)
52
53	for i in range(len(names)):
54	name = names[i]
55	value = record[name]
56	self.InsertStringItem(i, name)
57	self.SetStringItem(i, 1, str(value))
58	values[i] = value
59
60	self.values = values
61
62	class SelectableRecordListCtrl(RecordListCtrl):
63
64	def __init__(self, parent, id):
65	RecordListCtrl.__init__(self, parent, id)
66
67	# selected is the index of the selected record or -1 if none is
68	# selected
69	self.selected = -1
70	EVT_LIST_ITEM_SELECTED(self, self.GetId(), self.OnItemSelected)
71
72	def OnItemSelected(self, event):
73	"""Event handler. Update the selected instvar"""
74	self.selected = event.m_itemIndex
75
76	def GetValue(self):
77	"""Return the currently selected value. None if no value is selected"""
78	if self.selected >= 0:
79	return self.values[self.selected]
80	else:
81	return None
82
83
84	class RecordTable(wxPyGridTableBase):
85
86	"""Wrapper that makes a Thuban table record look like a table for a
87	wxGrid
88	"""
89
90	def __init__(self, table = None, record = None):
91	wxPyGridTableBase.__init__(self)
92	self.num_cols = 1
93	self.num_rows = 0
94	self.table = None
95	self.record_index = record
96	self.record = None
97	self.SetTable(table, record)
98
99	def SetTable(self, table, record_index):
100	old_num_rows = self.num_rows
101	if record_index is not None:
102	self.table = table
103	self.record_index = record_index
104	self.record = table.ReadRowAsDict(record_index)
105
106	# we have one row for each field in the table
107	self.num_rows = table.NumColumns()
108
109	# extract the field types and names of the row we're showing.
110	self.rows = []
111	for i in range(self.num_rows):
112	col = table.Column(i)
113	self.rows.append((col.name, wx_value_type_map[col.type]))
114	self.notify_get_values()
115	else:
116	# make the grid empty
117	self.num_rows = 0
118	self.rows = []
119
120	# notify the views if the number of rows has changed
121	if self.num_rows > old_num_rows:
122	self.notify_append_rows(self.num_rows - old_num_rows)
123	elif self.num_rows < old_num_rows:
124	self.notify_delete_rows(0, old_num_rows - self.num_rows)
125
126	def notify_append_rows(self, num):
127	"""Tell the view that num rows were appended"""
128	self.send_view_message(wxGRIDTABLE_NOTIFY_ROWS_APPENDED, num)
129
130	def notify_delete_rows(self, start, num):
131	"""Tell the view that num rows were deleted starting at start"""
132	self.send_view_message(wxGRIDTABLE_NOTIFY_ROWS_DELETED, start, num)
133
134	def notify_get_values(self):
135	"""Tell the view that the grid's values have to be updated"""
136	self.send_view_message(wxGRIDTABLE_REQUEST_VIEW_GET_VALUES)
137
138	def send_view_message(self, msgid, *args):
139	"""Send the message msgid to the view with arguments args"""
140	view = self.GetView()
141	if view:
142	#print "send_view_message", msgid, args
143	msg = apply(wxGridTableMessage, (self, msgid) + args)
144	view.ProcessTableMessage(msg)
145
146	#
147	# required methods for the wxPyGridTableBase interface
148	#
149
150	def GetNumberRows(self):
151	return self.num_rows
152
153	def GetNumberCols(self):
154	return self.num_cols
155
156	def IsEmptyCell(self, row, col):
157	return row >= self.num_rows or col >= self.num_cols
158
159	# Get/Set values in the table. The Python version of these
160	# methods can handle any data-type, (as long as the Editor and
161	# Renderer understands the type too,) not just strings as in the
162	# C++ version.
163	def GetValue(self, row, col):
164	if row < self.num_rows:
165	return self.record[self.rows[row][0]]
166	return ""
167
168	def SetValue(self, row, col, value):
169	if row < self.num_rows:
170	name = self.rows[row][0]
171	self.record[name] = value
172	self.table.write_record(self.record_index, {name: value})
173
174	#
175	# Some optional methods
176	#
177
178	# Called when the grid needs to display labels
179	def GetColLabelValue(self, col):
180	return _("Value")
181
182	def GetRowLabelValue(self, row):
183	if row < self.num_rows:
184	return self.rows[row][0]
185	return ""
186
187	# Called to determine the kind of editor/renderer to use by
188	# default, doesn't necessarily have to be the same type used
189	# nativly by the editor/renderer if they know how to convert.
190	def GetTypeName(self, row, col):
191	# for some reason row and col may be negative sometimes, but
192	# it's probably a wx bug (filed as #593189 on sourceforge)
193	if 0 <= row < self.num_rows:
194	return self.rows[row][1]
195	return wxGRID_VALUE_STRING
196
197	# Called to determine how the data can be fetched and stored by the
198	# editor and renderer. This allows you to enforce some type-safety
199	# in the grid.
200	def CanGetValueAs(self, row, col, typeName):
201	# perhaps we should allow conversion int->double?
202	return self.GetTypeName(row, col) == typeName
203
204	def CanSetValueAs(self, row, col, typeName):
205	return self.CanGetValueAs(row, col, typeName)
206
207
208
209	class RecordGridCtrl(wxGrid):
210
211	"""Grid view for a RecordTable"""
212
213	def __init__(self, parent, table = None, record = None):
214	wxGrid.__init__(self, parent, -1)
215
216	self.table = RecordTable(table, record)
217
218	# The second parameter means that the grid is to take ownership
219	# of the table and will destroy it when done. Otherwise you
220	# would need to keep a reference to it and call it's Destroy
221	# method later.
222	self.SetTable(self.table, true)
223
224	#self.SetMargins(0,0)
225	self.AutoSizeColumn(0, true)
226
227	#self.SetSelectionMode(wxGrid.wxGridSelectRows)
228
229	#EVT_GRID_RANGE_SELECT(self, self.OnRangeSelect)
230	#EVT_GRID_SELECT_CELL(self, self.OnSelectCell)
231
232	def SetTableRecord(self, table, record):
233	self.table.SetTable(table, record)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision