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 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)
        import main
        main.app.interactor.Subscribe(SELECTED_SHAPE, self.select_shape)

    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:
            self.SelectRow(shape)
            self.SetGridCursor(shape, 0)
            self.MakeCellVisible(shape, 0)


class TableFrame(wxFrame):

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