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

    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	bh	77	# Copyright (c) 2001, 2002 by Intevation GmbH
2	bh	6	# 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	bh	34	from Thuban.Lib.connector import Publisher
14	bh	6	from Thuban.Model.table import FIELDTYPE_INT, FIELDTYPE_DOUBLE, \
15			FIELDTYPE_STRING
16			import view
17	bh	30	from dialogs import NonModalDialog
18	bh	6	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	bh	34	ROW_SELECTED = "ROW_SELECTED"
25
26
27	bh	6	class DataTable(wxPyGridTableBase):
28
29	bh	34	"""Wrapper around a Thuban table object suitable for a wxGrid"""
30
31	bh	6	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	bh	34	class TableGrid(wxGrid, Publisher):
99	bh	6
100	bh	34	"""A grid view for a Thuban table"""
101	bh	6
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	bh	77	# would need to keep a reference to it and call its Destroy
110	bh	6	# method later.
111			self.SetTable(self.table, true)
112
113			#self.SetMargins(0,0)
114
115	bh	173	# 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	bh	6	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	bh	34	self.issue(ROW_SELECTED, event.GetTopLeftCoords().GetRow())
132	bh	6
133			def OnSelectCell(self, event):
134	bh	34	self.issue(ROW_SELECTED, event.GetRow())
135	bh	6
136			def select_shape(self, layer, shape):
137	bh	30	if layer is not None and layer.table is self.table.table \
138			and shape is not None:
139	bh	6	self.SelectRow(shape)
140			self.SetGridCursor(shape, 0)
141			self.MakeCellVisible(shape, 0)
142
143
144	bh	30	class TableFrame(NonModalDialog):
145	bh	6
146	bh	34	"""Frame that displays a Thuban table in a grid view"""
147
148			def __init__(self, parent, interactor, name, title, layer = None,
149			table = None):
150	bh	30	NonModalDialog.__init__(self, parent, interactor, name, title)
151	bh	34	self.layer = layer
152			self.table = table
153	bh	30	self.grid = TableGrid(self, table)
154	bh	34	self.grid.Subscribe(ROW_SELECTED, self.row_selected)
155	bh	30	self.interactor.Subscribe(SELECTED_SHAPE, self.select_shape)
156
157			def OnClose(self, event):
158			self.interactor.Unsubscribe(SELECTED_SHAPE, self.select_shape)
159			NonModalDialog.OnClose(self, event)
160
161			def select_shape(self, layer, shape):
162			self.grid.select_shape(layer, shape)
163	bh	34
164			def row_selected(self, row):
165			if self.layer is not None:
166			self.interactor.SelectLayerAndShape(self.layer, row)
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision