1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
|
---------------------------------------------------------------------------
-- 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
-- @module 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 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 = {}
}
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
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
self._draw_extents = {
x = x1, y = y1,
width = x2 - x1,
height = y2 - y1
}
-- 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
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).
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.
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.
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.
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.
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.
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
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
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.
function hierarchy:get_children()
return self._children
end
--- Does the given cairo context have an empty clip (aka "no drawing possible")?
local function empty_clip(cr)
local _, _, width, height = cr:clip_extents()
return width == 0 or height == 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.
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()
-- 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)
-- 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
-- vim: filetype=lua:expandtab:shiftwidth=4:tabstop=8:softtabstop=4:textwidth=80
|