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

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