Improve viewport manipulation utilities and support scroll in mechanisms.

I.e. allow the user to scroll around with cursor keys,
provided that keeps the cursor still visible.

library/lua/gui.lua

@@ -245,6 +245,16 @@ end
 function Screen:onShown()
 end
 
+function Screen:dismiss()
+    if self._native and not dscreen.isDismissed(self) then
+        dscreen.dismiss(self)
+        self:onDismissed()
+    end
+end
+
+function Screen:onDismissed()
+end
+
 ------------------------
 -- Framed screen object --
 ------------------------
@@ -311,8 +321,7 @@ local function hint_coord(gap,hint)
     end
 end
 
-function FramedScreen:updateLayout()
+function FramedScreen:updateFrameSize(sw,sh)
-    local sw, sh = dscreen.getWindowSize()
     local iw, ih = sw-2, sh-2
     local width = math.min(self.frame_width or iw, iw)
     local height = math.min(self.frame_height or ih, ih)
@@ -322,9 +331,11 @@ function FramedScreen:updateLayout()
     self.frame_opaque = (gw == 0 and gh == 0)
 end
 
-function FramedScreen:onRender()
+function FramedScreen:onResize(w,h)
-    self:updateLayout()
+    self:updateFrameSize(w,h)
+end
 
+function FramedScreen:onRender()
     local rect = self.frame_rect
     local x1,y1,x2,y2 = rect.x1-1, rect.y1-1, rect.x2+1, rect.y2+1
 

library/lua/gui/dwarfmode.lua

@@ -4,6 +4,7 @@ local _ENV = mkmodule('gui.dwarfmode')
 
 local gui = require('gui')
 local dscreen = dfhack.screen
+local world_map = df.global.world.map
 
 AREA_MAP_WIDTH = 23
 MENU_WIDTH = 30
@@ -40,71 +41,135 @@ function getPanelLayout()
 end
 
 function getCursorPos()
+    if df.global.cursor.x ~= -30000 then
         return copyall(df.global.cursor)
+    end
 end
 
 function setCursorPos(cursor)
     df.global.cursor = cursor
 end
 
-function getViewportPos()
+function clearCursorPos()
-    return {
+    df.global.cursor = xyz2pos(nil)
-        x = df.global.window_x,
+end
-        y = df.global.window_y,
+
-        z = df.global.window_z
+Viewport = defclass(Viewport)
-    }
+
+function Viewport.make(map,x,y,z)
+    local self = gui.mkdims_wh(x,y,map.width,map.height)
+    self.z = z
+    return mkinstance(Viewport, self)
+end
+
+function Viewport.get(layout)
+    return Viewport.make(
+        (layout or getPanelLayout()).map,
+        df.global.window_x,
+        df.global.window_y,
+        df.global.window_z
+    )
 end
 
-function clipViewport(view, layout)
+function Viewport:resize(layout)
-    local map = df.global.world.map
+    return Viewport.make(
-    layout = layout or getPanelLayout()
+        (layout or getPanelLayout()).map,
-    return {
+        self.x1, self.y1, self.z
-        x = math.max(0, math.min(view.x, map.x_count-layout.map.width)),
+    )
-        y = math.max(0, math.min(view.y, map.y_count-layout.map.height)),
-        z = math.max(0, math.min(view.z, map.z_count-1))
-    }
 end
 
-function setViewportPos(view, layout)
+function Viewport:set()
-    local map = df.global.world.map
+    local vp = self:clip()
-    layout = layout or getPanelLayout()
+    df.global.window_x = vp.x1
-    local vp = clipViewport(view, layout)
+    df.global.window_y = vp.y1
-    df.global.window_x = vp.x
-    df.global.window_y = vp.y
     df.global.window_z = vp.z
     return vp
 end
 
