visidata 2.11.1__py3-none-any.whl → 3.0.1__py3-none-any.whl

visidata/canvas.py

@@ -2,18 +2,19 @@ import math
 import random
 
 from collections import defaultdict, Counter, OrderedDict
-from visidata import *
+from visidata import vd, asyncthread, ENTER, colors, update_attr, clipdraw, dispwidth
+from visidata import BaseSheet, Column, Progress, ColorAttr
 from visidata.bezier import bezier
 
 # see www/design/graphics.md
 
-vd.option('show_graph_labels', True, 'show axes and legend on graph')
-vd.option('plot_colors', 'green red yellow cyan magenta white 38 136 168', 'list of distinct colors to use for plotting distinct objects')
-vd.option('disp_canvas_charset', ''.join(chr(0x2800+i) for i in range(256)), 'charset to render 2x4 blocks on canvas')
-vd.option('disp_pixel_random', False, 'randomly choose attr from set of pixels instead of most common')
-vd.option('zoom_incr', 2.0, 'amount to multiply current zoomlevel when zooming')
-vd.option('color_graph_hidden', '238 blue', 'color of legend for hidden attribute')
-vd.option('color_graph_selected', 'bold', 'color of selected graph points')
+vd.theme_option('disp_graph_labels', True, 'show axes and legend on graph')
+vd.theme_option('plot_colors', 'green red yellow cyan magenta white 38 136 168', 'list of distinct colors to use for plotting distinct objects')
+vd.theme_option('disp_canvas_charset', ''.join(chr(0x2800+i) for i in range(256)), 'charset to render 2x4 blocks on canvas')
+vd.theme_option('disp_pixel_random', False, 'randomly choose attr from set of pixels instead of most common')
+vd.theme_option('disp_zoom_incr', 2.0, 'amount to multiply current zoomlevel when zooming')
+vd.theme_option('color_graph_hidden', '238 blue', 'color of legend for hidden attribute')
+vd.theme_option('color_graph_selected', 'bold', 'color of selected graph points')
 
 
 class Point:
@@ -158,18 +159,19 @@ class Plotter(BaseSheet):
         # pixels[y][x] = { attr: list(rows), ... }
         self.pixels = [[defaultdict(list) for x in range(self.plotwidth)] for y in range(self.plotheight)]
 
-    def plotpixel(self, x, y, attr=0, row=None):
+    def plotpixel(self, x, y, attr:"str|ColorAttr=''", row=None):
         self.pixels[y][x][attr].append(row)
 
-    def plotline(self, x1, y1, x2, y2, attr=0, row=None):
+    def plotline(self, x1, y1, x2, y2, attr:"str|ColorAttr=''", row=None):
         for x, y in iterline(x1, y1, x2, y2):
             self.plotpixel(math.ceil(x), math.ceil(y), attr, row)
 
-    def plotlabel(self, x, y, text, attr=0, row=None):
+    def plotlabel(self, x, y, text, attr:"str|ColorAttr=''", row=None):
         self.labels.append((x, y, text, attr, row))
 
-    def plotlegend(self, i, txt, attr=0, width=15):
-        self.plotlabel(self.plotwidth-width*2, i*4, txt, attr)
+    def plotlegend(self, i, txt, attr:"str|ColorAttr=''", width=15):
+        # move it 1 character to the left b/c the rightmost column can't be drawn to
+        self.plotlabel(self.plotwidth-(width+1)*2, i*4, txt, attr)
 
     @property
     def plotterCursorBox(self):
@@ -183,14 +185,14 @@ class Plotter(BaseSheet):
     def plotterFromTerminalCoord(self, x, y):
         return x*2, y*4
 
-    def getPixelAttrRandom(self, x, y):
-        'weighted-random choice of attr at this pixel.'
+    def getPixelAttrRandom(self, x, y) -> str:
+        'weighted-random choice of colornum at this pixel.'
         c = list(attr for attr, rows in self.pixels[y][x].items()
                          for r in rows if attr and attr not in self.hiddenAttrs)
         return random.choice(c) if c else 0
 
-    def getPixelAttrMost(self, x, y):
-        'most common attr at this pixel.'
+    def getPixelAttrMost(self, x, y) -> str:
+        'most common colornum at this pixel.'
         r = self.pixels[y][x]
         if not r:
             return 0
@@ -198,22 +200,24 @@ class Plotter(BaseSheet):
         if not c:
             return 0
         _, attr, rows = max(c)
-        if isinstance(self.source, BaseSheet) and anySelected(self.source, rows):
-            attr = update_attr(ColorAttr(attr, 0, 8, attr), colors.color_graph_selected, 10).attr
         return attr
 
