if view then

view.visible = vis

end

if tab then

return tab[idx]

else

return idx

end

if self.frame_background then

dc:fill(rect, self.frame_background)

end

if not self.drag_anchors then

self.drag_anchors = {title=true, frame=false, body=true}

end

if not self.resize_anchors then

self.resize_anchors = {t=false, l=true, r=true, b=true}

end

self.resize_min = self.resize_min or {}

self.resize_min.w = self.resize_min.w or (self.frame or {}).w or 5

self.resize_min.h = self.resize_min.h or (self.frame or {}).h or 5

self.kbd_get_pos = nil -- fn when we are in keyboard dragging mode

self.saved_frame = nil -- copy of frame when dragging started

self.saved_frame_rect = nil -- copy of frame_rect when dragging started

self.drag_offset = nil -- relative pos of held panel tile

self.resize_edge = nil -- which dimension is being resized?

self.last_title_click_ms = 0 -- used to track double-clicking on the title

self:addviews(args.subviews)

if clear_state then

self.kbd_get_pos = nil

self.saved_frame = nil

self.saved_frame_rect = nil

self.drag_offset = nil

self.resize_edge = nil

end

if not frame then return end

if self.frame.l == frame.l and self.frame.r == frame.r

and self.frame.t == frame.t and self.frame.b == frame.b

and self.frame.w == frame.w and self.frame.h == frame.h then

return

end

self.frame = frame

self:updateLayout()

opposite_anchor, max_dim, wanted_dim,

max_anchor, wanted_anchor)

frame[dim] = math.max(resize_min[dim], math.min(max_dim, wanted_dim))

if frame[anchor] or not frame[opposite_anchor] then

frame[anchor] = math.max(0, math.min(max_anchor, wanted_anchor))

end

opposite_anchor, dim_base, dim_ref, anchor_ref,

dim_far, mouse_ref)

local dim_sign = (anchor == 't' or anchor == 'l') and 1 or -1

local max_dim = dim_base - dim_ref + 1

local wanted_dim = dim_sign * (dim_far - mouse_ref) + 1

local max_anchor = dim_base - resize_min[dim] - dim_ref + 1

local wanted_anchor = dim_sign * (mouse_ref - anchor_ref)

Panel_resize_edge_base(frame, resize_min, dim, anchor, opposite_anchor,

max_dim, wanted_dim, max_anchor, wanted_anchor)

local frame, resize_min = copyall(self.frame), self.resize_min

local parent_rect = self.frame_parent_rect

local ref_rect = self.saved_frame_rect

if self.resize_edge:find('t') then

Panel_resize_edge(frame, resize_min, 'h', 't', 'b', ref_rect.y2,

parent_rect.y1, parent_rect.y1, ref_rect.y2, mouse_pos.y)

end

if self.resize_edge:find('b') then

Panel_resize_edge(frame, resize_min, 'h', 'b', 't', parent_rect.y2,

ref_rect.y1, parent_rect.y2, ref_rect.y1, mouse_pos.y)

end

if self.resize_edge:find('l') then

Panel_resize_edge(frame, resize_min, 'w', 'l', 'r', ref_rect.x2,

parent_rect.x1, parent_rect.x1, ref_rect.x2, mouse_pos.x)

end

if self.resize_edge:find('r') then

Panel_resize_edge(frame, resize_min, 'w', 'r', 'l', parent_rect.x2,

ref_rect.x1, parent_rect.x2, ref_rect.x1, mouse_pos.x)

end

return frame

local frame = copyall(self.frame)

local parent_rect, frame_rect = self.frame_parent_rect, self.frame_rect

local bound_rect = self.drag_bound == 'body' and self.frame_body

or frame_rect

local offset = self.drag_offset

local max_width = parent_rect.width - (bound_rect.x2-frame_rect.x1+1)

local max_height = parent_rect.height - (bound_rect.y2-frame_rect.y1+1)

if frame.t or not frame.b then

local min_pos = frame_rect.y1 - bound_rect.y1

local requested_pos = mouse_pos.y - parent_rect.y1 - offset.y

frame.t = math.max(min_pos, math.min(max_height, requested_pos))

end

if frame.b or not frame.t then

local min_pos = bound_rect.y2 - frame_rect.y2

local requested_pos = parent_rect.y2 - mouse_pos.y + offset.y -

(frame_rect.y2 - frame_rect.y1)

