visidata 2.11.dev0__py3-none-any.whl → 3.0__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:
@@ -482,29 +537,55 @@ class Canvas(Plotter):
                     if ymin is None or y < ymin: ymin = y
                     if xmax is None or x > xmax: xmax = x
                     if ymax is None or y > ymax: ymax = y
-            self.canvasBox = BoundingBox(float(xmin or 0), float(ymin or 0), float(xmax or 1), float(ymax or 1))
-
+            xmin = xmin or 0
+            xmax = xmax or 0
+            ymin = ymin or 0
+            ymax = ymax or 0
+            if xmin == xmax:
+                xmax += 1
+            if ymin == ymax:
+                ymax += 1
+            self.canvasBox = BoundingBox(float(xmin), float(ymin), float(xmax), float(ymax))
+
+        w = self.calcVisibleBoxWidth()
+        h = self.calcVisibleBoxHeight()
         if not self.visibleBox:
             # initialize minx/miny, but w/h must be set first to center properly
-            self.visibleBox = Box(0, 0, self.plotviewBox.w/self.xScaler, self.plotviewBox.h/self.yScaler)
-            self.visibleBox.xmin = self.canvasBox.xcenter - self.visibleBox.w/2
-            self.visibleBox.ymin = self.canvasBox.ycenter - self.visibleBox.h/2
+            self.visibleBox = Box(0, 0, w, h)
+            self.visibleBox.xmin = self.canvasBox.xmin + (self.canvasBox.w / 2) * (1 - self.xzoomlevel)
+            self.visibleBox.ymin = self.canvasBox.ymin + (self.canvasBox.h / 2) * (1 - self.yzoomlevel)
         else:
-            self.visibleBox.w = self.plotviewBox.w/self.xScaler
-            self.visibleBox.h = self.plotviewBox.h/self.yScaler
+            self.visibleBox.w = w
+            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'
@@ -534,13 +615,47 @@ class Canvas(Plotter):
         else:
             return yratio
 
-    def scaleX(self, x):
-        'returns plotter x coordinate'
-        return round(self.plotviewBox.xmin+(x-self.visibleBox.xmin)*self.xScaler)
+    def calcVisibleBoxWidth(self):
+        w = self.canvasBox.w * self.xzoomlevel
+        if self.aspectRatio:
+            h = self.canvasBox.h * self.yzoomlevel
+            xratio = self.plotviewBox.w / w
+            yratio = self.plotviewBox.h / h
+            if xratio <= yratio:
+                return w / self.aspectRatio
+            else:
+                return self.plotviewBox.w / (self.aspectRatio * yratio)
+        else:
+            return w
 
-    def scaleY(self, y):
-        'returns plotter y coordinate'
-        return round(self.plotviewBox.ymin+(y-self.visibleBox.ymin)*self.yScaler)
+    def calcVisibleBoxHeight(self):
+        h = self.canvasBox.h * self.yzoomlevel
+        if self.aspectRatio:
+            w = self.canvasBox.w * self.yzoomlevel
+            xratio = self.plotviewBox.w / w
+            yratio = self.plotviewBox.h / h
+            if xratio < yratio:
+                return self.plotviewBox.h / xratio
+            else:
+                return h
+        else:
+            return h
+
+    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 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'
@@ -564,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
 
@@ -592,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
 
@@ -609,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')
@@ -639,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')
@@ -666,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,
@@ -674,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,8 +39,13 @@ def chooseFancy(vd, choices):
 
 
 @VisiData.api
-def chooseMany(vd, choices):
-    '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 items in the dicts are also shown in fancy chooser mode.  Use previous choices from the replay input if available.  Add chosen keys (space-separated) to the cmdlog as input for the current command.'''
+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
+    items in the dicts are also shown in fancy chooser mode.  Use previous
+    choices from the replay input if available.  Add chosen keys
+    (space-separated) to the cmdlog as input for the current command.'''
     if vd.cmdlog:
         v = vd.getLastArgs()
         if v is not None:
@@ -60,13 +65,12 @@ 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():
-                poss = [p for p in choice_keys if str(p).startswith(c)]
-                if not poss:
-                    vd.warning('invalid choice "%s"' % c)
+                if c in choice_keys:
+                    chosen.append(c)
                 else:
-                    chosen.extend(poss)
+                    vd.warning('invalid choice "%s"' % c)
         except ReturnValue as e:
             chosen = e.args[0]