-    def hideAttr(self, attr, hide=True):
+    def hideAttr(self, attr:str, hide=True):
         if hide:
             self.hiddenAttrs.add(attr)
         else:
             self.hiddenAttrs.remove(attr)
         self.plotlegends()
 
-    def rowsWithin(self, bbox):
-        'return list of deduped rows within bbox'
+    def rowsWithin(self, plotter_bbox):
+        'return list of deduped rows within plotter_bbox'
         ret = {}
-        for y in range(bbox.ymin, min(len(self.pixels), bbox.ymax+1)):
-            for x in range(bbox.xmin, min(len(self.pixels[y]), bbox.xmax+1)):
+        x_start = max(0, plotter_bbox.xmin)
+        y_start = max(0, plotter_bbox.ymin)
+        y_end = min(len(self.pixels), plotter_bbox.ymax)
+        for y in range(y_start, y_end):
+            x_end = min(len(self.pixels[y]), plotter_bbox.xmax)
+            for x in range(x_start, x_end):
                 for attr, rows in self.pixels[y][x].items():
                     if attr not in self.hiddenAttrs:
                         for r in rows:
@@ -253,16 +257,17 @@ class Plotter(BaseSheet):
                         pow2 *= 2
 
                     if braille_num != 0:
-                        attr = Counter(c for c in block_attrs if c).most_common(1)[0][0]
+                        color = Counter(c for c in block_attrs if c).most_common(1)[0][0]
+                        cattr = colors.get_color(color)
                     else:
-                        attr = 0
+                        cattr = ColorAttr()
 
                     if cursorBBox.contains(char_x*2, char_y*4) or \
                        cursorBBox.contains(char_x*2+1, char_y*4+3):
-                        attr = update_attr(ColorAttr(attr, 0, 0, attr), colors.color_current_row).attr
+                        cattr = update_attr(cattr, colors.color_current_row)
 
-                    if attr:
-                        scr.addstr(char_y, char_x, disp_canvas_charset[braille_num], attr)
+                    if cattr.attr:
+                        scr.addstr(char_y, char_x, disp_canvas_charset[braille_num], cattr.attr)
 
         def _mark_overlap_text(labels, textobj):
             def _overlaps(a, b):
@@ -283,7 +288,7 @@ class Plotter(BaseSheet):
                     o[1] = False
                     label_fldraw[1] = False
 
-        if self.options.show_graph_labels:
+        if self.options.disp_graph_labels:
             labels_by_line = defaultdict(list) # y -> text labels
 
             for pix_x, pix_y, txt, attr, row in self.labels:
@@ -300,7 +305,16 @@ class Plotter(BaseSheet):
                 for o, fldraw in line:
                     if fldraw:
                         char_x, char_y, txt, attr, row = o
-                        clipdraw(scr, char_y, char_x, txt, attr, len(txt))
+                        cattr = colors.get_color(attr)
+                        clipdraw(scr, char_y, char_x, txt, cattr, dispwidth(txt))
+                        cursorBBox = self.plotterCursorBox
+                        for c in txt:
+                            w = dispwidth(c)
+                            # check if the cursor contains the midpoint of the character box
+                            if cursorBBox.contains(char_x*2+1, char_y*4+2):
+                                char_attr = update_attr(cattr, colors.color_current_row)
+                                clipdraw(scr, char_y, char_x, c, char_attr, w)
+                            char_x += w
 
 
 # - has a cursor, of arbitrary position and width/height (not restricted to current zoom)
@@ -309,10 +323,11 @@ class Canvas(Plotter):
     rowtype = 'plots'
     leftMarginPixels = 10*2
     rightMarginPixels = 4*2
-    topMarginPixels = 0
+    topMarginPixels = 0*4
     bottomMarginPixels = 1*4  # reserve bottom line for x axis
 
     def __init__(self, *names, **kwargs):
+        self.left_margin = self.leftMarginPixels
         super().__init__(*names, **kwargs)
 
         self.canvasBox = None   # bounding box of entire canvas, in canvas units
@@ -324,8 +339,8 @@ class Canvas(Plotter):
         self.yzoomlevel = 1.0
         self.needsRefresh = False
 
-        self.polylines = []   # list of ([(canvas_x, canvas_y), ...], attr, row)
-        self.gridlabels = []  # list of (grid_x, grid_y, label, attr, row)
+        self.polylines = []   # list of ([(canvas_x, canvas_y), ...], fgcolornum, row)
+        self.gridlabels = []  # list of (grid_x, grid_y, label, fgcolornum, row)
 
         self.legends = OrderedDict()   # txt: attr  (visible legends only)
         self.plotAttrs = {}   # key: attr  (all keys, for speed)
@@ -338,12 +353,13 @@ class Canvas(Plotter):
     def reset(self):
         'clear everything in preparation for a fresh reload()'
         self.polylines.clear()
+        self.left_margin = self.leftMarginPixels
         self.legends.clear()
         self.legendwidth = 0
         self.plotAttrs.clear()
-        self.unusedAttrs = list(colors[colorname.translate(str.maketrans('_', ' '))] for colorname in self.options.plot_colors.split())
+        self.unusedAttrs = list(self.options.plot_colors.split())
 
-    def plotColor(self, k):
+    def plotColor(self, k) -> str:
         attr = self.plotAttrs.get(k, None)
         if attr is None:
             if self.unusedAttrs:
@@ -354,16 +370,38 @@ class Canvas(Plotter):
                 del self.legends[lastlegend]
                 legend = '[other]'
 
-            self.legendwidth = max(self.legendwidth, len(legend))
+            self.legendwidth = max(self.legendwidth, dispwidth(legend))
             self.legends[legend] = attr
             self.plotAttrs[k] = attr
-            self.plotlegends()
         return attr
 
     def resetCanvasDimensions(self, windowHeight, windowWidth):
+        old_plotsize = None
+        realign_cursor = False
+        if hasattr(self, 'plotwidth') and hasattr(self, 'plotheight'):
+            old_plotsize = [self.plotheight, self.plotwidth]
+            if hasattr(self, 'cursorBox') and self.cursorBox and self.visibleBox:
+                # if the cursor is at the origin, realign it with the origin after the resize
+                if self.cursorBox.xmin == self.visibleBox.xmin and self.cursorBox.ymin == self.calcBottomCursorY():
+                    realign_cursor = True
         super().resetCanvasDimensions(windowHeight, windowWidth)