frame.b = math.max(min_pos, math.min(max_height, requested_pos))

end

if frame.l or not frame.r then

local min_pos = frame_rect.x1 - bound_rect.x1

local requested_pos = mouse_pos.x - parent_rect.x1 - offset.x

frame.l = math.max(min_pos, math.min(max_width, requested_pos))

end

if frame.r or not frame.l then

local min_pos = bound_rect.x2 - frame_rect.x2

local requested_pos = parent_rect.x2 - mouse_pos.x + offset.x -

(frame_rect.x2 - frame_rect.x1)

frame.r = math.max(min_pos, math.min(max_width, requested_pos))

end

return frame

mouse_pos = mouse_pos or xy2pos(dfhack.screen.getMousePos())

return self.resize_edge and Panel_resize_frame(self, mouse_pos)

or Panel_drag_frame(self, mouse_pos)

Panel_update_frame(self, nil, true)

self.drag_offset = drag_offset or {x=0, y=0}

self.resize_edge = resize_edge

self.saved_frame = copyall(self.frame)

self.saved_frame_rect = copyall(self.frame_rect)

self.prev_focus_owner = self.focus_group.cur

self:setFocus(true)

if self.resize_edge then

if self.on_resize_begin then self.on_resize_begin(success) end

else

if self.on_drag_begin then self.on_drag_begin(success) end

end

success = not not success

if self.prev_focus_owner then

self.prev_focus_owner:setFocus(true)

else

self:setFocus(false)

end

Panel_update_frame(self, frame, true)

if self.resize_edge then

if self.on_resize_end then self.on_resize_end(success) end

else

if self.on_drag_end then self.on_drag_end(success) end

end

local a = self.resize_anchors

local can_vert, can_horiz = a.t or a.b, a.l or a.r

if not can_vert and not can_horiz then return false end

local f, rmin = self.frame, self.resize_min

local maximized = f.t == 0 and f.b == 0 and f.l == 0 and f.r == 0

local frame

if maximized then

frame = {

t=not can_vert and f.t or nil,

l=not can_horiz and f.l or nil,

b=not can_vert and f.b or nil,

r=not can_horiz and f.r or nil,

w=can_vert and rmin.w or f.w,

h=can_horiz and rmin.h or f.h,

}

else

frame = {

t=can_vert and 0 or f.t,

l=can_horiz and 0 or f.l,

b=can_vert and 0 or f.b,

r=can_horiz and 0 or f.r

}

end

Panel_update_frame(self, frame, true)

local frame_rect = self.frame_rect

local x,y = dscreen.getMousePos()

return (x == frame_rect.x2-2 or x == frame_rect.x2-1)

and (y == frame_rect.y1-1 or y == frame_rect.y1)

local x,y = Panel.super.getMouseFramePos(self)

if x then return x, y end

if panel_is_pinnable(self) and panel_is_on_pin(self) then

local frame_rect = self.frame_rect

return frame_rect.width - 3, 0

end

if self.kbd_get_pos then

if keys.SELECT or keys.LEAVESCREEN or keys._MOUSE_R_DOWN then

Panel_end_drag(self, not keys.SELECT and self.saved_frame or nil,

not not keys.SELECT)

return true

end

for code in pairs(keys) do

local dx, dy = guidm.get_movement_delta(code, 1, 10)

if dx then

local frame_rect = self.frame_rect

local kbd_pos = self.kbd_get_pos()

kbd_pos.x = kbd_pos.x + dx

kbd_pos.y = kbd_pos.y + dy

Panel_update_frame(self, Panel_make_frame(self, kbd_pos))

return true

end

end

return

end

if self.drag_offset then

if keys._MOUSE_R_DOWN then

Panel_end_drag(self, self.saved_frame)

elseif keys._MOUSE_L then

Panel_update_frame(self, Panel_make_frame(self))

end

return true

end

if panel_is_pinnable(self) and keys._MOUSE_L_DOWN then

if panel_is_on_pin(self) then

self.parent_view:togglePinned()

return true

end

end

if Panel.super.onInput(self, keys) then

return true

end

if not keys._MOUSE_L_DOWN then return end

local x,y = self:getMouseFramePos()

if not x then return end

if self.resizable and y == 0 then

local now_ms = dfhack.getTickCount()

if now_ms - self.last_title_click_ms <= DOUBLE_CLICK_MS then

self.last_title_click_ms = 0

if Panel_on_double_click(self) then return true end

else

self.last_title_click_ms = now_ms

end

end

local resize_edge = nil

if self.resizable then

local rect = self.frame_rect

if self.resize_anchors.r and self.resize_anchors.b

and x == rect.x2 - rect.x1 and y == rect.y2 - rect.y1 then

resize_edge = 'rb'

elseif self.resize_anchors.l and self.resize_anchors.b

and x == 0 and y == rect.y2 - rect.y1 then

resize_edge = 'lb'

elseif self.resize_anchors.r and self.resize_anchors.t

and x == rect.x2 - rect.x1 and y == 0 then

resize_edge = 'rt'

elseif self.resize_anchors.r and self.resize_anchors.t

and x == 0 and y == 0 then

resize_edge = 'lt'

elseif self.resize_anchors.r and x == rect.x2 - rect.x1 then

resize_edge = 'r'

elseif self.resize_anchors.l and x == 0 then

resize_edge = 'l'

elseif self.resize_anchors.b and y == rect.y2 - rect.y1 then

resize_edge = 'b'

elseif self.resize_anchors.t and y == 0 then

resize_edge = 't'

end

end

local is_dragging = false

if not resize_edge and self.draggable then

local on_body = self:getMousePos()

is_dragging = (self.drag_anchors.title and self.frame_style and y == 0)

or (self.drag_anchors.frame and not on_body) -- includes inset

or (self.drag_anchors.body and on_body)

end

if resize_edge or is_dragging then

Panel_begin_drag(self, {x=x, y=y}, resize_edge)

return true

end

if (enabled and self.kbd_get_pos)

or (not enabled and not self.kbd_get_pos) then

return

end

if enabled then

local kbd_get_pos = function()

return {x=self.frame_rect.x1, y=self.frame_rect.y1}

end

Panel_begin_drag(self)

self.kbd_get_pos = kbd_get_pos

else

Panel_end_drag(self)

end

local resize_anchors = self.resize_anchors

if resize_anchors.r and resize_anchors.b then

return 'rb', function()

return {x=self.frame_rect.x2, y=self.frame_rect.y2} end

elseif resize_anchors.l and resize_anchors.b then

return 'lb', function()

return {x=self.frame_rect.x1, y=self.frame_rect.y2} end

elseif resize_anchors.r and resize_anchors.t then

return 'rt', function()

return {x=self.frame_rect.x2, y=self.frame_rect.y1} end

elseif resize_anchors.l and resize_anchors.t then

return 'lt', function()

return {x=self.frame_rect.x1, y=self.frame_rect.y1} end

elseif resize_anchors.b then

return 'b', function()

return {x=(self.frame_rect.x1+self.frame_rect.x2)/2,

y=self.frame_rect.y2} end

elseif resize_anchors.r then

return 'r', function()

return {x=self.frame_rect.x2,

y=(self.frame_rect.y1+self.frame_rect.y2)/2} end

elseif resize_anchors.l then

return 'l', function()

return {x=self.frame_rect.x1,

y=(self.frame_rect.y1+self.frame_rect.y2)/2} end

elseif resize_anchors.t then

return 't', function()

return {x=(self.frame_rect.x1+self.frame_rect.x2)/2,

y=self.frame_rect.y1} end

end

if (enabled and self.kbd_get_pos)

or (not enabled and not self.kbd_get_pos) then

return

end

if enabled then

local resize_edge, kbd_get_pos = Panel_get_resize_data(self)

if not resize_edge then

dfhack.printerr('cannot resize window: no anchors are enabled')

else

Panel_begin_drag(self, kbd_get_pos(), resize_edge)

self.kbd_get_pos = kbd_get_pos

end

else

Panel_end_drag(self)

end

local sw, sh = parent_rect.width, parent_rect.height

if self.frame then

if self.frame.t and self.frame.h and self.frame.t + self.frame.h > sh then

self.frame.t = math.max(0, sh - self.frame.h)

end

if self.frame.b and self.frame.h and self.frame.b + self.frame.h > sh then

self.frame.b = math.max(0, sh - self.frame.h)

end

if self.frame.l and self.frame.w and self.frame.l + self.frame.w > sw then

self.frame.l = math.max(0, sw - self.frame.w)

end

if self.frame.r and self.frame.w and self.frame.r + self.frame.w > sw then

self.frame.r = math.max(0, sw - self.frame.w)

end

end

return gui.compute_frame_body(sw, sh, self.frame, self.frame_inset,

self.frame_style and 1 or 0)

-- don't leave artifacts behind on the parent screen when we move

gui.Screen.request_full_screen_refresh = true

if not self.autoarrange_subviews then return end

local gap = self.autoarrange_gap

local y = 0

for _,subview in ipairs(self.subviews) do

if not subview.frame then goto continue end

subview.frame.t = y

if getval(subview.visible) then

y = y + (subview.frame.h or 0) + gap

end

::continue::

end

self.frame_rect.height = y

-- let widgets adjust to their new positions

self:updateSubviewLayout()

Panel.super.onRenderFrame(self, dc, rect)

if not self.frame_style then return end

local pinned = nil

if self.pinnable then

pinned = self.parent_view and self.parent_view.pinned

end

local inactive = self.parent_view and self.parent_view.isOnTop

and not self.parent_view:isOnTop()

gui.paint_frame(dc, rect, self.frame_style, self.frame_title,

self.pinnable, pinned, inactive)

if self.kbd_get_pos then

local pos = self.kbd_get_pos()

local pen = to_pen{fg=COLOR_GREEN, bg=COLOR_BLACK}

dc:seek(pos.x, pos.y):pen(pen):char(string.char(0xDB))

end

if self.drag_offset and not self.kbd_get_pos

and df.global.enabler.mouse_lbut == 0 then

Panel_end_drag(self, nil, true)

end

local w, h = 0, 0

for _,s in ipairs(self.subviews) do

if getval(s.visible) then

w = math.max(w, (s.frame and s.frame.l or 0) +

(s.frame and s.frame.w or frame_body.width))

h = math.max(h, (s.frame and s.frame.t or 0) +

(s.frame and s.frame.h or frame_body.height))

end

end

local l,t,r,b = gui.parse_inset(self.frame_inset)

w = w + l + r

h = h + t + b

if self.frame_style then

w = w + 2

h = h + 2

end

if not self.frame then self.frame = {} end

local oldw, oldh = self.frame.w, self.frame.h

if not self.auto_height then h = oldh end

if not self.auto_width then w = oldw end

self.frame.w, self.frame.h = w, h

if not self._updateLayoutGuard and (oldw ~= w or oldh ~= h) then

self._updateLayoutGuard = true -- protect against infinite loops

self:updateLayout() -- our frame has changed, we need to fully refresh

end

self._updateLayoutGuard = nil

for _,v in ipairs(self.subviews) do

v.visible = false

end

self:setSelected(args.selected or 1)

if type(idx) ~= 'number' then

local key = idx

if type(idx) == 'string' then

key = self.subviews[key]

end

idx = utils.linear_index(self.subviews, key)

if not idx then

error('Unknown page: '..tostring(key))

end

end

show_view(self.subviews[self.selected], false)

self.selected = math.min(math.max(1, idx), #self.subviews)

show_view(self.subviews[self.selected], true)

local function on_activate()

self.saved_text = self.text

self:setFocus(true)

end

self.start_pos = 1

self.cursor = #self.text + 1

self:addviews{HotkeyLabel{frame={t=0,l=0},

key=self.key,

key_sep=self.key_sep,

label=self.label_text,

on_activate=self.key and on_activate or nil}}

if not cursor or cursor > #self.text then

self.cursor = #self.text + 1

return

end

self.cursor = math.max(1, cursor)

dc:pen(self.text_pen or COLOR_LIGHTCYAN)

local cursor_char = '_'

if not getval(self.active) or not self.focus or gui.blink_visible(300) then

cursor_char = (self.cursor > #self.text) and ' ' or

self.text:sub(self.cursor, self.cursor)

end

local txt = self.text:sub(1, self.cursor - 1) .. cursor_char ..

self.text:sub(self.cursor + 1)

local max_width = dc.width - self.text_offset

self.start_pos = 1

if #txt > max_width then

-- get the substring in the vicinity of the cursor

max_width = max_width - 2

local half_width = math.floor(max_width/2)

local start_pos = math.max(1, self.cursor-half_width)

local end_pos = math.min(#txt, self.cursor+half_width-1)

if self.cursor + half_width > #txt then

start_pos = #txt - (max_width - 1)

end

if self.cursor - half_width <= 1 then

end_pos = max_width + 1

end

self.start_pos = start_pos > 1 and start_pos - 1 or start_pos

txt = ('%s%s%s'):format(start_pos == 1 and '' or string.char(27),

txt:sub(start_pos, end_pos),

end_pos == #txt and '' or string.char(26))

end

dc:advance(self.text_offset):string(txt)

local old = self.text

self:setText(old:sub(1,self.cursor-1)..text..old:sub(self.cursor),

self.cursor + #text)

if not self.focus then

-- only react to our hotkey

return self:inputToSubviews(keys)

end

if self.ignore_keys then

for _,ignore_key in ipairs(self.ignore_keys) do

if keys[ignore_key] then return false end

end

end

if self.key and (keys.LEAVESCREEN or keys._MOUSE_R_DOWN) then

local old = self.text

self:setText(self.saved_text)

if self.on_change and old ~= self.saved_text then

self.on_change(self.text, old)

end

self:setFocus(false)

return true

end

if keys.SELECT or keys.CUSTOM_SHIFT_ENTER then

if self.key then

self:setFocus(false)

end

if keys.CUSTOM_SHIFT_ENTER then

if self.on_submit2 then

self.on_submit2(self.text)

return true

end

else

if self.on_submit then

self.on_submit(self.text)

return true

end

end

return not not self.key

elseif keys._MOUSE_L then

local mouse_x, mouse_y = self:getMousePos()

if mouse_x then

self:setCursor(self.start_pos + mouse_x - (self.text_offset or 0))

return true

end

elseif keys._STRING then

local old = self.text

if keys._STRING == 0 then

-- handle backspace

local del_pos = self.cursor - 1

if del_pos > 0 then

self:setText(old:sub(1, del_pos-1) .. old:sub(del_pos+1),

del_pos)

end

else

local cv = string.char(keys._STRING)

if not self.on_char or self.on_char(cv, old) then

self:insert(cv)

elseif self.on_char then

return self.modal

end

end

if self.on_change and self.text ~= old then

self.on_change(self.text, old)

end

return true

elseif keys.KEYBOARD_CURSOR_LEFT then

self:setCursor(self.cursor - 1)

return true

elseif keys.CUSTOM_CTRL_B then -- back one word

local _, prev_word_end = self.text:sub(1, self.cursor-1):

find('.*[%w_%-][^%w_%-]')

self:setCursor(prev_word_end or 1)

return true

elseif keys.CUSTOM_CTRL_A then -- home

self:setCursor(1)

return true

elseif keys.KEYBOARD_CURSOR_RIGHT then

self:setCursor(self.cursor + 1)

return true

elseif keys.CUSTOM_CTRL_F then -- forward one word

local _,next_word_start = self.text:find('[^%w_%-][%w_%-]', self.cursor)

self:setCursor(next_word_start)

return true

elseif keys.CUSTOM_CTRL_E then -- end

self:setCursor()

return true

end

-- if we're modal, then unconditionally eat all the input

return self.modal

self.last_scroll_ms = 0

self.is_first_click = false

self.scroll_spec = nil

self.is_dragging = false -- index of the scrollbar tile that we're dragging

self:update(1, 1, 1)

local frame_body = scrollbar.frame_body

local scrollbar_body_height = (frame_body and frame_body.height or 3) - 2

local height = math.max(1, math.floor(

(math.min(scrollbar.elems_per_page, scrollbar.num_elems) * scrollbar_body_height) /

scrollbar.num_elems))

return scrollbar_body_height - height, height

if not top_elem then error('must specify index of new top element') end

elems_per_page = elems_per_page or self.elems_per_page

num_elems = num_elems or self.num_elems

self.top_elem = top_elem

self.elems_per_page, self.num_elems = elems_per_page, num_elems

local max_pos, height = scrollbar_get_max_pos_and_height(self)

local pos = (num_elems == elems_per_page) and 0 or

math.ceil(((top_elem-1) * max_pos) /

(num_elems - elems_per_page))

self.bar_offset, self.bar_height = pos, height

local _,y = scrollbar.frame_body:localXY(dfhack.screen.getMousePos())

local cur_pos = y - scrollbar.is_dragging

local max_top = scrollbar.num_elems - scrollbar.elems_per_page + 1

local max_pos = scrollbar_get_max_pos_and_height(scrollbar)

local new_top_elem = math.floor(cur_pos * max_top / max_pos) + 1

new_top_elem = math.max(1, math.min(new_top_elem, max_top))

if new_top_elem ~= scrollbar.top_elem then

scrollbar.on_scroll(new_top_elem)

end