This time I am attempting to get familiar with gtk-sharp/Gtk's version of a grid view - the Gtk.TreeView object. Some of the gtk-sharp documentation suggests the NodeView object would be easier to use. I had some trouble instantiating the objects associated with the NodeView and went with the TreeView instead in the hopes of getting more control.
The Windows.Forms GridView I did years ago is here. It became apparent to me shortly after embarking on this journey that I would be hard pressed to recreate all the functionality of that script in a timely manner. I settled for a tabular view of drillhole data (fabricated, mock data) with some custom formatting.
Aside: this is typically how mineral exploration drillhole data (core, reverse circulation drilling) is presented in tabular format - a series of from-to intervals with assay values. Assuming the assays are all separate elements, the reported weight percents should not sum more than 100%, and never do unless someone fat fingers a decimal place. I've projected a couple screaming hot polymetallic drill holes that end near surface (lack of funding for drilling), but show enough promise that the new mining town of Trachteville (the drill hole name CBT-BNZA stands for CBT-Bonanza) will spring up there at any moment . . . one can dream.
The data store object for the grid view Gtk.ListStore object would not instantiate in IronPython. I was not the only person to have experienced this problem (I cannot locate the link to the mailing list thread or forum reference, but like the big fish that got away, I swear I saw it). I didn't want to drop the effort just because of that, so I hacked and compiled some C# code:
public class storex
{
public Gtk.ListStore drillhole =
// 7 columns
// drillhole id
new Gtk.ListStore (typeof (string),
// from
typeof (double),
// to
typeof (double),
// assay1
typeof (double),
// assay2
typeof (double),
// assay3
typeof (double),
// assay4
typeof (double));
}
The mono command on Windows was
C:\UserPrograms\Mono-3.2.3>mcs -pkg:gtk-sharp-2.0 /target:library C:\UserPrograms\IronPythonGUI\storex.cs
Those are my file paths; locations depend on where you install things like mono and IronPython.
Anyway, I got my dll and I was off to the races. Getting to know the Gtk and gtk-sharp object model proved challenging for me. I'm glad I got some familiarity with it, but it would take me longer to do something in Gtk than it did with Windows.Forms. The most fun and gratifying part of the project was getting the custom formatting to work with a Gtk.TreeCellDataFunc. I used a function that yielded specific functions for each column - something that's really easy to do in Python.
Anyway, here are a couple screenshots and the IronPython code:
The OpenBSD one below turned out pretty good, but the Windows one had a little double line underneath the first row - it looked as though it was still trying to select that row when I told it specifically not to. I'm not a design perfectionist Steve Jobs type, but niggling nits like that drive me batty. For now, though it's best I publish the code and move on.
#!/usr/local/bin/mono /home/carl/IronPython-2.7.4/ipy64.exe
import clr
GTKSHARP = 'gtk-sharp'
PANGO = 'pango-sharp'
# Mock store C#
STOREX = 'storex'
clr.AddReference(GTKSHARP)
clr.AddReference(PANGO)
# C# module compiled for this project.
# Problems with Gtk.ListStore in IronPython.
clr.AddReference(STOREX)
import Gtk
import Pango
import storex
TITLE = 'Gtk.TreeView Demo (Drillholes)'
MARKUP = '<span font="Courier New" size="14" weight="bold">{:s}</span>'
MARKEDUPTITLE = MARKUP.format(TITLE)
CENTERED = 0.5
RIGHT = 1.0
WINDOWWIDTH = 350
COURFONTREGULAR = 'Courier New 12'
COURFONTBOLD = 'Courier New Bold 12'
DHNAME = 'DH_CBTBNZA-{:>02d}'
DHNAMELABEL = 'drillhole'
FROM = 'from'
TO = 'to'
ASSAY1 = 'assay1'
ASSAY2 = 'assay2'
ASSAY3 = 'assay3'
ASSAY4 = 'assay4'
FP1FMT = '{:>5.1f}'
FP2FMT = '{:>4.2f}'
DHDATAX = {(DHNAME.format(1), 0.0):{TO:8.7,
ASSAY1:22.27,
ASSAY2:4.93,
ASSAY3:18.75,
ASSAY4:35.18},
(DHNAME.format(1), 8.7):{TO:15.3,
ASSAY1:0.27,
ASSAY2:0.09,
ASSAY3:0.03,
ASSAY4:0.22},
(DHNAME.format(1), 15.3):{TO:25.3,
ASSAY1:2.56,
ASSAY2:11.34,
ASSAY3:0.19,
ASSAY4:13.46},
(DHNAME.format(2), 0.0):{TO:10.0,
ASSAY1:0.07,
ASSAY2:1.23,
ASSAY3:4.78,
ASSAY4:5.13},
(DHNAME.format(2), 10.0):{TO:20.0,
ASSAY1:44.88,
ASSAY2:12.97,
ASSAY3:0.19,
ASSAY4:0.03}}
FIELDS = [DHNAMELABEL, FROM, TO, ASSAY1, ASSAY2, ASSAY3, ASSAY4]
BOLDEDCOLUMNS = [DHNAMELABEL, FROM, TO]
NONKEYFIELDS = FIELDS[2:]
BLAZINGCUTOFF = 10.0
def genericfloatformat(floatfmt, index):
"""
For cell formatting in Gtk.TreeView.
Returns a function to format floats
and to format floats' foreground color
based on cutoff value.
floatfmt is a format string.
index is an int that indicates the
column being formatted.
"""
def setfloatfmt(treeviewcolumn, cellrenderer, treemodel, treeiter):
cellrenderer.Text = floatfmt.format(treemodel.GetValue(treeiter, index))
# If it is one of the assay value columns.
# XXX - not generic.
if index > 2:
if treemodel.GetValue(treeiter, index) > BLAZINGCUTOFF:
cellrenderer.Foreground = 'red'
else:
cellrenderer.Foreground = 'black'
return Gtk.TreeCellDataFunc(setfloatfmt)
class TreeViewTest(object):
def __init__(self):
Gtk.Application.Init()
self.window = Gtk.Window('')
# DeleteEvent - copied from Gtk demo on internet.
self.window.DeleteEvent += self.DeleteEvent
# Frame property provides a frame and title.
self.frame = Gtk.Frame(MARKEDUPTITLE)
self.tree = Gtk.TreeView()
self.tree.EnableGridLines = Gtk.TreeViewGridLines.Both
self.frame.Add(self.tree)
# Fonts for formatting.
self.fdregular = Pango.FontDescription.FromString(COURFONTREGULAR)
self.fdbold = Pango.FontDescription.FromString(COURFONTBOLD)
# C# module
self.store = storex().drillhole
self.makecolumns()
self.adddata()
self.tree.Model = self.store
self.formatcolumns()
self.formatcells()
self.prettyup()
self.window.Add(self.frame)
self.window.ShowAll()
# Keep text viewable - size no smaller than intended.
self.window.AllowShrink = False
# XXX - hack to keep lack of gridlines on edges of
# table from showing.
self.window.AllowGrow = False
# Unselect everything for this demo.
self.tree.Selection.UnselectAll()
Gtk.Application.Run()
def makecolumns(self):
"""
Fill in columns for TreeView.
"""
self.columns = {}
for fieldx in FIELDS:
self.columns[fieldx] = Gtk.TreeViewColumn()
self.columns[fieldx].Title = fieldx
self.tree.AppendColumn(self.columns[fieldx])
def formatcolumns(self):
"""
Make custom labels for columnn headers.
Get each column properly justified (all
are right justified,floating point numbers
except for the drillhole 'number' -
actually a string).
"""
self.customlabels = {}
for fieldx in FIELDS:
# This centers the labels at the top.
self.columns[fieldx].Alignment = CENTERED
self.customlabels[fieldx] = Gtk.Label(self.columns[fieldx].Title)
self.customlabels[fieldx].ModifyFont(self.fdbold)
# 120 is about right for from, to, and assay columns.
self.columns[fieldx].MinWidth = 120
self.customlabels[fieldx].ShowAll()
self.columns[fieldx].Widget = self.customlabels[fieldx]
# ShowAll required for new label to take.
self.columns[fieldx].Widget.ShowAll()
def formatcells(self):
"""
Add and format cell renderers.
"""
self.cellrenderers = {}
for fieldx in FIELDS:
self.cellrenderers[fieldx] = Gtk.CellRendererText()
self.columns[fieldx].PackStart(self.cellrenderers[fieldx], True)
# Drillhole 'number' (string)
if fieldx == FIELDS[0]:
self.cellrenderers[fieldx].Xalign = CENTERED
self.columns[fieldx].AddAttribute(self.cellrenderers[fieldx],
'text', 0)
else:
self.cellrenderers[fieldx].Xalign = RIGHT
try:
self.columns[fieldx].AddAttribute(self.cellrenderers[fieldx],
'text', FIELDS.index(fieldx))
except ValueError:
print('\n\nProblem with field definitions; field not found.\n\n')
for fieldx in BOLDEDCOLUMNS:
self.cellrenderers[fieldx].Font = COURFONTBOLD
self.columns[fieldx].Widget.ShowAll()
# XXX - not very generic, but better than doing them one by one.
# from, to columns.
for x in xrange(1, 3):
self.columns[FIELDS[x]].SetCellDataFunc(self.cellrenderers[FIELDS[x]],
genericfloatformat(FP1FMT, x))
# assay<x> columns.
for x in xrange(3, 7):
self.columns[FIELDS[x]].SetCellDataFunc(self.cellrenderers[FIELDS[x]],
genericfloatformat(FP2FMT, x))
def usemarkup(self):
"""
Refreshes UseMarkup property on widgets (labels)
so that they display properly and without
markup text.
"""
# Have to refresh this property each time.
self.frame.LabelWidget.UseMarkup = True
def prettyup(self):
"""
Get Gtk objects looking the way we
intended.
"""
# Try to get Courier New on treeview.
self.tree.ModifyFont(self.fdregular)
# Get rid of line.
self.frame.Shadow = Gtk.ShadowType.None
self.usemarkup()
def adddata(self):
"""
Put data into store.
"""
# XXX - difficulty figuring out sorting
# function for TreeView. Hack it
# with dictionary here.
keytuples = [key for key in DHDATAX]
keytuples.sort()
datax = []
for tuplex in keytuples:
# XXX - side effect comprehension.
# Not great for readability,
# but compact.
[datax.append(x) for x in tuplex]
for fieldx in NONKEYFIELDS:
datax.append(DHDATAX[tuplex][fieldx])
self.store.AppendValues(*datax)
# Reinitiialize data row list.
datax = []
def DeleteEvent(self, widget, event):
Gtk.Application.Quit()
if __name__ == '__main__':
TreeViewTest()
Thanks for stopping by.