-        self.plotviewBox = BoundingBox(self.leftMarginPixels, self.topMarginPixels,
-                                       self.plotwidth-self.rightMarginPixels, self.plotheight-self.bottomMarginPixels-1)
+        if hasattr(self, 'legendwidth'):
+            # +4 = 1 empty space after the graph + 2 characters for the legend prefixes of "1:", "2:", etc +
+            #      1 character for the empty rightmost column
+            new_margin = max(self.rightMarginPixels, (self.legendwidth+4)*2)
+            pvbox_xmax = self.plotwidth-new_margin-1
+            # ensure the graph data takes up at least 3/4 of the width of the screen no matter how wide the legend gets
+            pvbox_xmax = max(pvbox_xmax, math.ceil(self.plotwidth * 3/4)//2*2 + 1)
+        else:
+            pvbox_xmax = self.plotwidth-self.rightMarginPixels-1
+        self.left_margin = min(self.left_margin, math.ceil(self.plotwidth * 1/3)//2*2)
+        self.plotviewBox = BoundingBox(self.left_margin, self.topMarginPixels,
+                                       pvbox_xmax, self.plotheight-self.bottomMarginPixels-1)
+        if [self.plotheight, self.plotwidth] != old_plotsize:
+            if hasattr(self, 'cursorBox') and self.cursorBox:
+                self.setCursorSizeInPlotterPixels(2, 4)
+            if realign_cursor:
+                self.cursorBox.ymin = self.calcBottomCursorY()
 
     @property
     def statusLine(self):
@@ -371,20 +409,29 @@ class Canvas(Plotter):
 
     @property
     def canvasMouse(self):
-        return self.canvasFromPlotterCoord(self.plotterMouse.x, self.plotterMouse.y)
-
-    def canvasFromPlotterCoord(self, plotter_x, plotter_y):
-        return Point(self.visibleBox.xmin + (plotter_x-self.plotviewBox.xmin)/self.xScaler, self.visibleBox.ymin + (plotter_y-self.plotviewBox.ymin)/self.yScaler)
-
-    def canvasFromTerminalCoord(self, x, y):
-        return self.canvasFromPlotterCoord(*self.plotterFromTerminalCoord(x, y))
+        x = self.plotterMouse.x
+        y = self.plotterMouse.y
+        if not self.canvasBox: return None
+        p = Point(self.unscaleX(x), self.unscaleY(y))
+        return p
 
     def setCursorSize(self, p):
         'sets width based on diagonal corner p'
+        if not p: return
         self.cursorBox = BoundingBox(self.cursorBox.xmin, self.cursorBox.ymin, p.x, p.y)
         self.cursorBox.w = max(self.cursorBox.w, self.canvasCharWidth)
         self.cursorBox.h = max(self.cursorBox.h, self.canvasCharHeight)
 
+    def setCursorSizeInPlotterPixels(self, w, h):
+        self.setCursorSize(Point(self.cursorBox.xmin + w/2 * self.canvasCharWidth,
+                                 self.cursorBox.ymin + h/4 * self.canvasCharHeight))
+
+    def formatX(self, v):
+        return str(v)
+
+    def formatY(self, v):
+        return str(v)
+
     def commandCursor(sheet, execstr):
         'Return (col, row) of cursor suitable for cmdlog replay of execstr.'
         contains = lambda s, *substrs: any((a in s) for a in substrs)
@@ -425,21 +472,29 @@ class Canvas(Plotter):
                            self.scaleX(self.cursorBox.xmax),
                            self.scaleY(self.cursorBox.ymax))
 
-    def point(self, x, y, attr=0, row=None):
+    def startCursor(self):
+        cm = self.canvasMouse
+        if cm:
+            self.cursorBox = Box(*cm.xy)
+            return True
+        else:
+            return None
+
+    def point(self, x, y, attr:"str|ColorAttr=''", row=None):
         self.polylines.append(([(x, y)], attr, row))
 
-    def line(self, x1, y1, x2, y2, attr=0, row=None):
+    def line(self, x1, y1, x2, y2, attr:"str|ColorAttr=''", row=None):
         self.polylines.append(([(x1, y1), (x2, y2)], attr, row))
 
-    def polyline(self, vertexes, attr=0, row=None):
+    def polyline(self, vertexes, attr:"str|ColorAttr=''", row=None):
         'adds lines for (x,y) vertexes of a polygon'
         self.polylines.append((vertexes, attr, row))
 
-    def polygon(self, vertexes, attr=0, row=None):
+    def polygon(self, vertexes, attr:"str|ColorAttr=''", row=None):
         'adds lines for (x,y) vertexes of a polygon'
         self.polylines.append((vertexes + [vertexes[0]], attr, row))
 
-    def qcurve(self, vertexes, attr=0, row=None):
+    def qcurve(self, vertexes, attr:"str|ColorAttr=''", row=None):
         'Draw quadratic curve from vertexes[0] to vertexes[2] with control point at vertexes[1]'
         if len(vertexes) != 3:
             vd.fail('need exactly 3 points for qcurve (got %d)' % len(vertexes))
@@ -451,7 +506,7 @@ class Canvas(Plotter):
         for x, y in bezier(x1, y1, x2, y2, x3, y3):
             self.point(x, y, attr, row)
 
-    def label(self, x, y, text, attr=0, row=None):
+    def label(self, x, y, text, attr:"str|ColorAttr=''", row=None):
         self.gridlabels.append((x, y, text, attr, row))
 
     def fixPoint(self, plotterPoint, canvasPoint):
@@ -473,7 +528,7 @@ class Canvas(Plotter):
         self.resetBounds()
 
     def resetBounds(self):
-        'create canvasBox and cursorBox if necessary, and set visibleBox w/h according to zoomlevels.  then redisplay labels.'
+        'create canvasBox and cursorBox if necessary, and set visibleBox w/h according to zoomlevels.  then redisplay legends.'
         if not self.canvasBox:
             xmin, ymin, xmax, ymax = None, None, None, None
             for vertexes, attr, row in self.polylines:
@@ -504,17 +559,33 @@ class Canvas(Plotter):
             self.visibleBox.h = h
 
         if not self.cursorBox:
-            self.cursorBox = Box(self.visibleBox.xmin, self.visibleBox.ymin, self.canvasCharWidth, self.canvasCharHeight)
+            cb_xmin = self.visibleBox.xmin
+            cb_ymin = self.calcBottomCursorY()
+            self.cursorBox = Box(cb_xmin, cb_ymin, self.canvasCharWidth, self.canvasCharHeight)
 
         self.plotlegends()
 
+    def calcTopCursorY(self):
+        'ymin for the cursor that will align its top with the top edge of the graph'
+        # + (1/4*self.canvasCharHeight) shifts the cursor up by 1 plotter pixel.
+        # That shift makes the cursor contain the top data point.
+        # Otherwise, the top data point would have y == plotterCursorBox.ymax,
+        # which would not be inside plotterCursorBox. Shifting the cursor makes
+        # plotterCursorBox.ymax > y for that top point.
+        return self.visibleBox.ymax - self.cursorBox.h + (1/4*self.canvasCharHeight)
+
+    def calcBottomCursorY(self):
+        'ymin for the cursor that will align its bottom with the bottom edge of the graph'
+        return self.visibleBox.ymin
+
     def plotlegends(self):
         # display labels
         for i, (legend, attr) in enumerate(self.legends.items()):
-            self.addCommand(str(i+1), 'toggle-%s'%(i+1), 'hideAttr(%s, %s not in hiddenAttrs)' % (attr, attr), 'toggle display of "%s"' % legend)
+            self.addCommand(str(i+1), f'toggle-{i+1}', f'hideAttr("{attr}", "{attr}" not in hiddenAttrs)', f'toggle display of "{legend}"')
             if attr in self.hiddenAttrs:
-                attr = colors.color_graph_hidden
-            self.plotlegend(i, '%s:%s'%(i+1,legend), attr, width=self.legendwidth+4)
+                attr = 'graph_hidden'
+            # add 2 characters to width to account for '1:' '2:' etc
+            self.plotlegend(i, '%s:%s'%(i+1,legend), attr, width=self.legendwidth+2)
 
     def checkCursor(self):
         'override Sheet.checkCursor'
@@ -570,14 +641,21 @@ class Canvas(Plotter):
         else:
             return h
 
-    #could be called canvas_to_plotterX()
-    def scaleX(self, x):
-        'returns plotter x coordinate'
-        return round(self.plotviewBox.xmin+(x-self.visibleBox.xmin)*self.xScaler)
+    def scaleX(self, canvasX):
+        'returns a plotter x coordinate'
+        return round(self.plotviewBox.xmin+(canvasX-self.visibleBox.xmin)*self.xScaler)
+
+    def scaleY(self, canvasY):
+        'returns a plotter y coordinate'
+        return round(self.plotviewBox.ymin+(canvasY-self.visibleBox.ymin)*self.yScaler)
+
+    def unscaleX(self, plotterX):
+        'performs the inverse of scaleX, returns a canvas x coordinate'
+        return (plotterX-self.plotviewBox.xmin)/self.xScaler + self.visibleBox.xmin
 
-    def scaleY(self, y):
-        'returns plotter y coordinate'
-        return round(self.plotviewBox.ymin+(y-self.visibleBox.ymin)*self.yScaler)
+    def unscaleY(self, plotterY):
+        'performs the inverse of scaleY, returns a canvas y coordinate'
+        return (plotterY-self.plotviewBox.ymin)/self.yScaler + self.visibleBox.ymin
 
     def canvasW(self, plotter_width):
         'plotter X units to canvas units'
@@ -601,25 +679,33 @@ class Canvas(Plotter):
 
     @asyncthread
     def render_async(self):
-        self.render_sync()
+        self.plot_elements()
 
-    def render_sync(self):
-        'plots points and lines and text onto the Plotter'
+    def plot_elements(self, invert_y=False):
+        'plots points and lines and text onto the plotter'
 
         self.resetBounds()
 
         bb = self.visibleBox
         xmin, ymin, xmax, ymax = bb.xmin, bb.ymin, bb.xmax, bb.ymax
         xfactor, yfactor = self.xScaler, self.yScaler
-        plotxmin, plotymin = self.plotviewBox.xmin, self.plotviewBox.ymin
+        plotxmin = self.plotviewBox.xmin
+        if invert_y:
+            plotymax = self.plotviewBox.ymax
+        else:
+            plotymin = self.plotviewBox.ymin
 
         for vertexes, attr, row in Progress(self.polylines, 'rendering'):
             if len(vertexes) == 1:  # single point
                 x1, y1 = vertexes[0]
                 x1, y1 = float(x1), float(y1)
                 if xmin <= x1 <= xmax and ymin <= y1 <= ymax:
+                    # equivalent to self.scaleX(x1) and self.scaleY(y1), inlined for speed
                     x = plotxmin+(x1-xmin)*xfactor
-                    y = plotymin+(y1-ymin)*yfactor
+                    if invert_y:
+                        y = plotymax-(y1-ymin)*yfactor
+                    else:
+                        y = plotymin+(y1-ymin)*yfactor
                     self.plotpixel(round(x), round(y), attr, row)
                 continue
 
@@ -629,9 +715,13 @@ class Canvas(Plotter):
                 if r:
                     x1, y1, x2, y2 = r
                     x1 = plotxmin+float(x1-xmin)*xfactor
-                    y1 = plotymin+float(y1-ymin)*yfactor
                     x2 = plotxmin+float(x2-xmin)*xfactor
-                    y2 = plotymin+float(y2-ymin)*yfactor
+                    if invert_y:
+                        y1 = plotymax-float(y1-ymin)*yfactor
+                        y2 = plotymax-float(y2-ymin)*yfactor
+                    else:
+                        y1 = plotymin+float(y1-ymin)*yfactor
+                        y2 = plotymin+float(y2-ymin)*yfactor
                     self.plotline(x1, y1, x2, y2, attr, row)
                 prev_x, prev_y = x, y
 
@@ -646,16 +736,16 @@ class Canvas(Plotter):
         self.reload()
 
 
-Plotter.addCommand('v', 'visibility', 'options.show_graph_labels = not options.show_graph_labels', 'toggle show_graph_labels option')
+Plotter.addCommand('v', 'visibility', 'options.disp_graph_labels = not options.disp_graph_labels', 'toggle disp_graph_labels option')
 
-Canvas.addCommand(None, 'go-left', 'sheet.cursorBox.xmin -= cursorBox.w', 'move cursor left by its width')
-Canvas.addCommand(None, 'go-right', 'sheet.cursorBox.xmin += cursorBox.w', 'move cursor right by its width' )
-Canvas.addCommand(None, 'go-up', 'sheet.cursorBox.ymin -= cursorBox.h', 'move cursor up by its height')
-Canvas.addCommand(None, 'go-down', 'sheet.cursorBox.ymin += cursorBox.h', 'move cursor down by its height')
-Canvas.addCommand(None, 'go-leftmost', 'sheet.cursorBox.xmin = visibleBox.xmin', 'move cursor to left edge of visible canvas')
-Canvas.addCommand(None, 'go-rightmost', 'sheet.cursorBox.xmin = visibleBox.xmax-cursorBox.w', 'move cursor to right edge of visible canvas')
-Canvas.addCommand(None, 'go-top', 'sheet.cursorBox.ymin = visibleBox.ymin', 'move cursor to top edge of visible canvas')
-Canvas.addCommand(None, 'go-bottom', 'sheet.cursorBox.ymin = visibleBox.ymax', 'move cursor to bottom edge of visible canvas')
+Canvas.addCommand(None, 'go-left', 'if cursorBox: sheet.cursorBox.xmin -= cursorBox.w', 'move cursor left by its width')
+Canvas.addCommand(None, 'go-right', 'if cursorBox: sheet.cursorBox.xmin += cursorBox.w', 'move cursor right by its width' )
+Canvas.addCommand(None, 'go-up', 'if cursorBox: sheet.cursorBox.ymin -= cursorBox.h', 'move cursor up by its height')
+Canvas.addCommand(None, 'go-down', 'if cursorBox: sheet.cursorBox.ymin += cursorBox.h', 'move cursor down by its height')
+Canvas.addCommand(None, 'go-leftmost', 'if cursorBox: sheet.cursorBox.xmin = visibleBox.xmin', 'move cursor to left edge of visible canvas')
+Canvas.addCommand(None, 'go-rightmost', 'if cursorBox: sheet.cursorBox.xmin = visibleBox.xmax-cursorBox.w+(1/2*canvasCharWidth)', 'move cursor to right edge of visible canvas')
+Canvas.addCommand(None, 'go-top',    'if cursorBox: sheet.cursorBox.ymin = sheet.calcTopCursorY()', 'move cursor to top edge of visible canvas')
+Canvas.addCommand(None, 'go-bottom', 'if cursorBox: sheet.cursorBox.ymin = sheet.calcBottomCursorY()', 'move cursor to bottom edge of visible canvas')
 
 Canvas.addCommand(None, 'go-pagedown', 't=(visibleBox.ymax-visibleBox.ymin); sheet.cursorBox.ymin += t; sheet.visibleBox.ymin += t; refresh()', 'move cursor down to next visible page')
 Canvas.addCommand(None, 'go-pageup', 't=(visibleBox.ymax-visibleBox.ymin); sheet.cursorBox.ymin -= t; sheet.visibleBox.ymin -= t; refresh()', 'move cursor up to previous visible page')
@@ -676,20 +766,27 @@ Canvas.addCommand('J', 'resize-cursor-taller', 'sheet.cursorBox.h += canvasCharH
 Canvas.addCommand('K', 'resize-cursor-shorter', 'sheet.cursorBox.h -= canvasCharHeight', 'decrease cursor height by one character')
 Canvas.addCommand('zz', 'zoom-cursor', 'zoomTo(cursorBox)', 'set visible bounds to cursor')
 
-Canvas.addCommand('-', 'zoomout-cursor', 'tmp=cursorBox.center; incrZoom(options.zoom_incr); fixPoint(plotviewBox.center, tmp)', 'zoom out from cursor center')
-Canvas.addCommand('+', 'zoomin-cursor', 'tmp=cursorBox.center; incrZoom(1.0/options.zoom_incr); fixPoint(plotviewBox.center, tmp)', 'zoom into cursor center')
-Canvas.addCommand('_', 'zoom-all', 'sheet.canvasBox = None; sheet.visibleBox = None; sheet.xzoomlevel=sheet.yzoomlevel=1.0; refresh()', 'zoom to fit full extent')
+Canvas.addCommand('-', 'zoomout-cursor', 'tmp=cursorBox.center; incrZoom(options.disp_zoom_incr); fixPoint(plotviewBox.center, tmp)', 'zoom out from cursor center')
+Canvas.addCommand('+', 'zoomin-cursor', 'tmp=cursorBox.center; incrZoom(1.0/options.disp_zoom_incr); fixPoint(plotviewBox.center, tmp)', 'zoom into cursor center')
+Canvas.addCommand('_', 'zoom-all', 'sheet.canvasBox = None; sheet.visibleBox = None; sheet.xzoomlevel=sheet.yzoomlevel=1.0; resetBounds(); refresh()', 'zoom to fit full extent')
 Canvas.addCommand('z_', 'set-aspect', 'sheet.aspectRatio = float(input("aspect ratio=", value=aspectRatio)); refresh()', 'set aspect ratio')
 
 # set cursor box with left click
-Canvas.addCommand('BUTTON1_PRESSED', 'start-cursor', 'sheet.cursorBox = Box(*canvasMouse.xy)', 'start cursor box with left mouse button press')
-Canvas.addCommand('BUTTON1_RELEASED', 'end-cursor', 'setCursorSize(canvasMouse)', 'end cursor box with left mouse button release')
-
-Canvas.addCommand('BUTTON3_PRESSED', 'start-move', 'sheet.anchorPoint = canvasMouse', 'mark grid point to move')
-Canvas.addCommand('BUTTON3_RELEASED', 'end-move', 'fixPoint(plotterMouse, anchorPoint)', 'mark canvas anchor point')
-
-Canvas.addCommand('ScrollwheelUp', 'zoomin-mouse', 'tmp=canvasMouse; incrZoom(1.0/options.zoom_incr); fixPoint(plotterMouse, tmp)', 'zoom in with scroll wheel')
-Canvas.addCommand('ScrollwheelDown', 'zoomout-mouse', 'tmp=canvasMouse; incrZoom(options.zoom_incr); fixPoint(plotterMouse, tmp)', 'zoom out with scroll wheel')
+Canvas.addCommand('BUTTON1_PRESSED', 'start-cursor', 'startCursor()', 'start cursor box with left mouse button press')
+Canvas.addCommand('BUTTON1_RELEASED', 'end-cursor', 'cm=canvasMouse; setCursorSize(cm) if cm else None', 'end cursor box with left mouse button release')
+Canvas.addCommand('BUTTON1_CLICKED', 'remake-cursor', 'startCursor(); cm=canvasMouse; setCursorSize(cm) if cm else None', 'end cursor box with left mouse button release')
+Canvas.bindkey('BUTTON1_DOUBLE_CLICKED', 'remake-cursor')
+Canvas.bindkey('BUTTON1_TRIPLE_CLICKED', 'remake-cursor')
+
+Canvas.addCommand('BUTTON3_PRESSED', 'start-move', 'cm=canvasMouse; sheet.anchorPoint = cm if cm else None', 'mark grid point to move')
+Canvas.addCommand('BUTTON3_RELEASED', 'end-move', 'fixPoint(plotterMouse, anchorPoint) if anchorPoint else None', 'mark canvas anchor point')
+# A click does not actually move the canvas, but gives useful UI feedback. It helps users understand that they can do press-drag-release.
+Canvas.addCommand('BUTTON3_CLICKED', 'move-canvas',  '', 'move canvas (in place)')
+Canvas.bindkey('BUTTON3_DOUBLE_CLICKED', 'move-canvas')
+Canvas.bindkey('BUTTON3_TRIPLE_CLICKED', 'move-canvas')
+
+Canvas.addCommand('ScrollUp', 'zoomin-mouse', 'cm=canvasMouse; incrZoom(1.0/options.disp_zoom_incr) if cm else fail("cannot zoom in on unplotted canvas"); fixPoint(plotterMouse, cm)', 'zoom in with scroll wheel')
+Canvas.addCommand('ScrollDown', 'zoomout-mouse', 'cm=canvasMouse; incrZoom(options.disp_zoom_incr) if cm else fail("cannot zoom out on unplotted canvas"); fixPoint(plotterMouse, cm)', 'zoom out with scroll wheel')
 
 Canvas.addCommand('s', 'select-cursor', 'source.select(list(rowsWithin(plotterCursorBox)))', 'select rows on source sheet contained within canvas cursor')
 Canvas.addCommand('t', 'stoggle-cursor', 'source.toggle(list(rowsWithin(plotterCursorBox)))', 'toggle selection of rows on source sheet contained within canvas cursor')
@@ -703,7 +800,6 @@ Canvas.addCommand('gu', 'unselect-visible', 'source.unselect(list(rowsWithin(plo
 Canvas.addCommand('g'+ENTER, 'dive-visible', 'vs=copy(source); vs.rows=list(rowsWithin(plotterVisibleBox)); vd.push(vs)', 'open sheet of source rows visible on screen')
 Canvas.addCommand('gd', 'delete-visible', 'deleteSourceRows(rowsWithin(plotterVisibleBox))', 'delete rows on source sheet visible on screen')
 
-
 vd.addGlobals({
     'Canvas': Canvas,
     'Plotter': Plotter,
@@ -711,3 +807,22 @@ vd.addGlobals({
     'Box': Box,
     'Point': Point,
 })
+
+vd.addMenuItems('''
+    Plot > Resize cursor > height > double > resize-cursor-doubleheight
+    Plot > Resize cursor > height > half > resize-cursor-halfheight
+    Plot > Resize cursor > height > shorter > resize-cursor-shorter
+    Plot > Resize cursor > height > taller > resize-cursor-taller
+    Plot > Resize cursor > width > double > resize-cursor-doublewide
+    Plot > Resize cursor > width > half > resize-cursor-halfwide
+    Plot > Resize cursor > width > thinner > resize-cursor-thinner
+    Plot > Resize cursor > width > wider > resize-cursor-wider
+    Plot > Resize graph > X axis > resize-x-input
+    Plot > Resize graph > Y axis > resize-y-input
+    Plot > Resize graph > aspect ratio > set-aspect
+    Plot > Zoom > out > zoomout-cursor
+    Plot > Zoom > in > zoomin-cursor
+    Plot > Zoom > cursor > zoom-all
+    Plot > Dive into cursor > dive-cursor
+    Plot > Delete > under cursor > delete-cursor
+''')

visidata/choose.py

@@ -5,15 +5,15 @@ from visidata import vd, options, VisiData, ListOfDictSheet, ENTER, CompleteKey,
 vd.option('fancy_chooser', False, 'a nicer selection interface for aggregators and jointype')
 
 @VisiData.api
-def chooseOne(vd, choices):
+def chooseOne(vd, choices, type=''):
     'Return one user-selected key from *choices*.'
-    return vd.choose(choices, 1)
+    return vd.choose(choices, 1, type=type)
 
 
 @VisiData.api
-def choose(vd, choices, n=None):
+def choose(vd, choices, n=None, type=''):
     'Return a list of 1 to *n* "key" from elements of *choices* (see chooseMany).'
-    ret = vd.chooseMany(choices) or vd.fail('no choice made')
+    ret = vd.chooseMany(choices, type=type) or vd.fail('no choice made')
     if n and len(ret) > n:
         vd.fail('can only choose %s' % n)
     return ret[0] if n==1 else ret
@@ -39,7 +39,7 @@ def chooseFancy(vd, choices):
 
 
 @VisiData.api
-def chooseMany(vd, choices):
+def chooseMany(vd, choices, type=''):
     '''Return a list of 1 or more keys from *choices*, which is a list of
     dicts. Each element dict must have a unique "key", which must be typed
     directly by the user in non-fancy mode (therefore no spaces).  All other
@@ -65,7 +65,7 @@ def chooseMany(vd, choices):
                 if ret:
                     raise ReturnValue(ret)
                 return v, i
-            chosenstr = vd.input(prompt+': ', completer=CompleteKey(choice_keys), bindings={'^X': throw_fancy})
+            chosenstr = vd.input(prompt+': ', completer=CompleteKey(choice_keys), bindings={'^X': throw_fancy}, type=type)
             for c in chosenstr.split():
                 if c in choice_keys:
                     chosen.append(c)

visidata/clean_names.py

@@ -0,0 +1,29 @@
+import re
+from visidata import vd, VisiData, Sheet
+
+
+vd.option('clean_names', False, 'clean column/sheet names to be valid Python identifiers', replay=True)
+
+
+@VisiData.global_api
+def cleanName(vd, s):
+    #[Nas Banov] https://stackoverflow.com/a/3305731
+    #    return re.sub(r'\W|^(?=\d)', '_', str(s)).strip('_')
+    s = re.sub(r'[^\w\d_]', '_', s)  # replace non-alphanum chars with _
+    s = re.sub(r'_+', '_', s)  # replace runs of _ with a single _
+    s = s.strip('_')
+    return s
+
+
+@Sheet.api
+def maybeClean(sheet, s):
+    if sheet.options.clean_names:
+        s = vd.cleanName(s)
+    return s
+
+
+Sheet.addCommand('', 'clean-names', '''
+options.clean_names = True;
+for c in visibleCols:
+    c.name = cleanName(c.name)
+''', 'set options.clean_names on sheet and clean visible column names')