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.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}

class DataTable(wxPyGridTableBase):

    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)


    # Thuban stuff
    def SelectRow(self, row):
        import main
        interactor = main.app.interactor
        return interactor.SelectShape(self.table, row)


class TableGrid(wxGrid):

    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():
            if not self.table.SelectRow(event.GetTopLeftCoords().GetRow()):
                event.Skip()

    def OnSelectCell(self, event):
        if not self.table.SelectRow(event.GetRow()):
            event.Skip()

    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):

    def __init__(self, parent, interactor, name, title, table = None):
        NonModalDialog.__init__(self, parent, interactor, name, title)
        self.grid = TableGrid(self, table)
        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)
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.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
14	FIELDTYPE_STRING
15	import view
16	from dialogs import NonModalDialog
17	from messages import SELECTED_SHAPE
18
19	wx_value_type_map = {FIELDTYPE_INT: wxGRID_VALUE_NUMBER,
20	FIELDTYPE_DOUBLE: wxGRID_VALUE_FLOAT,
21	FIELDTYPE_STRING: wxGRID_VALUE_STRING}
22
23	class DataTable(wxPyGridTableBase):
24
25	def __init__(self, table = None):
26	wxPyGridTableBase.__init__(self)
27	self.num_cols = 0
28	self.num_rows = 0
29	self.columns = []
30	self.table = None
31	self.SetTable(table)
32
33	def SetTable(self, table):
34	self.table = table
35	self.num_cols = table.field_count()
36	self.num_rows = table.record_count()
37
38	self.columns = []
39	for i in range(self.num_cols):
40	type, name, len, decc = table.field_info(i)
41	self.columns.append((name, wx_value_type_map[type], len, decc))
42
43	#
44	# required methods for the wxPyGridTableBase interface
45	#
46
47	def GetNumberRows(self):
48	return self.num_rows
49
50	def GetNumberCols(self):
51	return self.num_cols
52
53	def IsEmptyCell(self, row, col):
54	return 0
55
56	# Get/Set values in the table. The Python version of these
57	# methods can handle any data-type, (as long as the Editor and
58	# Renderer understands the type too,) not just strings as in the
59	# C++ version.
60	def GetValue(self, row, col):
61	record = self.table.read_record(row)
62	return record[self.columns[col][0]]
63
64	def SetValue(self, row, col, value):
65	pass
66
67	#
68	# Some optional methods
69	#
70
71	# Called when the grid needs to display labels
72	def GetColLabelValue(self, col):
73	return self.columns[col][0]
74
75	# Called to determine the kind of editor/renderer to use by
76	# default, doesn't necessarily have to be the same type used
77	# nativly by the editor/renderer if they know how to convert.
78	def GetTypeName(self, row, col):
79	return self.columns[col][1]
80
81	# Called to determine how the data can be fetched and stored by the
82	# editor and renderer. This allows you to enforce some type-safety
83	# in the grid.
84	def CanGetValueAs(self, row, col, typeName):
85	# perhaps we should allow conversion int->double?
86	return self.GetTypeName(row, col) == typeName
87
88	def CanSetValueAs(self, row, col, typeName):
89	return self.CanGetValueAs(row, col, typeName)
90
91
92	# Thuban stuff
93	def SelectRow(self, row):
94	import main
95	interactor = main.app.interactor
96	return interactor.SelectShape(self.table, row)
97
98
99	class TableGrid(wxGrid):
100
101	def __init__(self, parent, table = None):
102	wxGrid.__init__(self, parent, -1)
103
104	self.table = DataTable(table)
105
106	# The second parameter means that the grid is to take ownership
107	# of the table and will destroy it when done. Otherwise you
108	# would need to keep a reference to it and call it's Destroy
109	# method later.
110	self.SetTable(self.table, true)
111
112	#self.SetMargins(0,0)
113	self.AutoSizeColumns(false)
114
115	self.SetSelectionMode(wxGrid.wxGridSelectRows)
116
117	EVT_GRID_RANGE_SELECT(self, self.OnRangeSelect)
118	EVT_GRID_SELECT_CELL(self, self.OnSelectCell)
119
120	def SetTableObject(self, table):
121	self.table.SetTable(table)
122
123	def OnRangeSelect(self, event):
124	if event.Selecting():
125	if not self.table.SelectRow(event.GetTopLeftCoords().GetRow()):
126	event.Skip()
127
128	def OnSelectCell(self, event):
129	if not self.table.SelectRow(event.GetRow()):
130	event.Skip()
131
132	def select_shape(self, layer, shape):
133	if layer is not None and layer.table is self.table.table \
134	and shape is not None:
135	self.SelectRow(shape)
136	self.SetGridCursor(shape, 0)
137	self.MakeCellVisible(shape, 0)
138
139
140	class TableFrame(NonModalDialog):
141
142	def __init__(self, parent, interactor, name, title, table = None):
143	NonModalDialog.__init__(self, parent, interactor, name, title)
144	self.grid = TableGrid(self, table)
145	self.interactor.Subscribe(SELECTED_SHAPE, self.select_shape)
146
147	def OnClose(self, event):
148	self.interactor.Unsubscribe(SELECTED_SHAPE, self.select_shape)
149	NonModalDialog.OnClose(self, event)
150
151	def select_shape(self, layer, shape):
152	self.grid.select_shape(layer, shape)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision