470 lines
16 KiB
Lua
470 lines
16 KiB
Lua
---------------------------------------------------------------------------
|
|
--- Handling of drawables. A drawable is something that can be drawn to.
|
|
--
|
|
-- @author Uli Schlachter
|
|
-- @copyright 2012 Uli Schlachter
|
|
-- @release @AWESOME_VERSION@
|
|
-- @classmod wibox.drawable
|
|
---------------------------------------------------------------------------
|
|
|
|
local drawable = {}
|
|
local capi = {
|
|
awesome = awesome,
|
|
root = root,
|
|
screen = screen
|
|
}
|
|
local beautiful = require("beautiful")
|
|
local cairo = require("lgi").cairo
|
|
local color = require("gears.color")
|
|
local object = require("gears.object")
|
|
local surface = require("gears.surface")
|
|
local timer = require("gears.timer")
|
|
local grect = require("gears.geometry").rectangle
|
|
local matrix = require("gears.matrix")
|
|
local hierarchy = require("wibox.hierarchy")
|
|
local unpack = unpack or table.unpack -- luacheck: globals unpack (compatibility with Lua 5.1)
|
|
|
|
local drawables_draw = setmetatable({}, { __mode = 'k' })
|
|
local drawables_force_complete_repaint = setmetatable({}, { __mode = 'k' })
|
|
|
|
-- Get the widget context. This should always return the same table (if
|
|
-- possible), so that our draw and fit caches can work efficiently.
|
|
local function get_widget_context(self)
|
|
local geom = self.drawable:geometry()
|
|
|
|
local sgeos = {}
|
|
|
|
for s in capi.screen do
|
|
sgeos[s] = s.geometry
|
|
end
|
|
|
|
local s = grect.get_by_coord(sgeos, geom.x, geom.y) or capi.screen.primary
|
|
|
|
local context = self._widget_context
|
|
local dpi = beautiful.xresources.get_dpi(s)
|
|
if (not context) or context.screen ~= s or context.dpi ~= dpi then
|
|
context = {
|
|
screen = s,
|
|
dpi = dpi,
|
|
drawable = self,
|
|
}
|
|
for k, v in pairs(self._widget_context_skeleton) do
|
|
context[k] = v
|
|
end
|
|
self._widget_context = context
|
|
|
|
-- Give widgets a chance to react to the new context
|
|
self._need_complete_repaint = true
|
|
end
|
|
return context
|
|
end
|
|
|
|
local function do_redraw(self)
|
|
if not self.drawable.valid then return end
|
|
|
|
local surf = surface.load_silently(self.drawable.surface, false)
|
|
-- The surface can be nil if the drawable's parent was already finalized
|
|
if not surf then return end
|
|
local cr = cairo.Context(surf)
|
|
local geom = self.drawable:geometry();
|
|
local x, y, width, height = geom.x, geom.y, geom.width, geom.height
|
|
local context = get_widget_context(self)
|
|
|
|
-- Relayout
|
|
if self._need_relayout or self._need_complete_repaint then
|
|
self._need_relayout = false
|
|
if self._widget_hierarchy and self.widget then
|
|
self._widget_hierarchy:update(context,
|
|
self.widget, width, height, self._dirty_area)
|
|
else
|
|
self._need_complete_repaint = true
|
|
if self.widget then
|
|
self._widget_hierarchy_callback_arg = {}
|
|
self._widget_hierarchy = hierarchy.new(context, self.widget, width, height,
|
|
self._redraw_callback, self._layout_callback, self._widget_hierarchy_callback_arg)
|
|
else
|
|
self._widget_hierarchy = nil
|
|
end
|
|
end
|
|
|
|
if self._need_complete_repaint then
|
|
self._need_complete_repaint = false
|
|
self._dirty_area:union_rectangle(cairo.RectangleInt{
|
|
x = 0, y = 0, width = width, height = height
|
|
})
|
|
end
|
|
end
|
|
|
|
-- Clip to the dirty area
|
|
if self._dirty_area:is_empty() then
|
|
return
|
|
end
|
|
for i = 0, self._dirty_area:num_rectangles() - 1 do
|
|
local rect = self._dirty_area:get_rectangle(i)
|
|
cr:rectangle(rect.x, rect.y, rect.width, rect.height)
|
|
end
|
|
self._dirty_area = cairo.Region.create()
|
|
cr:clip()
|
|
|
|
-- Draw the background
|
|
cr:save()
|
|
|
|
if not capi.awesome.composite_manager_running then
|
|
-- This is pseudo-transparency: We draw the wallpaper in the background
|
|
local wallpaper = surface.load_silently(capi.root.wallpaper(), false)
|
|
if wallpaper then
|
|
cr.operator = cairo.Operator.SOURCE
|
|
cr:set_source_surface(wallpaper, -x, -y)
|
|
cr:paint()
|
|
end
|
|
cr.operator = cairo.Operator.OVER
|
|
else
|
|
-- This is true transparency: We draw a translucent background
|
|
cr.operator = cairo.Operator.SOURCE
|
|
end
|
|
|
|
cr:set_source(self.background_color)
|
|
cr:paint()
|
|
|
|
cr:restore()
|
|
|
|
-- Paint the background image
|
|
if self.background_image then
|
|
cr:save()
|
|
if type(self.background_image) == "function" then
|
|
self.background_image(context, cr, width, height, unpack(self.background_image_args))
|
|
else
|
|
local pattern = cairo.Pattern.create_for_surface(self.background_image)
|
|
cr:set_source(pattern)
|
|
cr:paint()
|
|
end
|
|
cr:restore()
|
|
end
|
|
|
|
-- Draw the widget
|
|
if self._widget_hierarchy then
|
|
cr:set_source(self.foreground_color)
|
|
self._widget_hierarchy:draw(context, cr)
|
|
end
|
|
|
|
self.drawable:refresh()
|
|
|
|
assert(cr.status == "SUCCESS", "Cairo context entered error state: " .. cr.status)
|
|
end
|
|
|
|
local function find_widgets(_drawable, result, _hierarchy, x, y)
|
|
local m = _hierarchy:get_matrix_from_device()
|
|
|
|
-- Is (x,y) inside of this hierarchy or any child (aka the draw extents)
|
|
local x1, y1 = m:transform_point(x, y)
|
|
local x2, y2, w2, h2 = _hierarchy:get_draw_extents()
|
|
if x1 < x2 or x1 >= x2 + w2 then
|
|
return
|
|
end
|
|
if y1 < y2 or y1 >= y2 + h2 then
|
|
return
|
|
end
|
|
|
|
-- Is (x,y) inside of this widget?
|
|
local width, height = _hierarchy:get_size()
|
|
if x1 >= 0 and y1 >= 0 and x1 <= width and y1 <= height then
|
|
-- Get the extents of this widget in the device space
|
|
local x3, y3, w3, h3 = matrix.transform_rectangle(_hierarchy:get_matrix_to_device(),
|
|
0, 0, width, height)
|
|
table.insert(result, {
|
|
x = x3, y = y3, width = w3, height = h3,
|
|
drawable = _drawable, widget = _hierarchy:get_widget(),
|
|
matrix_to_device = _hierarchy:get_matrix_to_device(),
|
|
matrix_to_parent = _hierarchy:get_matrix_to_parent(),
|
|
})
|
|
end
|
|
for _, child in ipairs(_hierarchy:get_children()) do
|
|
find_widgets(_drawable, result, child, x, y)
|
|
end
|
|
end
|
|
|
|
--- Find a widget by a point.
|
|
-- The drawable must have drawn itself at least once for this to work.
|
|
-- @param x X coordinate of the point
|
|
-- @param y Y coordinate of the point
|
|
-- @return A sorted table with all widgets that contain the given point. The
|
|
-- widgets are sorted by relevance.
|
|
function drawable:find_widgets(x, y)
|
|
local result = {}
|
|
if self._widget_hierarchy then
|
|
find_widgets(self, result, self._widget_hierarchy, x, y)
|
|
end
|
|
return result
|
|
end
|
|
|
|
|
|
--- Set the widget that the drawable displays
|
|
function drawable:set_widget(widget)
|
|
self.widget = widget
|
|
|
|
-- Make sure the widget gets drawn
|
|
self._need_relayout = true
|
|
self.draw()
|
|
end
|
|
|
|
--- Set the background of the drawable
|
|
-- @param c The background to use. This must either be a cairo pattern object,
|
|
-- nil or a string that gears.color() understands.
|
|
function drawable:set_bg(c)
|
|
c = c or "#000000"
|
|
local t = type(c)
|
|
|
|
if t == "string" or t == "table" then
|
|
c = color(c)
|
|
end
|
|
|
|
-- If the background is completely opaque, we don't need to redraw when
|
|
-- the drawable is moved
|
|
-- XXX: This isn't needed when awesome.composite_manager_running is true,
|
|
-- but a compositing manager could stop/start and we'd have to properly
|
|
-- handle this. So for now we choose the lazy approach.
|
|
local redraw_on_move = not color.create_opaque_pattern(c)
|
|
if self._redraw_on_move ~= redraw_on_move then
|
|
self._redraw_on_move = redraw_on_move
|
|
if redraw_on_move then
|
|
self.drawable:connect_signal("property::x", self._do_complete_repaint)
|
|
self.drawable:connect_signal("property::y", self._do_complete_repaint)
|
|
else
|
|
self.drawable:disconnect_signal("property::x", self._do_complete_repaint)
|
|
self.drawable:disconnect_signal("property::y", self._do_complete_repaint)
|
|
end
|
|
end
|
|
|
|
self.background_color = c
|
|
self._do_complete_repaint()
|
|
end
|
|
|
|
--- Set the background image of the drawable
|
|
-- If `image` is a function, it will be called with `(context, cr, width, height)`
|
|
-- as arguments. Any other arguments passed to this method will be appended.
|
|
-- @param image A background image or a function
|
|
function drawable:set_bgimage(image, ...)
|
|
if type(image) ~= "function" then
|
|
image = surface(image)
|
|
end
|
|
|
|
self.background_image = image
|
|
self.background_image_args = {...}
|
|
|
|
self._do_complete_repaint()
|
|
end
|
|
|
|
--- Set the foreground of the drawable
|
|
-- @param c The foreground to use. This must either be a cairo pattern object,
|
|
-- nil or a string that gears.color() understands.
|
|
function drawable:set_fg(c)
|
|
c = c or "#FFFFFF"
|
|
if type(c) == "string" or type(c) == "table" then
|
|
c = color(c)
|
|
end
|
|
self.foreground_color = c
|
|
self._do_complete_repaint()
|
|
end
|
|
|
|
function drawable:_inform_visible(visible)
|
|
end
|
|
|
|
local function emit_difference(name, list, skip)
|
|
local function in_table(table, val)
|
|
for _, v in pairs(table) do
|
|
if v.widget == val.widget then
|
|
return true
|
|
end
|
|
end
|
|
return false
|
|
end
|
|
|
|
for _, v in pairs(list) do
|
|
if not in_table(skip, v) then
|
|
v.widget:emit_signal(name,v)
|
|
end
|
|
end
|
|
end
|
|
|
|
local function handle_leave(_drawable)
|
|
emit_difference("mouse::leave", _drawable._widgets_under_mouse, {})
|
|
_drawable._widgets_under_mouse = {}
|
|
end
|
|
|
|
local function handle_motion(_drawable, x, y)
|
|
if x < 0 or y < 0 or x > _drawable.drawable:geometry().width or y > _drawable.drawable:geometry().height then
|
|
return handle_leave(_drawable)
|
|
end
|
|
|
|
-- Build a plain list of all widgets on that point
|
|
local widgets_list = _drawable:find_widgets(x, y)
|
|
|
|
-- First, "leave" all widgets that were left
|
|
emit_difference("mouse::leave", _drawable._widgets_under_mouse, widgets_list)
|
|
-- Then enter some widgets
|
|
emit_difference("mouse::enter", widgets_list, _drawable._widgets_under_mouse)
|
|
|
|
_drawable._widgets_under_mouse = widgets_list
|
|
end
|
|
|
|
local function setup_signals(_drawable)
|
|
local d = _drawable.drawable
|
|
|
|
local function clone_signal(name)
|
|
-- When "name" is emitted on wibox.drawin, also emit it on wibox
|
|
d:connect_signal(name, function(_, ...)
|
|
_drawable:emit_signal(name, ...)
|
|
end)
|
|
end
|
|
clone_signal("button::press")
|
|
clone_signal("button::release")
|
|
clone_signal("mouse::enter")
|
|
clone_signal("mouse::leave")
|
|
clone_signal("mouse::move")
|
|
clone_signal("property::surface")
|
|
clone_signal("property::width")
|
|
clone_signal("property::height")
|
|
clone_signal("property::x")
|
|
clone_signal("property::y")
|
|
end
|
|
|
|
function drawable.new(d, widget_context_skeleton, drawable_name)
|
|
local ret = object()
|
|
ret.drawable = d
|
|
ret._widget_context_skeleton = widget_context_skeleton
|
|
ret._need_complete_repaint = true
|
|
ret._need_relayout = true
|
|
ret._dirty_area = cairo.Region.create()
|
|
setup_signals(ret)
|
|
|
|
for k, v in pairs(drawable) do
|
|
if type(v) == "function" then
|
|
ret[k] = v
|
|
end
|
|
end
|
|
|
|
-- Only redraw a drawable once, even when we get told to do so multiple times.
|
|
ret._redraw_pending = false
|
|
ret._do_redraw = function()
|
|
ret._redraw_pending = false
|
|
do_redraw(ret)
|
|
end
|
|
|
|
-- Connect our signal when we need a redraw
|
|
ret.draw = function()
|
|
if not ret._redraw_pending then
|
|
timer.delayed_call(ret._do_redraw)
|
|
ret._redraw_pending = true
|
|
end
|
|
end
|
|
ret._do_complete_repaint = function()
|
|
ret._need_complete_repaint = true
|
|
ret:draw()
|
|
end
|
|
drawables_draw[ret.draw] = true
|
|
drawables_force_complete_repaint[ret._do_complete_repaint] = true
|
|
|
|
-- Do a full redraw if the surface changes (the new surface has no content yet)
|
|
d:connect_signal("property::surface", ret._do_complete_repaint)
|
|
|
|
-- Do a normal redraw when the drawable moves. This will likely do nothing
|
|
-- in most cases, but it makes us do a complete repaint when we are moved to
|
|
-- a different screen.
|
|
d:connect_signal("property::x", ret.draw)
|
|
d:connect_signal("property::y", ret.draw)
|
|
|
|
-- Currently we aren't redrawing on move (signals not connected).
|
|
-- :set_bg() will later recompute this.
|
|
ret._redraw_on_move = false
|
|
|
|
-- Set the default background
|
|
ret:set_bg(beautiful.bg_normal)
|
|
ret:set_fg(beautiful.fg_normal)
|
|
|
|
-- Initialize internals
|
|
ret._widgets_under_mouse = {}
|
|
|
|
local function button_signal(name)
|
|
d:connect_signal(name, function(_, x, y, button, modifiers)
|
|
local widgets = ret:find_widgets(x, y)
|
|
for _, v in pairs(widgets) do
|
|
-- Calculate x/y inside of the widget
|
|
local lx = x - v.x
|
|
local ly = y - v.y
|
|
v.widget:emit_signal(name, lx, ly, button, modifiers,v)
|
|
end
|
|
end)
|
|
end
|
|
button_signal("button::press")
|
|
button_signal("button::release")
|
|
|
|
d:connect_signal("mouse::move", function(_, x, y) handle_motion(ret, x, y) end)
|
|
d:connect_signal("mouse::leave", function() handle_leave(ret) end)
|
|
|
|
-- Set up our callbacks for repaints
|
|
ret._redraw_callback = function(hierar, arg)
|
|
-- XXX: lgi will lead us into memory-corruption-land when we use an
|
|
-- object after it was GC'd. Try to detect this situation by checking if
|
|
-- the drawable is still valid. This is only a weak indication, but it
|
|
-- seems to be the best that we can do. The problem is that the drawable
|
|
-- could not yet be GC'd, but is pending finalisation, while the
|
|
-- cairo.Region below was already GC'd. This would still lead to corruption.
|
|
if not ret.drawable.valid then
|
|
return
|
|
end
|
|
if ret._widget_hierarchy_callback_arg ~= arg then
|
|
return
|
|
end
|
|
local m = hierar:get_matrix_to_device()
|
|
local x, y, width, height = matrix.transform_rectangle(m, hierar:get_draw_extents())
|
|
local x1, y1 = math.floor(x), math.floor(y)
|
|
local x2, y2 = math.ceil(x + width), math.ceil(y + height)
|
|
ret._dirty_area:union_rectangle(cairo.RectangleInt{
|
|
x = x1, y = y1, width = x2 - x1, height = y2 - y1
|
|
})
|
|
ret:draw()
|
|
end
|
|
ret._layout_callback = function(_, arg)
|
|
if ret._widget_hierarchy_callback_arg ~= arg then
|
|
return
|
|
end
|
|
ret._need_relayout = true
|
|
ret:draw()
|
|
end
|
|
|
|
-- Add __tostring method to metatable.
|
|
ret.drawable_name = drawable_name or object.modulename(3)
|
|
local mt = {}
|
|
local orig_string = tostring(ret)
|
|
mt.__tostring = function()
|
|
return string.format("%s (%s)", ret.drawable_name, orig_string)
|
|
end
|
|
ret = setmetatable(ret, mt)
|
|
|
|
-- Make sure the drawable is drawn at least once
|
|
ret._do_complete_repaint()
|
|
|
|
return ret
|
|
end
|
|
|
|
-- Redraw all drawables when the wallpaper changes
|
|
capi.awesome.connect_signal("wallpaper_changed", function()
|
|
for k in pairs(drawables_force_complete_repaint) do
|
|
k()
|
|
end
|
|
end)
|
|
|
|
-- Give drawables a chance to react to screen changes
|
|
local function draw_all()
|
|
for k in pairs(drawables_draw) do
|
|
k()
|
|
end
|
|
end
|
|
screen.connect_signal("property::geometry", draw_all)
|
|
screen.connect_signal("added", draw_all)
|
|
screen.connect_signal("removed", draw_all)
|
|
|
|
return setmetatable(drawable, { __call = function(_, ...) return drawable.new(...) end })
|
|
|
|
-- vim: filetype=lua:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80
|