-function centerViewportOn(target, layout)
+function Viewport:clip(x,y,z)
-    layout = layout or getPanelLayout()
+    return self:make(
-    local view = xyz2pos(
+        math.max(0, math.min(x or self.x1, world_map.x_count-self.width)),
-        target.x-math.floor(layout.map.width/2),
+        math.max(0, math.min(y or self.y1, world_map.y_count-self.height)),
-        target.y-math.floor(layout.map.height/2),
+        math.max(0, math.min(z or self.z, world_map.z_count-1))
-        target.z
     )
-    return setViewportPos(view, layout)
 end
 
-function isInViewport(layout,view,target,gap)
+function Viewport:isVisibleXY(target,gap)
+    gap = gap or 0
+
+    return math.max(target.x-gap,0) >= self.x1
+       and math.min(target.x+gap,world_map.x_count-1) <= self.x2
+       and math.max(target.y-gap,0) >= self.y1
+       and math.min(target.y+gap,world_map.y_count-1) <= self.y2
+end
+
+function Viewport:isVisible(target,gap)
     gap = gap or 0
 
-    local map = df.global.world.map
+    return self:isVisibleXY(target,gap) and target.z == self.z
-    return math.max(target.x-gap,0) >= view.x
+end
-       and math.min(target.x+gap,map.x_count-1) < view.x+layout.map.width
+
-       and math.max(target.y-gap,0) >= view.y
+function Viewport:centerOn(target)
-       and math.min(target.y+gap,map.y_count-1) < view.y+layout.map.height
+    return self:clip(
-       and target.z == view.z
+        target.x - math.floor(self.width/2),
+        target.y - math.floor(self.height/2),
+        target.z
+    )
+end
+
+function Viewport:scrollTo(target,gap)
+    gap = math.max(0, gap or 5)
+    if gap*2 >= math.min(self.width, self.height) then
+        gap = math.floor(math.min(self.width, self.height)/2)
+    end
+    local x = math.min(self.x1, target.x-gap)
+    x = math.max(x, target.x+gap+1-self.width)
+    local y = math.min(self.y1, target.y-gap)
+    y = math.max(y, target.y+gap+1-self.height)
+    return self:clip(x, y, target.z)
 end
 
-function revealInViewport(target,gap,view,layout)
+function Viewport:reveal(target,gap,max_scroll,scroll_gap,scroll_z)
-    layout = layout or getPanelLayout()
+    gap = math.max(0, gap or 5)
+    if self:isVisible(target, gap) then
+        return self
+    end
 
-    if not isInViewport(layout, getViewportPos(), target, gap) then
+    max_scroll = math.max(0, max_scroll or 5)
-        if view and isInViewport(layout, view, target, gap) then
+    if self:isVisibleXY(target, -max_scroll)
-            return setViewportPos(view, layout)
+    and (scroll_z or target.z == self.z) then
+        return self:scrollTo(target, scroll_gap or gap)
     else
-            return centerViewportOn(target, layout)
+        return self:centerOn(target)
     end
+end
+
+MOVEMENT_KEYS = {
+    CURSOR_UP = { 0, -1, 0 }, CURSOR_DOWN = { 0, 1, 0 },
+    CURSOR_LEFT = { -1, 0, 0 }, CURSOR_RIGHT = { 1, 0, 0 },
+    CURSOR_UPLEFT = { -1, -1, 0 }, CURSOR_UPRIGHT = { 1, -1, 0 },
+    CURSOR_DOWNLEFT = { -1, 1, 0 }, CURSOR_DOWNRIGHT = { 1, 1, 0 },
+    CURSOR_UP_FAST = { 0, -1, 0, true }, CURSOR_DOWN_FAST = { 0, 1, 0, true },
+    CURSOR_LEFT_FAST = { -1, 0, 0, true }, CURSOR_RIGHT_FAST = { 1, 0, 0, true },
+    CURSOR_UPLEFT_FAST = { -1, -1, 0, true }, CURSOR_UPRIGHT_FAST = { 1, -1, 0, true },
+    CURSOR_DOWNLEFT_FAST = { -1, 1, 0, true }, CURSOR_DOWNRIGHT_FAST = { 1, 1, 0, true },
+    CURSOR_UP_Z = { 0, 0, 1 }, CURSOR_DOWN_Z = { 0, 0, -1 },
+    CURSOR_UP_Z_AUX = { 0, 0, 1 }, CURSOR_DOWN_Z_AUX = { 0, 0, -1 },
+}
+
+function Viewport:scrollByKey(key)
+    local info = MOVEMENT_KEYS[key]
+    if info then
+        local delta = 10
+        if info[4] then delta = 20 end
+
+        return self:clip(
+            self.x1 + delta*info[1],
+            self.y1 + delta*info[2],
+            self.z + info[3]
+        )
+    else
+        return self
     end
 end
 
@@ -112,23 +177,53 @@ DwarfOverlay = defclass(DwarfOverlay, gui.Screen)
 
 function DwarfOverlay:updateLayout()
     self.df_layout = getPanelLayout()
-    self.df_viewport = getViewportPos()
-    self.df_cursor = getCursorPos()
 end
 
-local move_keys = {
+function DwarfOverlay:onShown()
-    'CURSOR_UP', 'CURSOR_DOWN', 'CURSOR_LEFT', 'CURSOR_RIGHT',
+    self:updateLayout()
-    'CURSOR_UPLEFT', 'CURSOR_UPRIGHT', 'CURSOR_DOWNLEFT', 'CURSOR_DOWNRIGHT',
+end
-    'CURSOR_UP_FAST', 'CURSOR_DOWN_FAST', 'CURSOR_LEFT_FAST', 'CURSOR_RIGHT_FAST',
+
-    'CURSOR_UPLEFT_FAST', 'CURSOR_UPRIGHT_FAST', 'CURSOR_DOWNLEFT_FAST', 'CURSOR_DOWNRIGHT_FAST',
+function DwarfOverlay:onResize(w,h)
-    'CURSOR_UP_Z', 'CURSOR_DOWN_Z', 'CURSOR_UP_Z_AUX', 'CURSOR_DOWN_Z_AUX'
+    self:updateLayout()
-}
+end
+
+function DwarfOverlay:getViewport(old_vp)
+    if old_vp then
+        return old_vp:resize(self.df_layout)
+    else
+        return Viewport.get(self.df_layout)
+    end
+end
 
 function DwarfOverlay:propagateMoveKeys(keys)
-    for _,v in ipairs(move_keys) do
+    for code,_ in pairs(MOVEMENT_KEYS) do
-        if keys[v] then
+        if keys[code] then
-            self:sendInputToParent(v)
+            self:sendInputToParent(code)
-            return v
+            return code
+        end
+    end
+end
+
+function DwarfOverlay:simulateViewScroll(keys, anchor, no_clip_cursor)
+    local layout = self.df_layout
+    local cursor = getCursorPos()
+
+    anchor = anchor or cursor
+
+    if anchor and keys.A_MOVE_SAME_SQUARE then
+        self:getViewport():centerOn(anchor):set()
+        return 'A_MOVE_SAME_SQUARE'
+    end
+
+    for code,_ in pairs(MOVEMENT_KEYS) do
+        if keys[code] then
+            local vp = self:getViewport():scrollByKey(code)
+            if (cursor and not no_clip_cursor) or no_clip_cursor == false then
+                vp = vp:reveal(anchor,4,20,4,true)
+            end
+            vp:set()
+
+            return code
         end
     end
 end

scripts/gui/mechanisms.lua

@@ -8,11 +8,19 @@ function getBuildingName(building)
     return utils.call_with_string(building, 'getName')
 end
 
+function getBuildingCenter(building)
+    return xyz2pos(building.centerx, building.centery, building.z)
+end
+
 function listMechanismLinks(building)
     local lst = {}
     local function push(item, mode)
         if item then
-            lst[#lst+1] = { obj = item, name = getBuildingName(item), mode = mode }
+            lst[#lst+1] = {
+                obj = item, mode = mode,
+                name = getBuildingName(item),
+                center = getBuildingCenter(item)
+            }
         end
     end
 
@@ -55,7 +63,7 @@ end
 function MechanismList:init(building)
     local links = listMechanismLinks(building)
 
-    links[1].viewport = guidm.getViewportPos()
+    links[1].viewport = self:getViewport()
     links[1].cursor = guidm.getCursorPos()
     if #links <= 1 then
         links[1].mode = 'none'
@@ -95,18 +103,16 @@ function MechanismList:onRenderBody(dc)
     dc:string("Enter", COLOR_LIGHTGREEN):string(": Switch")
 end
 
-function MechanismList:zoomToLink(link)
+function MechanismList:zoomToLink(link,back)
-    self:updateLayout()
-
     df.global.world.selected_building = link.obj
 
-    local cursor = link.cursor
+    if back then
-    if not cursor then
+        guidm.setCursorPos(link.cursor)
-        cursor = xyz2pos(link.obj.centerx, link.obj.centery, link.obj.z)
+        self:getViewport(link.viewport):set()
+    else
+        guidm.setCursorPos(link.center)
+        self:getViewport():reveal(link.center, 5, 0, 10):set()
     end
-    guidm.setCursorPos(cursor)
-
-    guidm.revealInViewport(cursor, 5, link.viewport, self.df_layout)
 end
 
 function MechanismList:changeSelected(delta)
@@ -116,22 +122,23 @@ function MechanismList:changeSelected(delta)
 end
 
 function MechanismList:onInput(keys)
-    if keys.STANDARDSCROLL_UP or keys.SECONDSCROLL_UP then
+    if keys.SECONDSCROLL_UP then
         self:changeSelected(-1)
-    elseif keys.STANDARDSCROLL_DOWN or keys.SECONDSCROLL_DOWN then
+    elseif keys.SECONDSCROLL_DOWN then
         self:changeSelected(1)
     elseif keys.LEAVESCREEN then
         self:dismiss()
         if self.selected ~= 1 then
-            self:zoomToLink(self.links[1])
+            self:zoomToLink(self.links[1], true)
         end
     elseif keys.SELECT_ALL then
         if self.selected > 1 then
             self:init(self.links[self.selected].obj)
-            self.invalidate()
         end
     elseif keys.SELECT then
         self:dismiss()
+    elseif self:simulateViewScroll(keys) then
+        return
     end
 end