376 lines
13 KiB
Lua
376 lines
13 KiB
Lua
local capi = {screen=screen, mouse = mouse}
|
|
local unpack = unpack or table.unpack
|
|
local mouse = require( "awful.mouse" )
|
|
local screen = require( "awful.screen" )
|
|
local cairo = require( "lgi" ).cairo
|
|
|
|
local module = {}
|
|
|
|
-- Compute the new `x` and `y`.
|
|
-- The workarea position need to be applied by the caller
|
|
local map = {
|
|
top_left = function(sw, sh, dw, dh) return {x=0 , y=0 } end,
|
|
top_right = function(sw, sh, dw, dh) return {x=sw-dw , y=0 } end,
|
|
bottom_left = function(sw, sh, dw, dh) return {x=0 , y=sh-dh } end,
|
|
bottom_right = function(sw, sh, dw, dh) return {x=sw-dw , y=sh-dh } end,
|
|
left = function(sw, sh, dw, dh) return {x=0 , y=sh/2-dh/2} end,
|
|
right = function(sw, sh, dw, dh) return {x=sw-dw , y=sh/2-dh/2} end,
|
|
top = function(sw, sh, dw, dh) return {x=sw/2-dw/2, y=0 } end,
|
|
bottom = function(sw, sh, dw, dh) return {x=sw/2-dw/2, y=sh-dh } end,
|
|
centered = function(sw, sh, dw, dh) return {x=sw/2-dw/2, y=sh/2-dh/2} end,
|
|
center_vertical = function(sw, sh, dw, dh) return {x= nil , y=sh-dh } end,
|
|
center_horizontal = function(sw, sh, dw, dh) return {x=sw/2-dw/2, y= nil } end,
|
|
}
|
|
|
|
-- Store function -> keys
|
|
local reverse_map = {}
|
|
|
|
-- Create the geometry rectangle 1=best case, 2=fallback
|
|
local positions = {
|
|
left1 = function(r, w, h) return {x=r.x-w , y=r.y } end,
|
|
left2 = function(r, w, h) return {x=r.x-w , y=r.y-h+r.height } end,
|
|
right1 = function(r, w, h) return {x=r.x , y=r.y } end,
|
|
right2 = function(r, w, h) return {x=r.x , y=r.y-h+r.height } end,
|
|
top1 = function(r, w, h) return {x=r.x , y=r.y-h } end,
|
|
top2 = function(r, w, h) return {x=r.x-w+r.width, y=r.y-h } end,
|
|
bottom1 = function(r, w, h) return {x=r.x , y=r.y } end,
|
|
bottom2 = function(r, w, h) return {x=r.x-w+r.width, y=r.y } end,
|
|
}
|
|
|
|
-- Check if the proposed geometry fit in the screen
|
|
local function fit_in_screen(s, geo)
|
|
local sgeo = capi.screen[s].geometry
|
|
local region = cairo.Region.create_rectangle(cairo.RectangleInt(sgeo))
|
|
|
|
region:intersect(cairo.Region.create_rectangle(
|
|
cairo.RectangleInt(geo)
|
|
))
|
|
|
|
local geo2 = region:get_rectangle(0)
|
|
|
|
-- If the geometry is the same, then it fit, else, it will be cropped
|
|
--TODO in case all directions are cropped, keep the least cropped one
|
|
return geo2.width == geo.width and geo2.height == geo.height
|
|
end
|
|
|
|
--- Move the drawable (client or wibox) `d` to a screen position or side.
|
|
--
|
|
-- Supported positions are:
|
|
--
|
|
-- * top_left
|
|
-- * top_right
|
|
-- * bottom_left
|
|
-- * bottom_right
|
|
-- * left
|
|
-- * right
|
|
-- * top
|
|
-- * bottom
|
|
-- * centered
|
|
-- * center_vertical
|
|
-- * center_horizontal
|
|
--
|
|
-- The valid other arguments are:
|
|
--
|
|
-- * *honor_workarea*: Take workarea into account when placing the drawable (default: false)
|
|
--
|
|
-- @param drawable A drawable (like `client` or `wibox`)
|
|
-- @tparam string position One of the position mentionned above
|
|
-- @param[opt=d.screen or capi.mouse.screen] parent The parent geometry
|
|
-- @tparam[opt={}] table args Other arguments
|
|
function module.align(drawable, position, parent, args)
|
|
args = args or {}
|
|
parent = parent or drawable.screen or capi.mouse.screen
|
|
|
|
|
|
-- Get the parent geometry
|
|
local parent_type = type(parent)
|
|
|
|
local sgeo = (parent_type == "screen" or parent_type == "number") and
|
|
capi.screen[parent][args.honor_workarea and "workarea" or "geometry"] or
|
|
parent:geometry()
|
|
|
|
local dgeo = drawable:geometry()
|
|
|
|
local pos = map[position](sgeo.width, sgeo.height, dgeo.width, dgeo.height)
|
|
|
|
drawable : geometry {
|
|
x = pos.x and math.ceil(sgeo.x + pos.x) or dgeo.x,
|
|
y = pos.y and math.ceil(sgeo.y + pos.y) or dgeo.y,
|
|
width = math.ceil(dgeo.width ) ,
|
|
height = math.ceil(dgeo.height ) ,
|
|
}
|
|
end
|
|
|
|
-- Create many placement functions
|
|
for k,v in pairs(map) do
|
|
module[k] = function(d, p, args)
|
|
module.align(d, k, p, args)
|
|
end
|
|
|
|
reverse_map[module[k]] = k
|
|
end
|
|
|
|
--- Pin a drawable to a placement function.
|
|
-- Automatically update the position when the size change.
|
|
-- All other arguments will be passed to the `position` function (if any)
|
|
-- @param drawable A drawable (like `client` or `wibox`)
|
|
-- @param position A position name (see `align`) or a position function
|
|
function module.attach(drawable, position, ...)
|
|
if type(position) == "string" then
|
|
position = module[position]
|
|
end
|
|
|
|
if not position then return end
|
|
|
|
local args = {...}
|
|
|
|
local function tracker()
|
|
position(drawable, unpack(args))
|
|
end
|
|
|
|
drawable:connect_signal("property::width" , tracker)
|
|
drawable:connect_signal("property::height", tracker)
|
|
|
|
tracker()
|
|
end
|
|
|
|
-- Update the workarea
|
|
local function wibox_update_strut(d, position)
|
|
-- If the drawable isn't visible, remove the struts
|
|
if not d.visible then
|
|
d:struts { left = 0, right = 0, bottom = 0, top = 0 }
|
|
return
|
|
end
|
|
|
|
-- Detect horizontal or vertical drawables
|
|
local geo = d:geometry()
|
|
local vertical = geo.width < geo.height
|
|
|
|
-- Look into the `position` string to find the relevants sides to crop from
|
|
-- the workarea
|
|
local struts = { left = 0, right = 0, bottom = 0, top = 0 }
|
|
|
|
if vertical then
|
|
for k, v in ipairs {"right", "left"} do
|
|
if (not position) or position:match(v) then
|
|
struts[v] = geo.width + 2 * d.border_width
|
|
end
|
|
end
|
|
else
|
|
for k, v in ipairs {"top", "bottom"} do
|
|
if (not position) or position:match(v) then
|
|
struts[v] = geo.height + 2 * d.border_width
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Update the workarea
|
|
d:struts(struts)
|
|
end
|
|
|
|
function module.attach_struts(d, f, ...)
|
|
module.attach(d, f, ...)
|
|
--TODO if there is multiple attach_struts, update them, see `raise_attached_struts`
|
|
|
|
local function tracker()
|
|
wibox_update_strut(d, reverse_map[f])
|
|
end
|
|
|
|
d:connect_signal("property::geometry" , tracker)
|
|
d:connect_signal("property::visible" , tracker)
|
|
|
|
tracker()
|
|
end
|
|
|
|
--- Move a drawable to the "top priority" of attached_structs
|
|
function module.raise_attached_struts()
|
|
|
|
end
|
|
|
|
-- Create a pair of rectangles used to set the relative areas.
|
|
-- v=vertical, h=horizontal
|
|
local function get_cross_sections(abs_geo, mode)
|
|
if not mode or mode == "cursor" then
|
|
-- A 1px cross section centered around the mouse position
|
|
|
|
local coords = capi.mouse.coords()
|
|
return {
|
|
h = {
|
|
x = abs_geo.drawable_geo.x ,
|
|
y = coords.y ,
|
|
width = abs_geo.drawable_geo.width ,
|
|
height = 1 ,
|
|
},
|
|
v = {
|
|
x = coords.x ,
|
|
y = abs_geo.drawable_geo.y ,
|
|
width = 1 ,
|
|
height = abs_geo.drawable_geo.height,
|
|
}
|
|
}
|
|
elseif mode == "widget" then
|
|
-- The widget geometry extended to reach the end of the drawable
|
|
|
|
return {
|
|
h = {
|
|
x = abs_geo.drawable_geo.x ,
|
|
y = abs_geo.y ,
|
|
width = abs_geo.drawable_geo.width ,
|
|
height = abs_geo.height ,
|
|
},
|
|
v = {
|
|
x = abs_geo.x ,
|
|
y = abs_geo.drawable_geo.y ,
|
|
width = abs_geo.width ,
|
|
height = abs_geo.drawable_geo.height,
|
|
}
|
|
}
|
|
elseif mode == "cursor_inside" then
|
|
-- A 1x1 rectangle centered around the mouse position
|
|
|
|
local coords = capi.mouse.coords()
|
|
coords.width,coords.height = 1,1
|
|
return {h=coords, v=coords}
|
|
elseif mode == "widget_inside" then
|
|
-- The widget absolute geometry, unchanged
|
|
|
|
return {h=abs_geo, v=abs_geo}
|
|
end
|
|
|
|
assert(false)
|
|
end
|
|
|
|
--- Get the possible 2D anchor points around a widget geometry.
|
|
-- This take into account the widget drawable (wibox) and try to avoid
|
|
-- overlapping.
|
|
--
|
|
-- Valid arguments are:
|
|
--
|
|
-- * xoffset
|
|
-- * yoffset
|
|
-- * margins: A table with "left", "right", "top" and "bottom" as key or a number
|
|
--
|
|
-- @tparam table geo A geometry table with optional "drawable" member
|
|
-- @tparam[opt="widget"] string mode TODO document
|
|
-- @tparam[opt={}] table args
|
|
function module.get_relative_points(geo, mode, args) --TODO rename regions
|
|
mode = mode or "widget"
|
|
args = args or {}
|
|
|
|
-- Use the mouse position and the wibox/client under it
|
|
if not geo then
|
|
local draw = mouse.drawin_under_pointer()
|
|
geo = draw and draw:geometry() or capi.mouse.coords()
|
|
geo.drawable = draw
|
|
elseif (not geo.drawable) and geo.x and geo.width then
|
|
local coords = capi.mouse.coords()
|
|
|
|
-- Check id the mouse is in the rect
|
|
if coords.x > geo.x and coords.x < geo.x+geo.width and
|
|
coords.y > geo.y and coords.y < geo.y+geo.height then
|
|
geo.drawable = mouse.drawin_under_pointer()
|
|
end
|
|
end
|
|
|
|
-- Get the drawable geometry
|
|
local dpos = geo.drawable and geo.drawable.drawable:geometry() or {x=0, y=0}
|
|
|
|
-- Compute the absolute widget geometry
|
|
local abs_widget_geo = {
|
|
x = dpos.x + geo.x ,
|
|
y = dpos.y + geo.y ,
|
|
width = geo.width ,
|
|
height = geo.height ,
|
|
drawable = geo.drawable ,
|
|
drawable_geo = geo.drawable and dpos or geo,
|
|
}
|
|
|
|
-- Get the comparaison point
|
|
local center_point = mode:match("cursor") and capi.mouse.coords() or {
|
|
x = abs_widget_geo.x + abs_widget_geo.width / 2,
|
|
y = abs_widget_geo.y + abs_widget_geo.height / 2,
|
|
}
|
|
|
|
-- Get widget regions for both axis
|
|
local cs = get_cross_sections(abs_widget_geo, mode)
|
|
|
|
-- Set the offset
|
|
local xoff, yoff = args.xoffset or 0, args.yoffset or 0 --TODO add margins
|
|
|
|
-- Get the 4 closest points from `center_point` around the wibox
|
|
local regions = {
|
|
left = {x = xoff+cs.h.x , y = yoff+cs.h.y },
|
|
right = {x = xoff+cs.h.x+cs.h.width, y = yoff+cs.h.y },
|
|
top = {x = xoff+cs.v.x , y = yoff+cs.v.y },
|
|
bottom = {x = xoff+cs.v.x , y = yoff+cs.v.y+cs.v.height},
|
|
}
|
|
|
|
-- Assume the section is part of a single screen until someone complain.
|
|
-- It is much faster to compute and getting it wrong probably have no side
|
|
-- effects.
|
|
local s = geo.drawable and geo.drawable.screen or screen.getbycoord(
|
|
center_point.x,
|
|
center_point.y
|
|
)
|
|
|
|
-- Compute the distance (dp) between the `center_point` and the sides.
|
|
-- This is only relevant for "cursor" and "cursor_inside" modes.
|
|
for k, v in pairs(regions) do
|
|
local dx, dy = v.x - center_point.x, v.y - center_point.y
|
|
|
|
v.distance = math.sqrt(dx*dx + dy*dy)
|
|
v.width = cs.v.width
|
|
v.height = cs.h.height
|
|
v.screen = s
|
|
end
|
|
|
|
return regions
|
|
end
|
|
|
|
-- @tparam drawable d A wibox or client
|
|
-- @tparam table regions A table with position as key and regions (x,y,w,h) as value
|
|
-- @tparam[opt={}] table preferred_positions The preferred positions (position as key,
|
|
-- and index as value)
|
|
-- @treturn string The choosen position
|
|
function module.move_relative(d, regions, preferred_positions) --TODO inside/outside
|
|
local w,h = d.width, d.height
|
|
|
|
local pref_idx, pref_name = 99, nil
|
|
|
|
local does_fit = {}
|
|
for k,v in pairs(regions) do
|
|
local geo = positions[k..1](v, w, h)
|
|
geo.width, geo.height = w, h
|
|
local fit = fit_in_screen(v.screen, geo)
|
|
|
|
-- Try the other compatible geometry
|
|
if not fit then
|
|
geo = positions[k..2](v, w, h)
|
|
geo.width, geo.height = w, h
|
|
fit = fit_in_screen(v.screen, geo)
|
|
end
|
|
|
|
does_fit[k] = fit and geo or nil
|
|
|
|
if fit and preferred_positions[k] and preferred_positions[k] < pref_idx then
|
|
pref_idx = preferred_positions[k]
|
|
pref_name = k
|
|
end
|
|
|
|
-- No need to continue
|
|
if fit and preferred_positions[k] == 1 then break end
|
|
end
|
|
|
|
local pos_name = pref_name or next(does_fit)
|
|
local pos = does_fit[pos_name]
|
|
|
|
if pos then
|
|
d.x = math.ceil(pos.x)
|
|
d.y = math.ceil(pos.y)
|
|
end
|
|
|
|
return pos_name
|
|
end
|
|
|
|
return module
|