Crylia/crylia-theme
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add overflow widget. The top level folder wibox overrides the default awesome one. Fix bluez crashing awesome when no bluetooth

Browse Source
This commit is contained in:
Kievits Rene
2022-06-02 03:58:13 +02:00
parent f7d7fb1b95
commit 3dfd991456
4 changed files with 1022 additions and 237 deletions
Download Patch File Download Diff File Expand all files Collapse all files

151
awesome/src/dbus/bluetooth_dbus.lua
View File

@@ -1,3 +1,4 @@
local awful = require("awful")
local gears = require("gears")
local dbus_proxy = require("dbus_proxy")
local lgi = require("lgi")
@@ -41,83 +42,91 @@ return function()
end
end
local ObjectManager = dbus_proxy.Proxy:new {
bus = dbus_proxy.Bus.SYSTEM,
name = "org.bluez",
interface = "org.freedesktop.DBus.ObjectManager",
path = "/"
}
awful.spawn.easy_async_with_shell(
"lsusb | grep Bluetooth",
function(stdout)
stdout = stdout:gsub("\n", "")
if stdout ~= "" or stdout == nil then
local ObjectManager = dbus_proxy.Proxy:new {
bus = dbus_proxy.Bus.SYSTEM,
name = "org.bluez",
interface = "org.freedesktop.DBus.ObjectManager",
path = "/"
}
local Adapter = dbus_proxy.Proxy:new {
bus = dbus_proxy.Bus.SYSTEM,
name = "org.bluez",
interface = "org.bluez.Adapter1",
path = "/org/bluez/hci0"
}
local Adapter = dbus_proxy.Proxy:new {
bus = dbus_proxy.Bus.SYSTEM,
name = "org.bluez",
interface = "org.bluez.Adapter1",
path = "/org/bluez/hci0"
}
local AdapterProperties = dbus_proxy.Proxy:new {
bus = dbus_proxy.Bus.SYSTEM,
name = "org.bluez",
interface = "org.freedesktop.DBus.Properties",
path = "/org/bluez/hci0"
}
local AdapterProperties = dbus_proxy.Proxy:new {
bus = dbus_proxy.Bus.SYSTEM,
name = "org.bluez",
interface = "org.freedesktop.DBus.Properties",
path = "/org/bluez/hci0"
}
ObjectManager:connect_signal(
function(interface)
get_device_info(interface)
end,
"InterfacesAdded"
)
ObjectManager:connect_signal(
function(interface)
get_device_info(interface)
end,
"InterfacesAdded"
)
ObjectManager:connect_signal(
function(interface)
awesome.emit_signal("device_removed", interface)
end,
"InterfacesRemoved"
)
ObjectManager:connect_signal(
function(interface)
awesome.emit_signal("device_removed", interface)
end,
"InterfacesRemoved"
)
Adapter:connect_signal(
function(data)
if data.Powered ~= nil then
awesome.emit_signal("state", data.Powered)
Adapter:connect_signal(
function(data)
if data.Powered ~= nil then
awesome.emit_signal("state", data.Powered)
end
end,
"PropertiesChanged"
)
AdapterProperties:connect_signal(
function(data)
if data.Powered ~= nil then
awesome.emit_signal("state", data.Powered)
if data.Powered then
Adapter:StartDiscovery()
end
end
end,
"PropertiesChanged"
)
awesome.connect_signal("toggle_bluetooth",
function()
local is_powered = Adapter.Powered
Adapter:Set(
"org.bluez.Adapter1",
"Powered",
lgi.GLib.Variant("b", not is_powered)
)
Adapter.Powered = { signature = "b", value = not is_powered }
awesome.emit_signal("state", Adapter.Powered)
end)
gears.timer.delayed_call(
function()
local objects = ObjectManager:GetManagedObjects()
for object_path, _ in pairs(objects) do
get_device_info(object_path)
end
awesome.emit_signal("state", Adapter.Powered)
end
)
end
end,
"PropertiesChanged"
)
AdapterProperties:connect_signal(
function(data)
if data.Powered ~= nil then
awesome.emit_signal("state", data.Powered)
if data.Powered then
Adapter:StartDiscovery()
end
end
end,
"PropertiesChanged"
)
awesome.connect_signal("toggle_bluetooth",
function()
local is_powered = Adapter.Powered
Adapter:Set(
"org.bluez.Adapter1",
"Powered",
lgi.GLib.Variant("b", not is_powered)
)
Adapter.Powered = { signature = "b", value = not is_powered }
awesome.emit_signal("state", Adapter.Powered)
end)
gears.timer.delayed_call(
function()
local objects = ObjectManager:GetManagedObjects()
for object_path, _ in pairs(objects) do
get_device_info(object_path)
end
awesome.emit_signal("state", Adapter.Powered)
end
)

245
awesome/src/lib/overflow_widget/overflow.lua
View File

@@ -7,6 +7,7 @@
-- @author Lucas Schwiderski
-- @copyright 2021 Lucas Schwiderski
-- @layoutmod wibox.layout.overflow
-- @supermodule wibox.layout.fixed
---------------------------------------------------------------------------
local base = require('wibox.widget.base')
@@ -46,32 +47,26 @@ function overflow:fit(context, orig_width, orig_height)
-- First, determine widget sizes.
-- Only when the content doesn't fit and needs scrolling should
-- we reduce content size to make space for a scrollbar.
for _, widget in pairs(widgets) do
for _, widget in ipairs(widgets) do
local w, h = base.fit_widget(self, context, widget, width, height)
if is_y then
used_max = math.max(used_max, w)
used_in_dir = used_in_dir + h
else
used_in_dir = used_in_dir + w
used_max = math.max(used_max, h)
used_in_dir = used_in_dir + w
end
end
local spacing = self._private.spacing * (num_widgets - 1)
used_in_dir = used_in_dir + spacing
local need_scrollbar = used_in_dir > avail_in_dir and scrollbar_enabled
local need_scrollbar = scrollbar_enabled and used_in_dir > avail_in_dir
-- If the direction perpendicular to scrolling (e.g. width in vertical
-- scrolling) is not fully covered by any of the widgets, we can add our
-- scrollbar width to that value. Otherwise widget size will be reduced
-- during `layout` to make space for the scrollbar.
if need_scrollbar
and (
(is_y and used_max < orig_width)
or (not is_y and used_max < orig_height)
) then
-- Even if `used_max == orig_(width|height)` already, `base.fit_widget`
-- will clamp return values, so we can "overextend" here.
if need_scrollbar then
used_max = used_max + scrollbar_width
end
@@ -114,8 +109,8 @@ function overflow:layout(context, orig_width, orig_height)
used_max = math.max(used_max, w)
used_in_dir = used_in_dir + h
else
used_in_dir = used_in_dir + w
used_max = math.max(used_max, h)
used_in_dir = used_in_dir + w
end
end
@@ -127,7 +122,7 @@ function overflow:layout(context, orig_width, orig_height)
local need_scrollbar = used_in_dir > avail_in_dir and scrollbar_enabled
local scroll_position = self._private.position
local scroll_position = self._private.scroll_factor
if need_scrollbar then
local scrollbar_widget = self._private.scrollbar_widget
@@ -139,7 +134,7 @@ function overflow:layout(context, orig_width, orig_height)
-- Make scrollbar length reflect `visible_percent`
-- TODO: Apply a default minimum length
local bar_length = math.floor(visible_percent * avail_in_dir)
local bar_pos = (avail_in_dir - bar_length) * self._private.position
local bar_pos = (avail_in_dir - bar_length) * self._private.scroll_factor
if is_y then
bar_w, bar_h = base.fit_widget(self, context, scrollbar_widget, scrollbar_width, bar_length)
@@ -191,7 +186,7 @@ function overflow:layout(context, orig_width, orig_height)
end
end
for i, w in pairs(widgets) do
for i, w in ipairs(widgets) do
local content_x, content_y
local content_w, content_h = base.fit_widget(self, context, w, width, height)
@@ -263,19 +258,13 @@ function overflow:before_draw_children(_, cr, width, height)
end
--- The amount of units to advance per scroll event.
--
-- This affects calls to `scroll` and the default mouse wheel handler.
--
-- The default is `10`.
--
-- @property step
-- @tparam number step The step size.
-- @see set_step
--- Set the step size.
--
-- @method overflow:set_step
-- @tparam number step The step size.
-- @see step
function overflow:set_step(step)
self._private.step = step
-- We don't need to emit enything here, since changing step only really
@@ -283,15 +272,18 @@ function overflow:set_step(step)
end
--- Scroll the layout's content by `amount * step`.
--
-- A positive amount scroll down/right, a negative amount scrolls up/left.
--
-- The amount of units scrolled is affected by `step`.
--
-- @method overflow:scroll
-- @tparam number amount The amount to scroll by.
-- @emits property::overflow::position
-- @emitstparam property::overflow::position number position The new position.
-- @emits property::overflow::scroll_factor
-- @emitstparam property::overflow::scroll_factor number scroll_factor The new
-- scroll factor.
-- @emits widget::layout_changed
-- @emits widget::redraw_needed
-- @see step
function overflow:scroll(amount)
if amount == 0 then
return
@@ -299,55 +291,45 @@ function overflow:scroll(amount)
local interval = self._private.used_in_dir
local delta = self._private.step / interval
local pos = self._private.position + (delta * amount)
self:set_position(pos)
local factor = self._private.scroll_factor + (delta * amount)
self:set_scroll_factor(factor)
end
--- The scroll position.
-- The position is represented as a fraction from `0` to `1`.
--- The scroll factor.
--
-- @property position
-- @tparam number position The position.
-- The scroll factor represents how far the layout's content is currently
-- scrolled. It is represented as a fraction from `0` to `1`, where `0` is the
-- start of the content and `1` is the end.
--
-- @property scroll_factor
-- @tparam number scroll_factor The scroll factor.
-- @propemits true false
-- @see set_position
--- Set the current scroll position.
--
-- @method overflow:set_position
-- @tparam number position The new position.
-- @propemits true false
-- @emits widget::layout_changed
-- @emits widget::redraw_needed
-- @see position
function overflow:set_position(pos)
local current = self._private.position
function overflow:set_scroll_factor(factor)
local current = self._private.scroll_factor
local interval = self._private.used_in_dir - self._private.avail_in_dir
if current == pos
if current == factor
-- the content takes less space than what is available, i.e. everything
-- is already visible
or interval <= 0
-- the position is out of range
or (current <= 0 and pos < 0)
or (current >= 1 and pos > 1) then
-- the scroll factor is out of range
or (current <= 0 and factor < 0)
or (current >= 1 and factor > 1) then
return
end
self._private.position = math.min(1, math.max(pos, 0))
self._private.scroll_factor = math.min(1, math.max(factor, 0))
self:emit_signal("widget::layout_changed")
self:emit_signal("property::position", pos)
self:emit_signal("property::scroll_factor", factor)
end
--- Get the current scroll position.
--
-- @method overflow:get_position
-- @treturn number position The current position.
-- @see position
function overflow:get_position()
return self._private.position
function overflow:get_scroll_factor()
return self._private.scroll_factor
end
--- The scrollbar width.
--
-- For horizontal scrollbars, this is the scrollbar height
--
-- The default is `5`.
@@ -357,16 +339,7 @@ end
-- @property scrollbar_width
-- @tparam number scrollbar_width The scrollbar width.
-- @propemits true false
-- @see set_scrollbar_width
--- Set the scrollbar width.
--
-- @method overflow:set_scrollbar_width
-- @tparam number scrollbar_width The new scrollbar width.
-- @propemits true false
-- @emits widget::layout_changed
-- @emits widget::redraw_needed
-- @see scrollbar_width
function overflow:set_scrollbar_width(width)
if self._private.scrollbar_width == width then
return
@@ -382,23 +355,14 @@ end
--
-- For horizontal scrollbars, this can be `"top"` or `"bottom"`,
-- for vertical scrollbars this can be `"left"` or `"right"`.
-- The default is `"left"`/`"bottom"`.
-- The default is `"right"`/`"bottom"`.
--
--@DOC_wibox_layout_overflow_scrollbar_position_EXAMPLE@
--
-- @property scrollbar_position
-- @tparam string scrollbar_position The scrollbar position.
-- @propemits true false
-- @see set_scrollbar_position
--- Set the scrollbar position.
--
-- @method overflow:set_scrollbar_position
-- @tparam string scrollbar_position The new scrollbar position.
-- @propemits true false
-- @emits widget::layout_changed
-- @emits widget::redraw_needed
-- @see scrollbar_position
function overflow:set_scrollbar_position(position)
if self._private.scrollbar_position == position then
return
@@ -410,7 +374,12 @@ function overflow:set_scrollbar_position(position)
self:emit_signal("property::scrollbar_position", position)
end
function overflow:get_scrollbar_position()
return self._private.scrollbar_position
end
--- The scrollbar visibility.
--
-- If this is set to `false`, no scrollbar will be rendered, even if the layout's
-- content overflows. Mouse wheel scrolling will work regardless.
--
@@ -419,16 +388,7 @@ end
-- @property scrollbar_enabled
-- @tparam boolean scrollbar_enabled The scrollbar visibility.
-- @propemits true false
-- @see set_scrollbar_enabled
--- Enable or disable the scrollbar visibility.
--
-- @method overflow:set_scrollbar_enabled
-- @tparam boolean scrollbar_enabled The new scrollbar visibility.
-- @propemits true false
-- @emits widget::layout_changed
-- @emits widget::redraw_needed
-- @see scrollbar_enabled
function overflow:set_scrollbar_enabled(enabled)
if self._private.scrollbar_enabled == enabled then
return
@@ -440,22 +400,34 @@ function overflow:set_scrollbar_enabled(enabled)
self:emit_signal("property::scrollbar_enabled", enabled)
end
function overflow:get_scrollbar_enabled()
return self._private.scrollbar_enabled
end
-- Wraps a callback function for `mousegrabber` that is capable of
-- updating the scroll position.
local function build_grabber(container)
-- updating the scroll factor.
local function build_grabber(container, initial_x, initial_y, geo)
local is_y = container._private.dir == "y"
local bar_interval = container._private.avail_in_dir - container._private.bar_length
local start_pos = container._private.position * bar_interval
local coords = mouse.coords()
local start = is_y and coords.y or coords.x
local start_pos = container._private.scroll_factor * bar_interval
local start = is_y and initial_y or initial_x
-- Calculate a matrix transforming from screen coordinates into widget
-- coordinates.
-- This is required for mouse movement to work when the widget has been
-- transformed by something like `wibox.container.rotate`.
local matrix_from_device = geo.hierarchy:get_matrix_from_device()
local wgeo = geo.drawable.drawable:geometry()
local matrix = matrix_from_device:translate(-wgeo.x, -wgeo.y)
return function(mouse)
if not mouse.buttons[1] then
return false
end
local pos = is_y and mouse.y or mouse.x
container:set_position((start_pos + (pos - start)) / bar_interval)
local x, y = matrix:transform_point(mouse.x, mouse.y)
local pos = is_y and x and y
container:set_scroll_factor((start_pos + (pos - start)) / bar_interval)
return true
end
@@ -463,35 +435,25 @@ end
-- Applies a mouse button signal using `build_grabber` to a scrollbar widget.
local function apply_scrollbar_mouse_signal(container, w)
w:connect_signal('button::press', function(_, _, _, button_id)
w:connect_signal('button::press', function(_, x, y, button_id, _, geo)
if button_id ~= 1 then
return
end
mousegrabber.run(build_grabber(container), "fleur")
mousegrabber.run(build_grabber(container, x, y, geo), "fleur")
end)
end
--- The scrollbar widget.
-- This widget is rendered as the scrollbar element.
--
-- The default is `awful.widget.separator{ shape = gears.shape.rectangle }`.
-- The default is `wibox.widget.separator{ shape = gears.shape.rectangle }`.
--
--@DOC_wibox_layout_overflow_scrollbar_widget_EXAMPLE@
--
-- @property scrollbar_widget
-- @tparam widget scrollbar_widget The scrollbar widget.
-- @propemits true false
-- @see set_scrollbar_widget
--- Set the scrollbar widget.
--
-- This will also apply the mouse button handler.
--
-- @method overflow:set_scrollbar_widget
-- @tparam widget scrollbar_widget The new scrollbar widget.
-- @propemits true false
-- @emits widget::layout_changed
-- @see scrollbar_widget
function overflow:set_scrollbar_widget(widget)
local w = base.make_widget_from_value(widget)
@@ -503,14 +465,22 @@ function overflow:set_scrollbar_widget(widget)
self:emit_signal("property::scrollbar_widget", widget)
end
function overflow:get_scrollbar_widget()
return self._private.scrollbar_widget
end
local function new(dir, ...)
local ret = fixed[dir](...)
gtable.crush(ret, overflow, true)
ret.widget_name = gobject.modulename(2)
-- Tell the widget system to prevent clicks outside the layout's extends
-- to register with child widgets, even if they actually extend that far.
-- This prevents triggering button presses on hidden/clipped widgets.
ret.clip_child_extends = true
-- Manually set the position here. We don't know the bounding size yet.
ret._private.position = 0
-- Manually set the scroll factor here. We don't know the bounding size yet.
ret._private.scroll_factor = 0
-- Apply defaults. Bypass setters to avoid signals.
ret._private.step = 10
@@ -525,17 +495,9 @@ local function new(dir, ...)
ret:connect_signal('button::press', function(self, _, _, button)
if button == 4 then
if self.scroll_speed == nil or self.scroll_speed <= 0 then
self:scroll(-1)
else
self:scroll(-1 * self.scroll_speed)
end
self:scroll(-1)
elseif button == 5 then
if self.scroll_speed == nil or self.scroll_speed <= 0 then
self:scroll(1)
else
self:scroll(1 * self.scroll_speed)
end
self:scroll(1)
end
end)
@@ -559,58 +521,9 @@ end
-- widgets exceeds the height available whithin the layout's outer container
-- a scrollbar will be added and scrolling behavior enabled.
-- @tparam widget ... Widgets that should be added to the layout.
-- @constructorfct wibox.layout.fixed.horizontal
-- @constructorfct wibox.layout.overflow.horizontal
function overflow.vertical(...)
return new("vertical", ...)
end
--- Add spacing between each layout widgets.
--
-- This behaves just like in `wibox.layout.fixed`:
--
--@DOC_wibox_layout_fixed_spacing_EXAMPLE@
--
-- @property spacing
-- @tparam number spacing Spacing between widgets.
-- @propemits true false
-- @see wibox.layout.fixed
--- The widget used to fill the spacing between the layout elements.
-- By default, no widget is used.
--
-- This behaves just like in `wibox.layout.fixed`:
--
--@DOC_wibox_layout_fixed_spacing_widget_EXAMPLE@
--
-- @property spacing_widget
-- @tparam widget spacing_widget
-- @propemits true false
-- @see wibox.layout.fixed
--- Set the layout's fill_space property.
--
-- If this property is `true`, widgets
-- take all space in the non-scrolling directing (e.g. `width` for vertical
-- scrolling). If `false`, they will only take as much as they need for their
-- content.
--
-- The default is `true`.
--
--@DOC_wibox_layout_overflow_fill_space_EXAMPLE@
--
-- @property fill_space
-- @tparam boolean fill_space
-- @propemits true false
--@DOC_fixed_COMMON@
--@DOC_widget_COMMON@
--@DOC_object_COMMON@
return setmetatable(overflow, overflow.mt)
-- vim: filetype=lua:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80

381
awesome/wibox/hierarchy.lua Normal file
View File

@@ -0,0 +1,381 @@
---------------------------------------------------------------------------
-- Management of widget hierarchies. Each widget hierarchy object has a widget
-- for which it saves e.g. size and transformation in its parent. Also, each
-- widget has a number of children.
--
-- @author Uli Schlachter
-- @copyright 2015 Uli Schlachter
-- @classmod wibox.hierarchy
---------------------------------------------------------------------------
local matrix = require("gears.matrix")
local protected_call = require("gears.protected_call")
local cairo = require("lgi").cairo
local base = require("wibox.widget.base")
local no_parent = base.no_parent_I_know_what_I_am_doing
local hierarchy = {}
local widgets_to_count = setmetatable({}, { __mode = "k" })
--- Add a widget to the list of widgets for which hierarchies should count their
-- occurrences. Note that for correct operations, the widget must not yet be
-- visible in any hierarchy.
-- @param widget The widget that should be counted.
-- @staticfct wibox.hierarchy.count_widget
function hierarchy.count_widget(widget)
widgets_to_count[widget] = true
end
local function hierarchy_new(redraw_callback, layout_callback, callback_arg)
local result = {
_matrix = matrix.identity,
_matrix_to_device = matrix.identity,
_need_update = true,
_widget = nil,
_context = nil,
_redraw_callback = redraw_callback,
_layout_callback = layout_callback,
_callback_arg = callback_arg,
_size = {
width = nil,
height = nil
},
_draw_extents = {
x = 0,
y = 0,
width = 0,
height = 0
},
_parent = nil,
_children = {},
_widget_counts = {},
}
function result._redraw()
redraw_callback(result, callback_arg)
end
function result._layout()
local h = result
while h do
h._need_update = true
h = h._parent
end
layout_callback(result, callback_arg)
end
function result._emit_recursive(widget, name, ...)
local cur = result
assert(widget == cur._widget)
while cur do
if cur._widget then
cur._widget:emit_signal(name, ...)
end
cur = cur._parent
end
end
for k, f in pairs(hierarchy) do
if type(f) == "function" then
result[k] = f
end
end
return result
end
local hierarchy_update
function hierarchy_update(self, context, widget, width, height, region, matrix_to_parent, matrix_to_device)
if (not self._need_update) and self._widget == widget and
self._context == context and
self._size.width == width and self._size.height == height and
matrix.equals(self._matrix, matrix_to_parent) and
matrix.equals(self._matrix_to_device, matrix_to_device) then
-- Nothing changed
return
end
self._need_update = false
local old_x, old_y, old_width, old_height
local old_widget = self._widget
if self._size.width and self._size.height then
local x, y, w, h = matrix.transform_rectangle(self._matrix_to_device, 0, 0, self._size.width, self._size.height)
old_x, old_y = math.floor(x), math.floor(y)
old_width, old_height = math.ceil(x + w) - old_x, math.ceil(y + h) - old_y
else
old_x, old_y, old_width, old_height = 0, 0, 0, 0
end
-- Disconnect old signals
if old_widget and old_widget ~= widget then
self._widget:disconnect_signal("widget::redraw_needed", self._redraw)
self._widget:disconnect_signal("widget::layout_changed", self._layout)
self._widget:disconnect_signal("widget::emit_recursive", self._emit_recursive)
end
-- Save the arguments we need to save
self._widget = widget
self._context = context
self._size.width = width
self._size.height = height
self._matrix = matrix_to_parent
self._matrix_to_device = matrix_to_device
-- Connect signals
if old_widget ~= widget then
widget:weak_connect_signal("widget::redraw_needed", self._redraw)
widget:weak_connect_signal("widget::layout_changed", self._layout)
widget:weak_connect_signal("widget::emit_recursive", self._emit_recursive)
end
-- Update children
local old_children = self._children
local layout_result = base.layout_widget(no_parent, context, widget, width, height)
self._children = {}
for _, w in ipairs(layout_result or {}) do
local r = table.remove(old_children, 1)
if not r then
r = hierarchy_new(self._redraw_callback, self._layout_callback, self._callback_arg)
r._parent = self
end
hierarchy_update(r, context, w._widget, w._width, w._height, region, w._matrix, w._matrix * matrix_to_device)
table.insert(self._children, r)
end
-- Calculate the draw extents
local x1, y1, x2, y2 = 0, 0, width, height
if not widget.clip_child_extends then
for _, h in ipairs(self._children) do
local px, py, pwidth, pheight = matrix.transform_rectangle(h._matrix, h:get_draw_extents())
x1 = math.min(x1, px)
y1 = math.min(y1, py)
x2 = math.max(x2, px + pwidth)
y2 = math.max(y2, py + pheight)
end
end
self._draw_extents = {
x = x1, y = y1,
width = x2 - x1,
height = y2 - y1
}
-- Update widget counts
self._widget_counts = {}
if widgets_to_count[widget] and width > 0 and height > 0 then
self._widget_counts[widget] = 1
end
for _, h in ipairs(self._children) do
for w, count in pairs(h._widget_counts) do
self._widget_counts[w] = (self._widget_counts[w] or 0) + count
end
end
-- Check which part needs to be redrawn
-- Are there any children which were removed? Their area needs a redraw.
for _, child in ipairs(old_children) do
local x, y, w, h = matrix.transform_rectangle(child._matrix_to_device, child:get_draw_extents())
region:union_rectangle(cairo.RectangleInt {
x = x, y = y, width = w, height = h
})
child._parent = nil
end
-- Did we change and need to be redrawn?
local x, y, w, h = matrix.transform_rectangle(self._matrix_to_device, 0, 0, self._size.width, self._size.height)
local new_x, new_y = math.floor(x), math.floor(y)
local new_width, new_height = math.ceil(x + w) - new_x, math.ceil(y + h) - new_y
if new_x ~= old_x or new_y ~= old_y or new_width ~= old_width or new_height ~= old_height or
widget ~= old_widget then
region:union_rectangle(cairo.RectangleInt {
x = old_x, y = old_y, width = old_width, height = old_height
})
region:union_rectangle(cairo.RectangleInt {
x = new_x, y = new_y, width = new_width, height = new_height
})
end
end
--- Create a new widget hierarchy that has no parent.
-- @param context The context in which we are laid out.
-- @param widget The widget that is at the base of the hierarchy.
-- @param width The available width for this hierarchy.
-- @param height The available height for this hierarchy.
-- @param redraw_callback Callback that is called with the corresponding widget
-- hierarchy on widget::redraw_needed on some widget.
-- @param layout_callback Callback that is called with the corresponding widget
-- hierarchy on widget::layout_changed on some widget.
-- @param callback_arg A second argument that is given to the above callbacks.
-- @return A new widget hierarchy
-- @constructorfct wibox.hierarchy.new
function hierarchy.new(context, widget, width, height, redraw_callback, layout_callback, callback_arg)
local result = hierarchy_new(redraw_callback, layout_callback, callback_arg)
result:update(context, widget, width, height)
return result
end
--- Update a widget hierarchy with some new state.
-- @param context The context in which we are laid out.
-- @param widget The widget that is at the base of the hierarchy.
-- @param width The available width for this hierarchy.
-- @param height The available height for this hierarchy.
-- @param[opt] region A region to use for accumulating changed parts
-- @return A cairo region describing the changed parts (either the `region`
-- argument or a new, internally created region).
-- @method update
function hierarchy:update(context, widget, width, height, region)
region = region or cairo.Region.create()
hierarchy_update(self, context, widget, width, height, region, self._matrix, self._matrix_to_device)
return region
end
--- Get the widget that this hierarchy manages.
-- @method get_widget
function hierarchy:get_widget()
return self._widget
end
--- Get a matrix that transforms to the parent's coordinate space from this
-- hierarchy's coordinate system.
-- @return A matrix describing the transformation.
-- @method get_matrix_to_parent
function hierarchy:get_matrix_to_parent()
return self._matrix
end
--- Get a matrix that transforms to the base of this hierarchy's coordinate
-- system (aka the coordinate system of the device that this
-- hierarchy is applied upon) from this hierarchy's coordinate system.
-- @return A matrix describing the transformation.
-- @method get_matrix_to_device
function hierarchy:get_matrix_to_device()
return self._matrix_to_device
end
--- Get a matrix that transforms from the parent's coordinate space into this
-- hierarchy's coordinate system.
-- @return A matrix describing the transformation.
-- @method get_matrix_from_parent
function hierarchy:get_matrix_from_parent()
local m = self:get_matrix_to_parent()
return m:invert()
end
--- Get a matrix that transforms from the base of this hierarchy's coordinate
-- system (aka the coordinate system of the device that this
-- hierarchy is applied upon) into this hierarchy's coordinate system.
-- @return A matrix describing the transformation.
-- @method get_matrix_from_device
function hierarchy:get_matrix_from_device()
local m = self:get_matrix_to_device()
return m:invert()
end
--- Get the extents that this hierarchy possibly draws to (in the current coordinate space).
-- This includes the size of this element plus the size of all children
-- (after applying the corresponding transformation).
-- @return x, y, width, height
-- @method get_draw_extents
function hierarchy:get_draw_extents()
local ext = self._draw_extents
return ext.x, ext.y, ext.width, ext.height
end
--- Get the size that this hierarchy logically covers (in the current coordinate space).
-- @return width, height
-- @method get_size
function hierarchy:get_size()
local ext = self._size
return ext.width, ext.height
end
--- Get a list of all children.
-- @return List of all children hierarchies.
-- @method get_children
function hierarchy:get_children()
return self._children
end
--- Count how often this widget is visible inside this hierarchy. This function
-- only works with widgets registered via `count_widget`.
-- @param widget The widget that should be counted
-- @return The number of times that this widget is contained in this hierarchy.
-- @method get_count
function hierarchy:get_count(widget)
return self._widget_counts[widget] or 0
end
--- Does the given cairo context have an empty clip (aka "no drawing possible")?
local function empty_clip(cr)
local x1, y1, x2, y2 = cr:clip_extents()
return x2 - x1 == 0 or y2 - y1 == 0
end
--- Draw a hierarchy to some cairo context.
-- This function draws the widgets in this widget hierarchy to the given cairo
-- context. The context's clip is used to skip parts that aren't visible.
-- @param context The context in which widgets are drawn.
-- @param cr The cairo context that is used for drawing.
-- @method draw
function hierarchy:draw(context, cr)
local widget = self:get_widget()
if not widget._private.visible then
return
end
cr:save()
cr:transform(self:get_matrix_to_parent():to_cairo_matrix())
-- Clip to the draw extents
cr:rectangle(self:get_draw_extents())
cr:clip()
-- Draw if needed
if not empty_clip(cr) then
local opacity = widget:get_opacity()
local function call(func, extra_arg1, extra_arg2)
if not func then return end
if not extra_arg2 then
protected_call(func, widget, context, cr, self:get_size())
else
protected_call(func, widget, context, extra_arg1, extra_arg2, cr, self:get_size())
end
end
-- Prepare opacity handling
if opacity ~= 1 then
cr:push_group()
end
-- Draw the widget
cr:save()
cr:rectangle(0, 0, self:get_size())
cr:clip()
call(widget.draw)
cr:restore()
-- Clear any path that the widget might have left
cr:new_path()
-- Draw its children (We already clipped to the draw extents above)
call(widget.before_draw_children)
for i, wi in ipairs(self:get_children()) do
call(widget.before_draw_child, i, wi:get_widget())
wi:draw(context, cr)
call(widget.after_draw_child, i, wi:get_widget())
end
call(widget.after_draw_children)
-- Clear any path that the widget might have left
cr:new_path()
-- Apply opacity
if opacity ~= 1 then
cr:pop_group_to_source()
cr.operator = cairo.Operator.OVER
cr:paint_with_alpha(opacity)
end
end
cr:restore()
end
return hierarchy

482
awesome/wibox/layout/fixed.lua Normal file
View File

@@ -0,0 +1,482 @@
---------------------------------------------------------------------------
-- A `fixed` layout may be initialized with any number of child widgets, and
-- during runtime widgets may be added and removed dynamically.
--
-- On the main axis, child widgets are given a fixed size of exactly as much
-- space as they ask for. The layout will then resize according to the sum of
-- all child widgets. If the space available to the layout is not enough to
-- include all child widgets, the excessive ones are not drawn at all.
--
-- Additionally, the layout allows adding empty spacing or even placing a custom
-- spacing widget between the child widget.
--
-- On its secondary axis, the layout's size is determined by the largest child
-- widget. Smaller child widgets are then placed with the same size.
-- Therefore, child widgets may ignore their `forced_width` or `forced_height`
-- properties for vertical and horizontal layouts respectively.
--
--@DOC_wibox_layout_defaults_fixed_EXAMPLE@
--
-- @author Uli Schlachter
-- @copyright 2010 Uli Schlachter
-- @layoutmod wibox.layout.fixed
-- @supermodule wibox.widget.base
---------------------------------------------------------------------------
local unpack = unpack or table.unpack -- luacheck: globals unpack (compatibility with Lua 5.1)
local base = require("wibox.widget.base")
local table = table
local pairs = pairs
local gtable = require("gears.table")
local fixed = {}
-- Layout a fixed layout. Each widget gets just the space it asks for.
-- @param context The context in which we are drawn.
-- @param width The available width.
-- @param height The available height.
function fixed:layout(context, width, height)
local result = {}
local spacing = self._private.spacing or 0
local is_y = self._private.dir == "y"
local is_x = not is_y
local abspace = math.abs(spacing)
local spoffset = spacing < 0 and 0 or spacing
local widgets_nr = #self._private.widgets
local spacing_widget
local x, y = 0, 0
spacing_widget = spacing ~= 0 and self._private.spacing_widget or nil
for index, widget in pairs(self._private.widgets) do
local w, h, local_spacing = width - x, height - y, spacing
-- Some widget might be zero sized either because this is their
-- minimum space or just because they are really empty. In this case,
-- they must still be added to the layout. Otherwise, if their size
-- change and this layout is resizable, they are lost "forever" until
-- a full relayout is called on this fixed layout object.
local zero = false
if is_y then
if index ~= widgets_nr or not self._private.fill_space then
h = select(2, base.fit_widget(self, context, widget, w, h))
zero = h == 0
end
if y - spacing >= height then
-- pop the spacing widget added in previous iteration if used
if spacing_widget then
table.remove(result)
-- Avoid adding zero-sized widgets at an out-of-bound
-- position.
y = y - spacing
end
-- Never display "random" widgets as soon as a non-zero sized
-- one doesn't fit.
if not zero then
break
end
end
else
if index ~= widgets_nr or not self._private.fill_space then
w = select(1, base.fit_widget(self, context, widget, w, h))
zero = w == 0
end
if x - spacing >= width then
-- pop the spacing widget added in previous iteration if used
if spacing_widget then
table.remove(result)
-- Avoid adding zero-sized widgets at an out-of-bound
-- position.
x = x - spacing
end
-- Never display "random" widgets as soon as a non-zero sized
-- one doesn't fit.
if not zero then
break
end
end
end
if zero then
local_spacing = 0
end
-- Place widget, even if it has zero width/height. Otherwise
-- any layout change for zero-sized widget would become invisible.
table.insert(result, base.place_widget_at(widget, x, y, w, h))
x = is_x and x + w + local_spacing or x
y = is_y and y + h + local_spacing or y
-- Add the spacing widget (if needed)
if index < widgets_nr and spacing_widget then
table.insert(result, base.place_widget_at(
spacing_widget,
is_x and (x - spoffset) or x,
is_y and (y - spoffset) or y,
is_x and abspace or w,
is_y and abspace or h
))
end
end
return result
end
--- Add some widgets to the given layout.
--
-- @method add
-- @tparam widget ... Widgets that should be added (must at least be one).
-- @interface layout
function fixed:add(...)
-- No table.pack in Lua 5.1 :-(
local args = { n = select('#', ...), ... }
assert(args.n > 0, "need at least one widget to add")
for i = 1, args.n do
local w = base.make_widget_from_value(args[i])
base.check_widget(w)
table.insert(self._private.widgets, w)
end
self:emit_signal("widget::layout_changed")
end
--- Remove a widget from the layout.
--
-- @method remove
-- @tparam number index The widget index to remove
-- @treturn boolean index If the operation is successful
-- @interface layout
function fixed:remove(index)
if not index or index < 1 or index > #self._private.widgets then return false end
table.remove(self._private.widgets, index)
self:emit_signal("widget::layout_changed")
return true
end
--- Remove one or more widgets from the layout.
--
-- The last parameter can be a boolean, forcing a recursive seach of the
-- widget(s) to remove.
-- @method remove_widgets
-- @tparam widget ... Widgets that should be removed (must at least be one)
-- @treturn boolean If the operation is successful
-- @interface layout
function fixed:remove_widgets(...)
local args = { ... }
local recursive = type(args[#args]) == "boolean" and args[#args]
local ret = true
for k, rem_widget in ipairs(args) do
if recursive and k == #args then break end
local idx, l = self:index(rem_widget, recursive)
if idx and l and l.remove then
l:remove(idx, false)
else
ret = false
end
end
return #args > (recursive and 1 or 0) and ret
end
function fixed:get_children()
return self._private.widgets
end
function fixed:set_children(children)
self:reset()
if #children > 0 then
self:add(unpack(children))
end
end
--- Replace the first instance of `widget` in the layout with `widget2`.
-- @method replace_widget
-- @tparam widget widget The widget to replace
-- @tparam widget widget2 The widget to replace `widget` with
-- @tparam[opt=false] boolean recursive Digg in all compatible layouts to find the widget.
-- @treturn boolean If the operation is successful
-- @interface layout
function fixed:replace_widget(widget, widget2, recursive)
local idx, l = self:index(widget, recursive)
if idx and l then
l:set(idx, widget2)
return true
end
return false
end
function fixed:swap(index1, index2)
if not index1 or not index2 or index1 > #self._private.widgets
or index2 > #self._private.widgets then
return false
end
local widget1, widget2 = self._private.widgets[index1], self._private.widgets[index2]
self:set(index1, widget2)
self:set(index2, widget1)
self:emit_signal("widget::swapped", widget1, widget2, index2, index1)
return true
end
function fixed:swap_widgets(widget1, widget2, recursive)
base.check_widget(widget1)
base.check_widget(widget2)
local idx1, l1 = self:index(widget1, recursive)
local idx2, l2 = self:index(widget2, recursive)
if idx1 and l1 and idx2 and l2 and (l1.set or l1.set_widget) and (l2.set or l2.set_widget) then
if l1.set then
l1:set(idx1, widget2)
if l1 == self then
self:emit_signal("widget::swapped", widget1, widget2, idx2, idx1)
end
elseif l1.set_widget then
l1:set_widget(widget2)
end
if l2.set then
l2:set(idx2, widget1)
if l2 == self then
self:emit_signal("widget::swapped", widget1, widget2, idx2, idx1)
end
elseif l2.set_widget then
l2:set_widget(widget1)
end
return true
end
return false
end
function fixed:set(index, widget2)
if (not widget2) or (not self._private.widgets[index]) then return false end
base.check_widget(widget2)
local w = self._private.widgets[index]
self._private.widgets[index] = widget2
self:emit_signal("widget::layout_changed")
self:emit_signal("widget::replaced", widget2, w, index)
return true
end
--- A widget to insert as a separator between child widgets.
--
-- If this property is a valid widget and `spacing` is greater than `0`, a
-- copy of this widget is inserted between each child widget, with its size in
-- the layout's main direction determined by `spacing`.
--
-- By default no widget is used and any `spacing` is applied as an empty offset.
--
--@DOC_wibox_layout_fixed_spacing_widget_EXAMPLE@
--
-- @property spacing_widget
-- @tparam widget spacing_widget
-- @propemits true false
-- @interface layout
function fixed:set_spacing_widget(wdg)
self._private.spacing_widget = base.make_widget_from_value(wdg)
self:emit_signal("widget::layout_changed")
self:emit_signal("property::spacing_widget", wdg)
end
--- Insert a new widget in the layout at position `index`.
--
-- @method insert
-- @tparam number index The position.
-- @tparam widget widget The widget.
-- @treturn boolean If the operation is successful.
-- @emits widget::inserted
-- @emitstparam widget::inserted widget self The fixed layout.
-- @emitstparam widget::inserted widget widget index The inserted widget.
-- @emitstparam widget::inserted number count The widget count.
-- @interface layout
function fixed:insert(index, widget)
if not index or index < 1 or index > #self._private.widgets + 1 then return false end
base.check_widget(widget)
table.insert(self._private.widgets, index, widget)
self:emit_signal("widget::layout_changed")
self:emit_signal("widget::inserted", widget, #self._private.widgets)
return true
end
-- Fit the fixed layout into the given space.
-- @param context The context in which we are fit.
-- @param orig_width The available width.
-- @param orig_height The available height.
function fixed:fit(context, orig_width, orig_height)
local widgets = self._private.widgets
local num_widgets = #widgets
-- Return early if there are no widgets to draw
if num_widgets < 1 then
return 0, 0
end
local width_left, height_left = orig_width, orig_height
local used_in_dir, used_max = 0, 0
local is_y = self._private.dir == "y"
local spacing = self._private.spacing or 0
for k, v in ipairs(widgets) do
-- Keep in mind that `spacing` may be negative to create overlap
if k > 1 and spacing ~= 0 then
used_in_dir = used_in_dir + spacing
if is_y then
height_left = height_left - spacing
else
width_left = width_left - spacing
end
end
local w, h = base.fit_widget(self, context, v, width_left, height_left)
-- Determine if the widget still fits
local is_enough
if is_y then
is_enough = height_left >= h
if is_enough then
used_max = math.max(used_max, w)
used_in_dir = used_in_dir + h
height_left = height_left - h
end
else
is_enough = w > 0 and width_left >= w
if is_enough then
used_max = math.max(used_max, h)
used_in_dir = used_in_dir + w
width_left = width_left - w
end
end
if not is_enough then
-- Remove previous spacing if there was not enough space
-- to add the current widget
used_in_dir = used_in_dir - spacing
break
elseif width_left <= 0 or height_left <= 0 then
break
end
end
if is_y then
return used_max, used_in_dir
else
return used_in_dir, used_max
end
end
function fixed:reset()
self._private.widgets = {}
self:emit_signal("widget::layout_changed")
self:emit_signal("widget::reseted")
self:emit_signal("widget::reset")
end
--- Set the layout's fill_space property. If this property is true, the last
-- widget will get all the space that is left. If this is false, the last widget
-- won't be handled specially and there can be space left unused.
-- @property fill_space
-- @tparam boolean fill_space
-- @propemits true false
function fixed:fill_space(val)
if self._private.fill_space ~= val then
self._private.fill_space = not not val
self:emit_signal("widget::layout_changed")
self:emit_signal("property::fill_space", val)
end
end
local function get_layout(dir, widget1, ...)
local ret = base.make_widget(nil, nil, { enable_properties = true })
gtable.crush(ret, fixed, true)
ret._private.dir = dir
ret._private.widgets = {}
ret:set_spacing(0)
ret:fill_space(false)
if widget1 then
ret:add(widget1, ...)
end
return ret
end
--- Creates and returns a new horizontal fixed layout.
--
-- @tparam widget ... Widgets that should be added to the layout.
-- @constructorfct wibox.layout.fixed.horizontal
function fixed.horizontal(...)
return get_layout("x", ...)
end
--- Creates and returns a new vertical fixed layout.
--
-- @tparam widget ... Widgets that should be added to the layout.
-- @constructorfct wibox.layout.fixed.vertical
function fixed.vertical(...)
return get_layout("y", ...)
end
--- The amount of space inserted between the child widgets.
--
-- If a `spacing_widget` is defined, this value is used for its size.
--
--@DOC_wibox_layout_fixed_spacing_EXAMPLE@
--
-- @property spacing
-- @tparam number spacing Spacing between widgets.
-- @propemits true false
-- @interface layout
function fixed:set_spacing(spacing)
if self._private.spacing ~= spacing then
self._private.spacing = spacing
self:emit_signal("widget::layout_changed")
self:emit_signal("property::spacing", spacing)
end
end
function fixed:get_spacing()
return self._private.spacing or 0
end
--@DOC_fixed_COMMON@
return fixed
-- vim: filetype=lua:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80