# -*- coding: iso-8859-1 -*-
import ipipe, os, webbrowser, urllib
from IPython.core import ipapi
import wx
import wx.grid, wx.html
try:
sorted
except NameError:
from ipipe import sorted
try:
set
except:
from sets import Set as set
__all__ = ["igrid"]
help = """
igrid help
igrid help
Commands
pick (P)
Pick the whole row (object is available as "_")
pickattr (Shift-P)
Pick the attribute under the cursor
pickallattrs (Shift-C)
Pick the complete column under the cursor (i.e. the attribute under the
cursor) from all currently fetched objects. These attributes will be returned
as a list.
pickinput (I)
Pick the current row as next input line in IPython. Additionally the row is stored as "_"
pickinputattr (Shift-I)
Pick the attribute under the cursor as next input line in IPython. Additionally the row is stored as "_"
enter (E)
Enter the object under the cursor. (what this mean depends on the object
itself, i.e. how it implements iteration). This opens a new browser 'level'.
enterattr (Shift-E)
Enter the attribute under the cursor.
detail (D)
Show a detail view of the object under the cursor. This shows the name,
type, doc string and value of the object attributes (and it might show more
attributes than in the list view, depending on the object).
detailattr (Shift-D)
Show a detail view of the attribute under the cursor.
pickrows (M)
Pick multiple selected rows (M)
pickrowsattr (CTRL-M)
From multiple selected rows pick the cells matching the attribute the cursor is in (CTRL-M)
find (CTRL-F)
Find text
find_expression (CTRL-Shift-F)
Find entries matching an expression
find_next (F3)
Find next occurrence
find_previous (Shift-F3)
Find previous occurrence
sortattrasc (V)
Sort the objects (in ascending order) using the attribute under the cursor as the sort key.
sortattrdesc (Shift-V)
Sort the objects (in descending order) using the attribute under the cursor as the sort key.
refresh_once (R, F5)
Refreshes the display by restarting the iterator
refresh_every_second
Refreshes the display by restarting the iterator every second until stopped by stop_refresh.
refresh_interval
Refreshes the display by restarting the iterator every X ms (X is a custom interval set by the user) until stopped by stop_refresh.
stop_refresh
Stops all refresh timers.
leave (Backspace, DEL, X)
Close current tab (and all the tabs to the right of the current one).
quit (ESC,Q)
Quit igrid and return to the IPython prompt.
Navigation
Jump to the last column of the current row (END, CTRL-E, CTRL-Right)
Jump to the first column of the current row (HOME, CTRL-A, CTRL-Left)
Move the cursor one column to the left (<)
Move the cursor one column to the right (>)
Jump to the first row in the current column (CTRL-Up)
Jump to the last row in the current column (CTRL-Down)
"""
class IGridRenderer(wx.grid.PyGridCellRenderer):
"""
This is a custom renderer for our IGridGrid
"""
def __init__(self, table):
self.maxchars = 200
self.table = table
self.colormap = (
( 0, 0, 0),
(174, 0, 0),
( 0, 174, 0),
(174, 174, 0),
( 0, 0, 174),
(174, 0, 174),
( 0, 174, 174),
( 64, 64, 64)
)
wx.grid.PyGridCellRenderer.__init__(self)
def _getvalue(self, row, col):
try:
value = self.table._displayattrs[col].value(self.table.items[row])
(align, width, text) = ipipe.xformat(value, "cell", self.maxchars)
except Exception as exc:
(align, width, text) = ipipe.xformat(exc, "cell", self.maxchars)
return (align, text)
def GetBestSize(self, grid, attr, dc, row, col):
text = grid.GetCellValue(row, col)
(align, text) = self._getvalue(row, col)
dc.SetFont(attr.GetFont())
(w, h) = dc.GetTextExtent(str(text))
return wx.Size(min(w+2, 600), h+2) # add border
def Draw(self, grid, attr, dc, rect, row, col, isSelected):
"""
Takes care of drawing everything in the cell; aligns the text
"""
text = grid.GetCellValue(row, col)
(align, text) = self._getvalue(row, col)
if isSelected:
bg = grid.GetSelectionBackground()
else:
bg = ["white", (240, 240, 240)][row%2]
dc.SetTextBackground(bg)
dc.SetBrush(wx.Brush(bg, wx.SOLID))
dc.SetPen(wx.TRANSPARENT_PEN)
dc.SetFont(attr.GetFont())
dc.DrawRectangleRect(rect)
dc.SetClippingRect(rect)
# Format the text
if align == -1: # left alignment
(width, height) = dc.GetTextExtent(str(text))
x = rect[0]+1
y = rect[1]+0.5*(rect[3]-height)
for (style, part) in text:
if isSelected:
fg = grid.GetSelectionForeground()
else:
fg = self.colormap[style.fg]
dc.SetTextForeground(fg)
(w, h) = dc.GetTextExtent(part)
dc.DrawText(part, x, y)
x += w
elif align == 0: # center alignment
(width, height) = dc.GetTextExtent(str(text))
x = rect[0]+0.5*(rect[2]-width)
y = rect[1]+0.5*(rect[3]-height)
for (style, part) in text:
if isSelected:
fg = grid.GetSelectionForeground()
else:
fg = self.colormap[style.fg]
dc.SetTextForeground(fg)
(w, h) = dc.GetTextExtent(part)
dc.DrawText(part, x, y)
x += w
else: # right alignment
(width, height) = dc.GetTextExtent(str(text))
x = rect[0]+rect[2]-1
y = rect[1]+0.5*(rect[3]-height)
for (style, part) in reversed(text):
(w, h) = dc.GetTextExtent(part)
x -= w
if isSelected:
fg = grid.GetSelectionForeground()
else:
fg = self.colormap[style.fg]
dc.SetTextForeground(fg)
dc.DrawText(part, x, y)
dc.DestroyClippingRegion()
def Clone(self):
return IGridRenderer(self.table)
class IGridTable(wx.grid.PyGridTableBase):
# The data table for the ``IGridGrid``. Some dirty tricks were used here:
# ``GetValue()`` does not get any values (or at least it does not return
# anything, accessing the values is done by the renderer)
# but rather tries to fetch the objects which were requested into the table.
# General behaviour is: Fetch the first X objects. If the user scrolls down
# to the last object another bunch of X objects is fetched (if possible)
def __init__(self, input, fontsize, *attrs):
wx.grid.PyGridTableBase.__init__(self)
self.input = input
self.iterator = ipipe.xiter(input)
self.items = []
self.attrs = [ipipe.upgradexattr(attr) for attr in attrs]
self._displayattrs = self.attrs[:]
self._displayattrset = set(self.attrs)
self.fontsize = fontsize
self._fetch(1)
self.timer = wx.Timer()
self.timer.Bind(wx.EVT_TIMER, self.refresh_content)
def GetAttr(self, *args):
attr = wx.grid.GridCellAttr()
attr.SetFont(wx.Font(self.fontsize, wx.TELETYPE, wx.NORMAL, wx.NORMAL))
return attr
def GetNumberRows(self):
return len(self.items)
def GetNumberCols(self):
return len(self._displayattrs)
def GetColLabelValue(self, col):
if col < len(self._displayattrs):
return self._displayattrs[col].name()
else:
return ""
def GetRowLabelValue(self, row):
return str(row)
def IsEmptyCell(self, row, col):
return False
def _append(self, item):
self.items.append(item)
# Nothing to do if the set of attributes has been fixed by the user
if not self.attrs:
for attr in ipipe.xattrs(item):
attr = ipipe.upgradexattr(attr)
if attr not in self._displayattrset:
self._displayattrs.append(attr)
self._displayattrset.add(attr)
def _fetch(self, count):
# Try to fill ``self.items`` with at least ``count`` objects.
have = len(self.items)
while self.iterator is not None and have < count:
try:
item = self.iterator.next()
except StopIteration:
self.iterator = None
break
except (KeyboardInterrupt, SystemExit):
raise
except Exception as exc:
have += 1
self._append(exc)
self.iterator = None
break
else:
have += 1
self._append(item)
def GetValue(self, row, col):
# some kind of dummy-function: does not return anything but "";
# (The value isn't use anyway)
# its main task is to trigger the fetch of new objects
sizing_needed = False
had_cols = len(self._displayattrs)
had_rows = len(self.items)
if row == had_rows - 1 and self.iterator is not None:
self._fetch(row + 20)
sizing_needed = True
have_rows = len(self.items)
have_cols = len(self._displayattrs)
if have_rows > had_rows:
msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED, have_rows - had_rows)
self.GetView().ProcessTableMessage(msg)
sizing_needed = True
if row >= have_rows:
return ""
if have_cols != had_cols:
msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_COLS_APPENDED, have_cols - had_cols)
self.GetView().ProcessTableMessage(msg)
sizing_needed = True
if sizing_needed:
self.GetView().AutoSizeColumns(False)
return ""
def SetValue(self, row, col, value):
pass
def refresh_content(self, event):
msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_DELETED, 0, self.GetNumberRows())
self.GetView().ProcessTableMessage(msg)
self.iterator = ipipe.xiter(self.input)
self.items = []
self.attrs = [] # _append will calculate new displayattrs
self._fetch(1) # fetch one...
if self.items:
msg = wx.grid.GridTableMessage(self, wx.grid.GRIDTABLE_NOTIFY_ROWS_APPENDED, 1)
self.GetView().ProcessTableMessage(msg)
self.GetValue(0, 0) # and trigger "fetch next 20"
item = self.items[0]
self.GetView().AutoSizeColumns(False)
panel = self.GetView().GetParent()
nb = panel.GetParent()
current = nb.GetSelection()
if nb.GetPage(current) == panel:
self.GetView().set_footer(item)
class IGridGrid(wx.grid.Grid):
# The actual grid
# all methods for selecting/sorting/picking/... data are implemented here
def __init__(self, panel, input, *attrs):
wx.grid.Grid.__init__(self, panel)
fontsize = 9
self.input = input
self.table = IGridTable(self.input, fontsize, *attrs)
self.SetTable(self.table, True)
self.SetSelectionMode(wx.grid.Grid.wxGridSelectRows)
self.SetDefaultRenderer(IGridRenderer(self.table))
self.EnableEditing(False)
self.Bind(wx.EVT_KEY_DOWN, self.key_pressed)
self.Bind(wx.grid.EVT_GRID_CELL_LEFT_DCLICK, self.cell_doubleclicked)
self.Bind(wx.grid.EVT_GRID_CELL_LEFT_CLICK, self.cell_leftclicked)
self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_DCLICK, self.label_doubleclicked)
self.Bind(wx.grid.EVT_GRID_LABEL_LEFT_CLICK, self.on_label_leftclick)
self.Bind(wx.grid.EVT_GRID_RANGE_SELECT, self._on_selected_range)
self.Bind(wx.grid.EVT_GRID_SELECT_CELL, self._on_selected_cell)
self.current_selection = set()
self.maxchars = 200
def on_label_leftclick(self, event):
event.Skip()
def error_output(self, text):
wx.Bell()
frame = self.GetParent().GetParent().GetParent()
frame.SetStatusText(str(text))
def _on_selected_range(self, event):
# Internal update to the selection tracking lists
if event.Selecting():
# adding to the list...
self.current_selection.update(xrange(event.GetTopRow(), event.GetBottomRow()+1))
else:
# removal from list
for index in xrange(event.GetTopRow(), event.GetBottomRow()+1):
self.current_selection.discard(index)
event.Skip()
def _on_selected_cell(self, event):
# Internal update to the selection tracking list
self.current_selection = set([event.GetRow()])
event.Skip()
def sort(self, key, reverse=False):
"""
Sort the current list of items using the key function ``key``. If
``reverse`` is true the sort order is reversed.
"""
row = self.GetGridCursorRow()
col = self.GetGridCursorCol()
curitem = self.table.items[row] # Remember where the cursor is now
# Sort items
def realkey(item):
try:
return key(item)
except (KeyboardInterrupt, SystemExit):
raise
except Exception:
return None
try:
self.table.items = ipipe.deque(sorted(self.table.items, key=realkey, reverse=reverse))
except TypeError as exc:
self.error_output("Exception encountered: %s" % exc)
return
# Find out where the object under the cursor went
for (i, item) in enumerate(self.table.items):
if item is curitem:
self.SetGridCursor(i,col)
self.MakeCellVisible(i,col)
self.Refresh()
def sortattrasc(self):
"""
Sort in ascending order; sorting criteria is the current attribute
"""
col = self.GetGridCursorCol()
attr = self.table._displayattrs[col]
frame = self.GetParent().GetParent().GetParent()
if attr is ipipe.noitem:
self.error_output("no column under cursor")
return
frame.SetStatusText("sort by %s (ascending)" % attr.name())
def key(item):
try:
return attr.value(item)
except (KeyboardInterrupt, SystemExit):
raise
except Exception:
return None
self.sort(key)
def sortattrdesc(self):
"""
Sort in descending order; sorting criteria is the current attribute
"""
col = self.GetGridCursorCol()
attr = self.table._displayattrs[col]
frame = self.GetParent().GetParent().GetParent()
if attr is ipipe.noitem:
self.error_output("no column under cursor")
return
frame.SetStatusText("sort by %s (descending)" % attr.name())
def key(item):
try:
return attr.value(item)
except (KeyboardInterrupt, SystemExit):
raise
except Exception:
return None
self.sort(key, reverse=True)
def label_doubleclicked(self, event):
row = event.GetRow()
col = event.GetCol()
if col == -1:
self.enter(row)
def _getvalue(self, row, col):
"""
Gets the text which is displayed at ``(row, col)``
"""
try:
value = self.table._displayattrs[col].value(self.table.items[row])
(align, width, text) = ipipe.xformat(value, "cell", self.maxchars)
except IndexError:
raise IndexError
except Exception as exc:
(align, width, text) = ipipe.xformat(exc, "cell", self.maxchars)
return text
def searchexpression(self, searchexp, startrow=None, search_forward=True ):
"""
Find by expression
"""
frame = self.GetParent().GetParent().GetParent()
if searchexp:
if search_forward:
if not startrow:
row = self.GetGridCursorRow()+1
else:
row = startrow + 1
while True:
try:
foo = self.table.GetValue(row, 0)
item = self.table.items[row]
try:
globals = ipipe.getglobals(None)
if eval(searchexp, globals, ipipe.AttrNamespace(item)):
self.SetGridCursor(row, 0) # found something
self.MakeCellVisible(row, 0)
break
except (KeyboardInterrupt, SystemExit):
raise
except Exception as exc:
frame.SetStatusText(str(exc))
wx.Bell()
break # break on error
except IndexError:
return
row += 1
else:
if not startrow:
row = self.GetGridCursorRow() - 1
else:
row = startrow - 1
while True:
try:
foo = self.table.GetValue(row, 0)
item = self.table.items[row]
try:
globals = ipipe.getglobals(None)
if eval(searchexp, globals, ipipe.AttrNamespace(item)):
self.SetGridCursor(row, 0) # found something
self.MakeCellVisible(row, 0)
break
except (KeyboardInterrupt, SystemExit):
raise
except Exception as exc:
frame.SetStatusText(str(exc))
wx.Bell()
break # break on error
except IndexError:
return
row -= 1
def search(self, searchtext, startrow=None, startcol=None, search_forward=True):
"""
search for ``searchtext``, starting in ``(startrow, startcol)``;
if ``search_forward`` is true the direction is "forward"
"""
searchtext = searchtext.lower()
if search_forward:
if startrow is not None and startcol is not None:
row = startrow
else:
startcol = self.GetGridCursorCol() + 1
row = self.GetGridCursorRow()
if startcol >= self.GetNumberCols():
startcol = 0
row += 1
while True:
for col in xrange(startcol, self.table.GetNumberCols()):
try:
foo = self.table.GetValue(row, col)
text = self._getvalue(row, col)
if searchtext in text.string().lower():
self.SetGridCursor(row, col)
self.MakeCellVisible(row, col)
return
except IndexError:
return
startcol = 0
row += 1
else:
if startrow is not None and startcol is not None:
row = startrow
else:
startcol = self.GetGridCursorCol() - 1
row = self.GetGridCursorRow()
if startcol < 0:
startcol = self.GetNumberCols() - 1
row -= 1
while True:
for col in xrange(startcol, -1, -1):
try:
foo = self.table.GetValue(row, col)
text = self._getvalue(row, col)
if searchtext in text.string().lower():
self.SetGridCursor(row, col)
self.MakeCellVisible(row, col)
return
except IndexError:
return
startcol = self.table.GetNumberCols()-1
row -= 1
def key_pressed(self, event):
"""
Maps pressed keys to functions
"""
frame = self.GetParent().GetParent().GetParent()
frame.SetStatusText("")
sh = event.ShiftDown()
ctrl = event.ControlDown()
keycode = event.GetKeyCode()
if keycode == ord("P"):
row = self.GetGridCursorRow()
if sh:
col = self.GetGridCursorCol()
self.pickattr(row, col)
else:
self.pick(row)
elif keycode == ord("M"):
if ctrl:
col = self.GetGridCursorCol()
self.pickrowsattr(sorted(self.current_selection), col)
else:
self.pickrows(sorted(self.current_selection))
elif keycode in (wx.WXK_BACK, wx.WXK_DELETE, ord("X")) and not (ctrl or sh):
self.delete_current_notebook()
elif keycode in (ord("E"), ord("\r")):
row = self.GetGridCursorRow()
if sh:
col = self.GetGridCursorCol()
self.enterattr(row, col)
else:
self.enter(row)
elif keycode == ord("E") and ctrl:
row = self.GetGridCursorRow()
self.SetGridCursor(row, self.GetNumberCols()-1)
elif keycode == wx.WXK_HOME or (keycode == ord("A") and ctrl):
row = self.GetGridCursorRow()
self.SetGridCursor(row, 0)
elif keycode == ord("C") and sh:
col = self.GetGridCursorCol()
attr = self.table._displayattrs[col]
result = []
for i in xrange(self.GetNumberRows()):
result.append(self.table._displayattrs[col].value(self.table.items[i]))
self.quit(result)
elif keycode in (wx.WXK_ESCAPE, ord("Q")) and not (ctrl or sh):
self.quit()
elif keycode == ord("<"):
row = self.GetGridCursorRow()
col = self.GetGridCursorCol()
if not event.ShiftDown():
newcol = col - 1
if newcol >= 0:
self.SetGridCursor(row, col - 1)
else:
newcol = col + 1
if newcol < self.GetNumberCols():
self.SetGridCursor(row, col + 1)
elif keycode == ord("D"):
col = self.GetGridCursorCol()
row = self.GetGridCursorRow()
if not sh:
self.detail(row, col)
else:
self.detail_attr(row, col)
elif keycode == ord("F") and ctrl:
if sh:
frame.enter_searchexpression(event)
else:
frame.enter_searchtext(event)
elif keycode == wx.WXK_F3:
if sh:
frame.find_previous(event)
else:
frame.find_next(event)
elif keycode == ord("V"):
if sh:
self.sortattrdesc()
else:
self.sortattrasc()
elif keycode == wx.WXK_DOWN:
row = self.GetGridCursorRow()
try:
item = self.table.items[row+1]
except IndexError:
item = self.table.items[row]
self.set_footer(item)
event.Skip()
elif keycode == wx.WXK_UP:
row = self.GetGridCursorRow()
if row >= 1:
item = self.table.items[row-1]
else:
item = self.table.items[row]
self.set_footer(item)
event.Skip()
elif keycode == wx.WXK_RIGHT:
row = self.GetGridCursorRow()
item = self.table.items[row]
self.set_footer(item)
event.Skip()
elif keycode == wx.WXK_LEFT:
row = self.GetGridCursorRow()
item = self.table.items[row]
self.set_footer(item)
event.Skip()
elif keycode == ord("R") or keycode == wx.WXK_F5:
self.table.refresh_content(event)
elif keycode == ord("I"):
row = self.GetGridCursorRow()
if not sh:
self.pickinput(row)
else:
col = self.GetGridCursorCol()
self.pickinputattr(row, col)
else:
event.Skip()
def delete_current_notebook(self):
"""
deletes the current notebook tab
"""
panel = self.GetParent()
nb = panel.GetParent()
current = nb.GetSelection()
count = nb.GetPageCount()
if count > 1:
for i in xrange(count-1, current-1, -1):
nb.DeletePage(i)
nb.GetCurrentPage().grid.SetFocus()
else:
frame = nb.GetParent()
frame.SetStatusText("This is the last level!")
def _doenter(self, value, *attrs):
"""
"enter" a special item resulting in a new notebook tab
"""
panel = self.GetParent()
nb = panel.GetParent()
frame = nb.GetParent()
current = nb.GetSelection()
count = nb.GetPageCount()
try: # if we want to enter something non-iterable, e.g. a function
if current + 1 == count and value is not self.input: # we have an event in the last tab
frame._add_notebook(value, *attrs)
elif value != self.input: # we have to delete all tabs newer than [panel] first
for i in xrange(count-1, current, -1): # some tabs don't close if we don't close in *reverse* order
nb.DeletePage(i)
frame._add_notebook(value)
except TypeError as exc:
if exc.__class__.__module__ == "exceptions":
msg = "%s: %s" % (exc.__class__.__name__, exc)
else:
msg = "%s.%s: %s" % (exc.__class__.__module__, exc.__class__.__name__, exc)
frame.SetStatusText(msg)
def enterattr(self, row, col):
try:
attr = self.table._displayattrs[col]
value = attr.value(self.table.items[row])
except Exception as exc:
self.error_output(str(exc))
else:
self._doenter(value)
def set_footer(self, item):
frame = self.GetParent().GetParent().GetParent()
frame.SetStatusText(" ".join([str(text) for (style, text) in ipipe.xformat(item, "footer", 20)[2]]), 0)
def enter(self, row):
try:
value = self.table.items[row]
except Exception as exc:
self.error_output(str(exc))
else:
self._doenter(value)
def detail(self, row, col):
"""
shows a detail-view of the current cell
"""
try:
attr = self.table._displayattrs[col]
item = self.table.items[row]
except Exception as exc:
self.error_output(str(exc))
else:
attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
self._doenter(attrs)
def detail_attr(self, row, col):
try:
attr = self.table._displayattrs[col]
item = attr.value(self.table.items[row])
except Exception as exc:
self.error_output(str(exc))
else:
attrs = [ipipe.AttributeDetail(item, attr) for attr in ipipe.xattrs(item, "detail")]
self._doenter(attrs)
def quit(self, result=None):
"""
quit
"""
frame = self.GetParent().GetParent().GetParent()
if frame.helpdialog:
frame.helpdialog.Destroy()
app = frame.parent
if app is not None:
app.result = result
frame.Close()
frame.Destroy()
def cell_doubleclicked(self, event):
self.enterattr(event.GetRow(), event.GetCol())
event.Skip()
def cell_leftclicked(self, event):
row = event.GetRow()
item = self.table.items[row]
self.set_footer(item)
event.Skip()
def pick(self, row):
"""
pick a single row and return to the IPython prompt
"""
try:
value = self.table.items[row]
except Exception as exc:
self.error_output(str(exc))
else:
self.quit(value)
def pickinput(self, row):
try:
value = self.table.items[row]
except Exception as exc:
self.error_output(str(exc))
else:
api = ipapi.get()
api.set_next_input(str(value))
self.quit(value)
def pickinputattr(self, row, col):
try:
attr = self.table._displayattrs[col]
value = attr.value(self.table.items[row])
except Exception as exc:
self.error_output(str(exc))
else:
api = ipapi.get()
api.set_next_input(str(value))
self.quit(value)
def pickrows(self, rows):
"""
pick multiple rows and return to the IPython prompt
"""
try:
value = [self.table.items[row] for row in rows]
except Exception as exc:
self.error_output(str(exc))
else:
self.quit(value)
def pickrowsattr(self, rows, col):
""""
pick one column from multiple rows
"""
values = []
try:
attr = self.table._displayattrs[col]
for row in rows:
try:
values.append(attr.value(self.table.items[row]))
except (SystemExit, KeyboardInterrupt):
raise
except Exception:
raise #pass
except Exception as exc:
self.error_output(str(exc))
else:
self.quit(values)
def pickattr(self, row, col):
try:
attr = self.table._displayattrs[col]
value = attr.value(self.table.items[row])
except Exception as exc:
self.error_output(str(exc))
else:
self.quit(value)
class IGridPanel(wx.Panel):
# Each IGridPanel contains an IGridGrid
def __init__(self, parent, input, *attrs):
wx.Panel.__init__(self, parent, -1)
self.grid = IGridGrid(self, input, *attrs)
self.grid.FitInside()
sizer = wx.BoxSizer(wx.VERTICAL)
sizer.Add(self.grid, proportion=1, flag=wx.EXPAND | wx.ALL, border=10)
self.SetSizer(sizer)
sizer.Fit(self)
sizer.SetSizeHints(self)
class IGridHTMLHelp(wx.Frame):
def __init__(self, parent, title, size):
wx.Frame.__init__(self, parent, -1, title, size=size)
html = wx.html.HtmlWindow(self)
if "gtk2" in wx.PlatformInfo:
html.SetStandardFonts()
html.SetPage(help)
class IGridFrame(wx.Frame):
maxtitlelen = 30
def __init__(self, parent, input):
title = " ".join([str(text) for (style, text) in ipipe.xformat(input, "header", 20)[2]])
wx.Frame.__init__(self, None, title=title, size=(640, 480))
self.menubar = wx.MenuBar()
self.menucounter = 100
self.m_help = wx.Menu()
self.m_search = wx.Menu()
self.m_sort = wx.Menu()
self.m_refresh = wx.Menu()
self.notebook = wx.Notebook(self, -1, style=0)
self.statusbar = self.CreateStatusBar(1, wx.ST_SIZEGRIP)
self.statusbar.SetFieldsCount(2)
self.SetStatusWidths([-1, 200])
self.parent = parent
self._add_notebook(input)
self.Bind(wx.EVT_CLOSE, self.OnCloseWindow)
self.makemenu(self.m_sort, "&Sort (asc)\tV", "Sort ascending", self.sortasc)
self.makemenu(self.m_sort, "Sort (&desc)\tShift-V", "Sort descending", self.sortdesc)
self.makemenu(self.m_help, "&Help\tF1", "Help", self.display_help)
# self.makemenu(self.m_help, "&Show help in browser", "Show help in browser", self.display_help_in_browser)
self.makemenu(self.m_search, "&Find text\tCTRL-F", "Find text", self.enter_searchtext)
self.makemenu(self.m_search, "Find by &expression\tCTRL-Shift-F", "Find by expression", self.enter_searchexpression)
self.makemenu(self.m_search, "Find &next\tF3", "Find next", self.find_next)
self.makemenu(self.m_search, "Find &previous\tShift-F3", "Find previous", self.find_previous)
self.makemenu(self.m_refresh, "&Refresh once \tF5", "Refresh once", self.refresh_once)
self.makemenu(self.m_refresh, "Refresh every &1s", "Refresh every second", self.refresh_every_second)
self.makemenu(self.m_refresh, "Refresh every &X seconds", "Refresh every X seconds", self.refresh_interval)
self.makemenu(self.m_refresh, "&Stop all refresh timers", "Stop refresh timers", self.stop_refresh)
self.menubar.Append(self.m_search, "&Find")
self.menubar.Append(self.m_sort, "&Sort")
self.menubar.Append(self.m_refresh, "&Refresh")
self.menubar.Append(self.m_help, "&Help")
self.SetMenuBar(self.menubar)
self.searchtext = ""
self.searchexpression = ""
self.helpdialog = None
self.refresh_interval = 1000
self.SetStatusText("Refreshing inactive", 1)
def refresh_once(self, event):
table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
table.refresh_content(event)
def refresh_interval(self, event):
table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
dlg = wx.TextEntryDialog(self, "Enter refresh interval (milliseconds):", "Refresh timer:", defaultValue=str(self.refresh_interval))
if dlg.ShowModal() == wx.ID_OK:
try:
milliseconds = int(dlg.GetValue())
except ValueError as exc:
self.SetStatusText(str(exc))
else:
table.timer.Start(milliseconds=milliseconds, oneShot=False)
self.SetStatusText("Refresh timer set to %s ms" % milliseconds)
self.SetStatusText("Refresh interval: %s ms" % milliseconds, 1)
self.refresh_interval = milliseconds
dlg.Destroy()
def stop_refresh(self, event):
for i in xrange(self.notebook.GetPageCount()):
nb = self.notebook.GetPage(i)
nb.grid.table.timer.Stop()
self.SetStatusText("Refreshing inactive", 1)
def refresh_every_second(self, event):
table = self.notebook.GetPage(self.notebook.GetSelection()).grid.table
table.timer.Start(milliseconds=1000, oneShot=False)
self.SetStatusText("Refresh interval: 1000 ms", 1)
def sortasc(self, event):
grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
grid.sortattrasc()
def sortdesc(self, event):
grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
grid.sortattrdesc()
def find_previous(self, event):
"""
find previous occurrences
"""
grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
if self.searchtext:
row = grid.GetGridCursorRow()
col = grid.GetGridCursorCol()
self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
if col-1 >= 0:
grid.search(self.searchtext, row, col-1, False)
else:
grid.search(self.searchtext, row-1, grid.table.GetNumberCols()-1, False)
elif self.searchexpression:
self.SetStatusText("Search mode: expression; looking for %s" % repr(self.searchexpression)[2:-1])
grid.searchexpression(searchexp=self.searchexpression, search_forward=False)
else:
self.SetStatusText("No search yet: please enter search-text or -expression")
def find_next(self, event):
"""
find the next occurrence
"""
grid = self.notebook.GetPage(self.notebook.GetSelection()).grid
if self.searchtext != "":
row = grid.GetGridCursorRow()
col = grid.GetGridCursorCol()
self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
if col+1 < grid.table.GetNumberCols():
grid.search(self.searchtext, row, col+1)
else:
grid.search(self.searchtext, row+1, 0)
elif self.searchexpression != "":
self.SetStatusText('Search mode: expression; looking for %s' % repr(self.searchexpression)[2:-1])
grid.searchexpression(searchexp=self.searchexpression)
else:
self.SetStatusText("No search yet: please enter search-text or -expression")
def display_help(self, event):
"""
Display a help dialog
"""
if self.helpdialog:
self.helpdialog.Destroy()
self.helpdialog = IGridHTMLHelp(None, title="Help", size=wx.Size(600,400))
self.helpdialog.Show()
def display_help_in_browser(self, event):
"""
Show the help-HTML in a browser (as a ``HtmlWindow`` does not understand
CSS this looks better)
"""
filename = urllib.pathname2url(os.path.abspath(os.path.join(os.path.dirname(__file__), "igrid_help.html")))
if not filename.startswith("file"):
filename = "file:" + filename
webbrowser.open(filename, new=1, autoraise=True)
def enter_searchexpression(self, event):
dlg = wx.TextEntryDialog(self, "Find:", "Find matching expression:", defaultValue=self.searchexpression)
if dlg.ShowModal() == wx.ID_OK:
self.searchexpression = dlg.GetValue()
self.searchtext = ""
self.SetStatusText('Search mode: expression; looking for %s' % repr(self.searchexpression)[2:-1])
self.notebook.GetPage(self.notebook.GetSelection()).grid.searchexpression(self.searchexpression)
dlg.Destroy()
def makemenu(self, menu, label, help, cmd):
menu.Append(self.menucounter, label, help)
self.Bind(wx.EVT_MENU, cmd, id=self.menucounter)
self.menucounter += 1
def _add_notebook(self, input, *attrs):
# Adds another notebook which has the starting object ``input``
panel = IGridPanel(self.notebook, input, *attrs)
text = str(ipipe.xformat(input, "header", self.maxtitlelen)[2])
if len(text) >= self.maxtitlelen:
text = text[:self.maxtitlelen].rstrip(".") + "..."
self.notebook.AddPage(panel, text, True)
panel.grid.SetFocus()
self.Layout()
def OnCloseWindow(self, event):
self.Destroy()
def enter_searchtext(self, event):
# Displays a dialog asking for the searchtext
dlg = wx.TextEntryDialog(self, "Find:", "Find in list", defaultValue=self.searchtext)
if dlg.ShowModal() == wx.ID_OK:
self.searchtext = dlg.GetValue()
self.searchexpression = ""
self.SetStatusText('Search mode: text; looking for %s' % self.searchtext)
self.notebook.GetPage(self.notebook.GetSelection()).grid.search(self.searchtext)
dlg.Destroy()
class App(wx.App):
def __init__(self, input):
self.input = input
self.result = None # Result to be returned to IPython. Set by quit().
wx.App.__init__(self)
def OnInit(self):
frame = IGridFrame(self, self.input)
frame.Show()
self.SetTopWindow(frame)
frame.Raise()
return True
class igrid(ipipe.Display):
"""
This is a wx-based display object that can be used instead of ``ibrowse``
(which is curses-based) or ``idump`` (which simply does a print).
"""
if wx.VERSION < (2, 7):
def display(self):
try:
# Try to create a "standalone" frame. If this works we're probably
# running with -wthread.
# Note that this sets the parent of the frame to None, but we can't
# pass a result object back to the shell anyway.
frame = IGridFrame(None, self.input)
frame.Show()
frame.Raise()
except wx.PyNoAppError:
# There's no wx application yet => create one.
app = App(self.input)
app.MainLoop()
return app.result
else:
# With wx 2.7 it gets simpler.
def display(self):
app = App(self.input)
app.MainLoop()
return app.result