Yessiest
2 years ago
14 changed files with 1742 additions and 61 deletions
-
BINbackground.jpg
-
79libs/awmtk2.lua
-
17libs/debug.lua
-
714libs/dkjson.lua
-
52libs/simplepam.lua
-
29libs/thumbnail.lua
-
67modules/base.lua
-
100modules/binds.lua
-
15modules/errorlog.lua
-
5modules/global.lua
-
62modules/static_tags.lua
-
16modules/temp_crutches.lua
-
76rc.lua
-
571rc_dynamic_tags.lua
After Width: 1920 | Height: 1080 | Size: 792 KiB |
@ -0,0 +1,79 @@ |
|||
local wibox = require("wibox") |
|||
local awful = require("awful") |
|||
local gears = require("gears") |
|||
local beautiful = require("beautiful") |
|||
|
|||
local awmtk = {} |
|||
|
|||
-- {{{ Utils |
|||
awmtk.create_class = function(name,overrides,style,parent_class) |
|||
return setmetatable(overrides,{ |
|||
__index = function(self,k) |
|||
-- Per-widget overrides are top priority |
|||
if rawget(self,k) then |
|||
return rawget(self,k) |
|||
-- Style overrides are second in priority |
|||
elseif type(style[name]) == "table" and rawget(style[name],k) then |
|||
return rawget(style[name],k) |
|||
-- Parent class is fallback |
|||
elseif parent_class[k] then |
|||
return parent_class[k] |
|||
end |
|||
end |
|||
}) |
|||
end |
|||
|
|||
awmtk.create_style = function(style_name,parent,overrides) |
|||
local new_style = {} |
|||
for name,parent_class in pairs(parent) do |
|||
new_style[name] = awmtk.create_class( |
|||
name, |
|||
(overrides and overrides[name]) or {}, |
|||
(beautiful[style_name] or {}), |
|||
parent_class |
|||
) |
|||
end |
|||
return new_style |
|||
end |
|||
|
|||
-- }}} |
|||
|
|||
|
|||
-- {{{ Default style |
|||
|
|||
-- Default style |
|||
awmtk.default = { |
|||
base = setmetatable({ |
|||
-- { Backgrounds |
|||
-- custom background color for highlighting elements |
|||
bg_highlight = beautiful.bg_highlight or beautiful.bg_focus, |
|||
-- } |
|||
-- { Borders |
|||
-- Borders for popups |
|||
shape_border_width = beautiful.shape_border_width or 0, |
|||
shape_border_color = beautiful.shape_border_color or beautiful.bg_normal, |
|||
-- } |
|||
-- { Shapes |
|||
inner_margin = beautiful.inner_margin or 5, |
|||
rounding = beautiful.rounding or 0, |
|||
-- } |
|||
},{__index = beautiful}) |
|||
} |
|||
|
|||
-- Container subclass |
|||
awmtk.default.container = awmtk.create_class("container",{ |
|||
},awmtk.default,awmtk.default.base) |
|||
|
|||
-- Button subclass |
|||
awmtk.default.button = awmtk.create_class("button",{ |
|||
inner_margin = 1 |
|||
},awmtk.default,awmtk.default.base) |
|||
|
|||
-- Icon subclass |
|||
awmtk.default.icon = awmtk.create_class("icon",{ |
|||
inner_margin = 1 |
|||
},awmtk.default,awmtk.default.base) |
|||
|
|||
-- }}} |
|||
|
|||
return awmtk |
@ -0,0 +1,17 @@ |
|||
local naughty = require("naughty") |
|||
local debug = {} |
|||
-- Thanks, u/skhil |
|||
-- (https://www.reddit.com/r/awesomewm/comments/te49nb/why_does_awesomes_ram_consumption_get_higher_and/) |
|||
function debug.print_awesome_memory_stats(message) |
|||
print(os.date(), "\nLua memory usage:", collectgarbage("count")) |
|||
out_string = tostring(os.date()) .. "\nLua memory usage:"..tostring(collectgarbage("count")).."\n" |
|||
out_string = out_string .. "Objects alive:" |
|||
print("Objects alive:") |
|||
for name, obj in pairs{ button = button, client = client, drawable = drawable, drawin = drawin, key = key, screen = screen, tag = tag } do |
|||
out_string =out_string .. "\n" .. tostring(name) .. " = " ..tostring(obj.instances()) |
|||
print(name, obj.instances()) |
|||
end |
|||
naughty.notify({title = "Awesome WM memory statistics " .. message, text = out_string, timeout=20,hover_timeout=20}) |
|||
end |
|||
|
|||
return debug |
@ -0,0 +1,714 @@ |
|||
-- Module options: |
|||
local always_try_using_lpeg = true |
|||
local register_global_module_table = false |
|||
local global_module_name = 'json' |
|||
|
|||
--[==[ |
|||
|
|||
David Kolf's JSON module for Lua 5.1/5.2 |
|||
|
|||
Version 2.5 |
|||
|
|||
|
|||
For the documentation see the corresponding readme.txt or visit |
|||
<http://dkolf.de/src/dkjson-lua.fsl/>. |
|||
|
|||
You can contact the author by sending an e-mail to 'david' at the |
|||
domain 'dkolf.de'. |
|||
|
|||
|
|||
Copyright (C) 2010-2013 David Heiko Kolf |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining |
|||
a copy of this software and associated documentation files (the |
|||
"Software"), to deal in the Software without restriction, including |
|||
without limitation the rights to use, copy, modify, merge, publish, |
|||
distribute, sublicense, and/or sell copies of the Software, and to |
|||
permit persons to whom the Software is furnished to do so, subject to |
|||
the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be |
|||
included in all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, |
|||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF |
|||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND |
|||
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS |
|||
BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN |
|||
ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN |
|||
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
|||
SOFTWARE. |
|||
|
|||
--]==] |
|||
|
|||
-- global dependencies: |
|||
local pairs, type, tostring, tonumber, getmetatable, setmetatable, rawset = |
|||
pairs, type, tostring, tonumber, getmetatable, setmetatable, rawset |
|||
local error, require, pcall, select = error, require, pcall, select |
|||
local floor, huge = math.floor, math.huge |
|||
local strrep, gsub, strsub, strbyte, strchar, strfind, strlen, strformat = |
|||
string.rep, string.gsub, string.sub, string.byte, string.char, |
|||
string.find, string.len, string.format |
|||
local strmatch = string.match |
|||
local concat = table.concat |
|||
|
|||
local json = { version = "dkjson 2.5" } |
|||
|
|||
if register_global_module_table then |
|||
_G[global_module_name] = json |
|||
end |
|||
|
|||
local _ENV = nil -- blocking globals in Lua 5.2 |
|||
|
|||
pcall (function() |
|||
-- Enable access to blocked metatables. |
|||
-- Don't worry, this module doesn't change anything in them. |
|||
local debmeta = require "debug".getmetatable |
|||
if debmeta then getmetatable = debmeta end |
|||
end) |
|||
|
|||
json.null = setmetatable ({}, { |
|||
__tojson = function () return "null" end |
|||
}) |
|||
|
|||
local function isarray (tbl) |
|||
local max, n, arraylen = 0, 0, 0 |
|||
for k,v in pairs (tbl) do |
|||
if k == 'n' and type(v) == 'number' then |
|||
arraylen = v |
|||
if v > max then |
|||
max = v |
|||
end |
|||
else |
|||
if type(k) ~= 'number' or k < 1 or floor(k) ~= k then |
|||
return false |
|||
end |
|||
if k > max then |
|||
max = k |
|||
end |
|||
n = n + 1 |
|||
end |
|||
end |
|||
if max > 10 and max > arraylen and max > n * 2 then |
|||
return false -- don't create an array with too many holes |
|||
end |
|||
return true, max |
|||
end |
|||
|
|||
local escapecodes = { |
|||
["\""] = "\\\"", ["\\"] = "\\\\", ["\b"] = "\\b", ["\f"] = "\\f", |
|||
["\n"] = "\\n", ["\r"] = "\\r", ["\t"] = "\\t" |
|||
} |
|||
|
|||
local function escapeutf8 (uchar) |
|||
local value = escapecodes[uchar] |
|||
if value then |
|||
return value |
|||
end |
|||
local a, b, c, d = strbyte (uchar, 1, 4) |
|||
a, b, c, d = a or 0, b or 0, c or 0, d or 0 |
|||
if a <= 0x7f then |
|||
value = a |
|||
elseif 0xc0 <= a and a <= 0xdf and b >= 0x80 then |
|||
value = (a - 0xc0) * 0x40 + b - 0x80 |
|||
elseif 0xe0 <= a and a <= 0xef and b >= 0x80 and c >= 0x80 then |
|||
value = ((a - 0xe0) * 0x40 + b - 0x80) * 0x40 + c - 0x80 |
|||
elseif 0xf0 <= a and a <= 0xf7 and b >= 0x80 and c >= 0x80 and d >= 0x80 then |
|||
value = (((a - 0xf0) * 0x40 + b - 0x80) * 0x40 + c - 0x80) * 0x40 + d - 0x80 |
|||
else |
|||
return "" |
|||
end |
|||
if value <= 0xffff then |
|||
return strformat ("\\u%.4x", value) |
|||
elseif value <= 0x10ffff then |
|||
-- encode as UTF-16 surrogate pair |
|||
value = value - 0x10000 |
|||
local highsur, lowsur = 0xD800 + floor (value/0x400), 0xDC00 + (value % 0x400) |
|||
return strformat ("\\u%.4x\\u%.4x", highsur, lowsur) |
|||
else |
|||
return "" |
|||
end |
|||
end |
|||
|
|||
local function fsub (str, pattern, repl) |
|||
-- gsub always builds a new string in a buffer, even when no match |
|||
-- exists. First using find should be more efficient when most strings |
|||
-- don't contain the pattern. |
|||
if strfind (str, pattern) then |
|||
return gsub (str, pattern, repl) |
|||
else |
|||
return str |
|||
end |
|||
end |
|||
|
|||
local function quotestring (value) |
|||
-- based on the regexp "escapable" in https://github.com/douglascrockford/JSON-js |
|||
value = fsub (value, "[%z\1-\31\"\\\127]", escapeutf8) |
|||
if strfind (value, "[\194\216\220\225\226\239]") then |
|||
value = fsub (value, "\194[\128-\159\173]", escapeutf8) |
|||
value = fsub (value, "\216[\128-\132]", escapeutf8) |
|||
value = fsub (value, "\220\143", escapeutf8) |
|||
value = fsub (value, "\225\158[\180\181]", escapeutf8) |
|||
value = fsub (value, "\226\128[\140-\143\168-\175]", escapeutf8) |
|||
value = fsub (value, "\226\129[\160-\175]", escapeutf8) |
|||
value = fsub (value, "\239\187\191", escapeutf8) |
|||
value = fsub (value, "\239\191[\176-\191]", escapeutf8) |
|||
end |
|||
return "\"" .. value .. "\"" |
|||
end |
|||
json.quotestring = quotestring |
|||
|
|||
local function replace(str, o, n) |
|||
local i, j = strfind (str, o, 1, true) |
|||
if i then |
|||
return strsub(str, 1, i-1) .. n .. strsub(str, j+1, -1) |
|||
else |
|||
return str |
|||
end |
|||
end |
|||
|
|||
-- locale independent num2str and str2num functions |
|||
local decpoint, numfilter |
|||
|
|||
local function updatedecpoint () |
|||
decpoint = strmatch(tostring(0.5), "([^05+])") |
|||
-- build a filter that can be used to remove group separators |
|||
numfilter = "[^0-9%-%+eE" .. gsub(decpoint, "[%^%$%(%)%%%.%[%]%*%+%-%?]", "%%%0") .. "]+" |
|||
end |
|||
|
|||
updatedecpoint() |
|||
|
|||
local function num2str (num) |
|||
return replace(fsub(tostring(num), numfilter, ""), decpoint, ".") |
|||
end |
|||
|
|||
local function str2num (str) |
|||
local num = tonumber(replace(str, ".", decpoint)) |
|||
if not num then |
|||
updatedecpoint() |
|||
num = tonumber(replace(str, ".", decpoint)) |
|||
end |
|||
return num |
|||
end |
|||
|
|||
local function addnewline2 (level, buffer, buflen) |
|||
buffer[buflen+1] = "\n" |
|||
buffer[buflen+2] = strrep (" ", level) |
|||
buflen = buflen + 2 |
|||
return buflen |
|||
end |
|||
|
|||
function json.addnewline (state) |
|||
if state.indent then |
|||
state.bufferlen = addnewline2 (state.level or 0, |
|||
state.buffer, state.bufferlen or #(state.buffer)) |
|||
end |
|||
end |
|||
|
|||
local encode2 -- forward declaration |
|||
|
|||
local function addpair (key, value, prev, indent, level, buffer, buflen, tables, globalorder, state) |
|||
local kt = type (key) |
|||
if kt ~= 'string' and kt ~= 'number' then |
|||
return nil, "type '" .. kt .. "' is not supported as a key by JSON." |
|||
end |
|||
if prev then |
|||
buflen = buflen + 1 |
|||
buffer[buflen] = "," |
|||
end |
|||
if indent then |
|||
buflen = addnewline2 (level, buffer, buflen) |
|||
end |
|||
buffer[buflen+1] = quotestring (key) |
|||
buffer[buflen+2] = ":" |
|||
return encode2 (value, indent, level, buffer, buflen + 2, tables, globalorder, state) |
|||
end |
|||
|
|||
local function appendcustom(res, buffer, state) |
|||
local buflen = state.bufferlen |
|||
if type (res) == 'string' then |
|||
buflen = buflen + 1 |
|||
buffer[buflen] = res |
|||
end |
|||
return buflen |
|||
end |
|||
|
|||
local function exception(reason, value, state, buffer, buflen, defaultmessage) |
|||
defaultmessage = defaultmessage or reason |
|||
local handler = state.exception |
|||
if not handler then |
|||
return nil, defaultmessage |
|||
else |
|||
state.bufferlen = buflen |
|||
local ret, msg = handler (reason, value, state, defaultmessage) |
|||
if not ret then return nil, msg or defaultmessage end |
|||
return appendcustom(ret, buffer, state) |
|||
end |
|||
end |
|||
|
|||
function json.encodeexception(reason, value, state, defaultmessage) |
|||
return quotestring("<" .. defaultmessage .. ">") |
|||
end |
|||
|
|||
encode2 = function (value, indent, level, buffer, buflen, tables, globalorder, state) |
|||
local valtype = type (value) |
|||
local valmeta = getmetatable (value) |
|||
valmeta = type (valmeta) == 'table' and valmeta -- only tables |
|||
local valtojson = valmeta and valmeta.__tojson |
|||
if valtojson then |
|||
if tables[value] then |
|||
return exception('reference cycle', value, state, buffer, buflen) |
|||
end |
|||
tables[value] = true |
|||
state.bufferlen = buflen |
|||
local ret, msg = valtojson (value, state) |
|||
if not ret then return exception('custom encoder failed', value, state, buffer, buflen, msg) end |
|||
tables[value] = nil |
|||
buflen = appendcustom(ret, buffer, state) |
|||
elseif value == nil then |
|||
buflen = buflen + 1 |
|||
buffer[buflen] = "null" |
|||
elseif valtype == 'number' then |
|||
local s |
|||
if value ~= value or value >= huge or -value >= huge then |
|||
-- This is the behaviour of the original JSON implementation. |
|||
s = "null" |
|||
else |
|||
s = num2str (value) |
|||
end |
|||
buflen = buflen + 1 |
|||
buffer[buflen] = s |
|||
elseif valtype == 'boolean' then |
|||
buflen = buflen + 1 |
|||
buffer[buflen] = value and "true" or "false" |
|||
elseif valtype == 'string' then |
|||
buflen = buflen + 1 |
|||
buffer[buflen] = quotestring (value) |
|||
elseif valtype == 'table' then |
|||
if tables[value] then |
|||
return exception('reference cycle', value, state, buffer, buflen) |
|||
end |
|||
tables[value] = true |
|||
level = level + 1 |
|||
local isa, n = isarray (value) |
|||
if n == 0 and valmeta and valmeta.__jsontype == 'object' then |
|||
isa = false |
|||
end |
|||
local msg |
|||
if isa then -- JSON array |
|||
buflen = buflen + 1 |
|||
buffer[buflen] = "[" |
|||
for i = 1, n do |
|||
buflen, msg = encode2 (value[i], indent, level, buffer, buflen, tables, globalorder, state) |
|||
if not buflen then return nil, msg end |
|||
if i < n then |
|||
buflen = buflen + 1 |
|||
buffer[buflen] = "," |
|||
end |
|||
end |
|||
buflen = buflen + 1 |
|||
buffer[buflen] = "]" |
|||
else -- JSON object |
|||
local prev = false |
|||
buflen = buflen + 1 |
|||
buffer[buflen] = "{" |
|||
local order = valmeta and valmeta.__jsonorder or globalorder |
|||
if order then |
|||
local used = {} |
|||
n = #order |
|||
for i = 1, n do |
|||
local k = order[i] |
|||
local v = value[k] |
|||
if v then |
|||
used[k] = true |
|||
buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state) |
|||
prev = true -- add a seperator before the next element |
|||
end |
|||
end |
|||
for k,v in pairs (value) do |
|||
if not used[k] then |
|||
buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state) |
|||
if not buflen then return nil, msg end |
|||
prev = true -- add a seperator before the next element |
|||
end |
|||
end |
|||
else -- unordered |
|||
for k,v in pairs (value) do |
|||
buflen, msg = addpair (k, v, prev, indent, level, buffer, buflen, tables, globalorder, state) |
|||
if not buflen then return nil, msg end |
|||
prev = true -- add a seperator before the next element |
|||
end |
|||
end |
|||
if indent then |
|||
buflen = addnewline2 (level - 1, buffer, buflen) |
|||
end |
|||
buflen = buflen + 1 |
|||
buffer[buflen] = "}" |
|||
end |
|||
tables[value] = nil |
|||
else |
|||
return exception ('unsupported type', value, state, buffer, buflen, |
|||
"type '" .. valtype .. "' is not supported by JSON.") |
|||
end |
|||
return buflen |
|||
end |
|||
|
|||
function json.encode (value, state) |
|||
state = state or {} |
|||
local oldbuffer = state.buffer |
|||
local buffer = oldbuffer or {} |
|||
state.buffer = buffer |
|||
updatedecpoint() |
|||
local ret, msg = encode2 (value, state.indent, state.level or 0, |
|||
buffer, state.bufferlen or 0, state.tables or {}, state.keyorder, state) |
|||
if not ret then |
|||
error (msg, 2) |
|||
elseif oldbuffer == buffer then |
|||
state.bufferlen = ret |
|||
return true |
|||
else |
|||
state.bufferlen = nil |
|||
state.buffer = nil |
|||
return concat (buffer) |
|||
end |
|||
end |
|||
|
|||
local function loc (str, where) |
|||
local line, pos, linepos = 1, 1, 0 |
|||
while true do |
|||
pos = strfind (str, "\n", pos, true) |
|||
if pos and pos < where then |
|||
line = line + 1 |
|||
linepos = pos |
|||
pos = pos + 1 |
|||
else |
|||
break |
|||
end |
|||
end |
|||
return "line " .. line .. ", column " .. (where - linepos) |
|||
end |
|||
|
|||
local function unterminated (str, what, where) |
|||
return nil, strlen (str) + 1, "unterminated " .. what .. " at " .. loc (str, where) |
|||
end |
|||
|
|||
local function scanwhite (str, pos) |
|||
while true do |
|||
pos = strfind (str, "%S", pos) |
|||
if not pos then return nil end |
|||
local sub2 = strsub (str, pos, pos + 1) |
|||
if sub2 == "\239\187" and strsub (str, pos + 2, pos + 2) == "\191" then |
|||
-- UTF-8 Byte Order Mark |
|||
pos = pos + 3 |
|||
elseif sub2 == "//" then |
|||
pos = strfind (str, "[\n\r]", pos + 2) |
|||
if not pos then return nil end |
|||
elseif sub2 == "/*" then |
|||
pos = strfind (str, "*/", pos + 2) |
|||
if not pos then return nil end |
|||
pos = pos + 2 |
|||
else |
|||
return pos |
|||
end |
|||
end |
|||
end |
|||
|
|||
local escapechars = { |
|||
["\""] = "\"", ["\\"] = "\\", ["/"] = "/", ["b"] = "\b", ["f"] = "\f", |
|||
["n"] = "\n", ["r"] = "\r", ["t"] = "\t" |
|||
} |
|||
|
|||
local function unichar (value) |
|||
if value < 0 then |
|||
return nil |
|||
elseif value <= 0x007f then |
|||
return strchar (value) |
|||
elseif value <= 0x07ff then |
|||
return strchar (0xc0 + floor(value/0x40), |
|||
0x80 + (floor(value) % 0x40)) |
|||
elseif value <= 0xffff then |
|||
return strchar (0xe0 + floor(value/0x1000), |
|||
0x80 + (floor(value/0x40) % 0x40), |
|||
0x80 + (floor(value) % 0x40)) |
|||
elseif value <= 0x10ffff then |
|||
return strchar (0xf0 + floor(value/0x40000), |
|||
0x80 + (floor(value/0x1000) % 0x40), |
|||
0x80 + (floor(value/0x40) % 0x40), |
|||
0x80 + (floor(value) % 0x40)) |
|||
else |
|||
return nil |
|||
end |
|||
end |
|||
|
|||
local function scanstring (str, pos) |
|||
local lastpos = pos + 1 |
|||
local buffer, n = {}, 0 |
|||
while true do |
|||
local nextpos = strfind (str, "[\"\\]", lastpos) |
|||
if not nextpos then |
|||
return unterminated (str, "string", pos) |
|||
end |
|||
if nextpos > lastpos then |
|||
n = n + 1 |
|||
buffer[n] = strsub (str, lastpos, nextpos - 1) |
|||
end |
|||
if strsub (str, nextpos, nextpos) == "\"" then |
|||
lastpos = nextpos + 1 |
|||
break |
|||
else |
|||
local escchar = strsub (str, nextpos + 1, nextpos + 1) |
|||
local value |
|||
if escchar == "u" then |
|||
value = tonumber (strsub (str, nextpos + 2, nextpos + 5), 16) |
|||
if value then |
|||
local value2 |
|||
if 0xD800 <= value and value <= 0xDBff then |
|||
-- we have the high surrogate of UTF-16. Check if there is a |
|||
-- low surrogate escaped nearby to combine them. |
|||
if strsub (str, nextpos + 6, nextpos + 7) == "\\u" then |
|||
value2 = tonumber (strsub (str, nextpos + 8, nextpos + 11), 16) |
|||
if value2 and 0xDC00 <= value2 and value2 <= 0xDFFF then |
|||
value = (value - 0xD800) * 0x400 + (value2 - 0xDC00) + 0x10000 |
|||
else |
|||
value2 = nil -- in case it was out of range for a low surrogate |
|||
end |
|||
end |
|||
end |
|||
value = value and unichar (value) |
|||
if value then |
|||
if value2 then |
|||
lastpos = nextpos + 12 |
|||
else |
|||
lastpos = nextpos + 6 |
|||
end |
|||
end |
|||
end |
|||
end |
|||
if not value then |
|||
value = escapechars[escchar] or escchar |
|||
lastpos = nextpos + 2 |
|||
end |
|||
n = n + 1 |
|||
buffer[n] = value |
|||
end |
|||
end |
|||
if n == 1 then |
|||
return buffer[1], lastpos |
|||
elseif n > 1 then |
|||
return concat (buffer), lastpos |
|||
else |
|||
return "", lastpos |
|||
end |
|||
end |
|||
|
|||
local scanvalue -- forward declaration |
|||
|
|||
local function scantable (what, closechar, str, startpos, nullval, objectmeta, arraymeta) |
|||
local len = strlen (str) |
|||
local tbl, n = {}, 0 |
|||
local pos = startpos + 1 |
|||
if what == 'object' then |
|||
setmetatable (tbl, objectmeta) |
|||
else |
|||
setmetatable (tbl, arraymeta) |
|||
end |
|||
while true do |
|||
pos = scanwhite (str, pos) |
|||
if not pos then return unterminated (str, what, startpos) end |
|||
local char = strsub (str, pos, pos) |
|||
if char == closechar then |
|||
return tbl, pos + 1 |
|||
end |
|||
local val1, err |
|||
val1, pos, err = scanvalue (str, pos, nullval, objectmeta, arraymeta) |
|||
if err then return nil, pos, err end |
|||
pos = scanwhite (str, pos) |
|||
if not pos then return unterminated (str, what, startpos) end |
|||
char = strsub (str, pos, pos) |
|||
if char == ":" then |
|||
if val1 == nil then |
|||
return nil, pos, "cannot use nil as table index (at " .. loc (str, pos) .. ")" |
|||
end |
|||
pos = scanwhite (str, pos + 1) |
|||
if not pos then return unterminated (str, what, startpos) end |
|||
local val2 |
|||
val2, pos, err = scanvalue (str, pos, nullval, objectmeta, arraymeta) |
|||
if err then return nil, pos, err end |
|||
tbl[val1] = val2 |
|||
pos = scanwhite (str, pos) |
|||
if not pos then return unterminated (str, what, startpos) end |
|||
char = strsub (str, pos, pos) |
|||
else |
|||
n = n + 1 |
|||
tbl[n] = val1 |
|||
end |
|||
if char == "," then |
|||
pos = pos + 1 |
|||
end |
|||
end |
|||
end |
|||
|
|||
scanvalue = function (str, pos, nullval, objectmeta, arraymeta) |
|||
pos = pos or 1 |
|||
pos = scanwhite (str, pos) |
|||
if not pos then |
|||
return nil, strlen (str) + 1, "no valid JSON value (reached the end)" |
|||
end |
|||
local char = strsub (str, pos, pos) |
|||
if char == "{" then |
|||
return scantable ('object', "}", str, pos, nullval, objectmeta, arraymeta) |
|||
elseif char == "[" then |
|||
return scantable ('array', "]", str, pos, nullval, objectmeta, arraymeta) |
|||
elseif char == "\"" then |
|||
return scanstring (str, pos) |
|||
else |
|||
local pstart, pend = strfind (str, "^%-?[%d%.]+[eE]?[%+%-]?%d*", pos) |
|||
if pstart then |
|||
local number = str2num (strsub (str, pstart, pend)) |
|||
if number then |
|||
return number, pend + 1 |
|||
end |
|||
end |
|||
pstart, pend = strfind (str, "^%a%w*", pos) |
|||
if pstart then |
|||
local name = strsub (str, pstart, pend) |
|||
if name == "true" then |
|||
return true, pend + 1 |
|||
elseif name == "false" then |
|||
return false, pend + 1 |
|||
elseif name == "null" then |
|||
return nullval, pend + 1 |
|||
end |
|||
end |
|||
return nil, pos, "no valid JSON value at " .. loc (str, pos) |
|||
end |
|||
end |
|||
|
|||
local function optionalmetatables(...) |
|||
if select("#", ...) > 0 then |
|||
return ... |
|||
else |
|||
return {__jsontype = 'object'}, {__jsontype = 'array'} |
|||
end |
|||
end |
|||
|
|||
function json.decode (str, pos, nullval, ...) |
|||
local objectmeta, arraymeta = optionalmetatables(...) |
|||
return scanvalue (str, pos, nullval, objectmeta, arraymeta) |
|||
end |
|||
|
|||
function json.use_lpeg () |
|||
local g = require ("lpeg") |
|||
|
|||
if g.version() == "0.11" then |
|||
error "due to a bug in LPeg 0.11, it cannot be used for JSON matching" |
|||
end |
|||
|
|||
local pegmatch = g.match |
|||
local P, S, R = g.P, g.S, g.R |
|||
|
|||
local function ErrorCall (str, pos, msg, state) |
|||
if not state.msg then |
|||
state.msg = msg .. " at " .. loc (str, pos) |
|||
state.pos = pos |
|||
end |
|||
return false |
|||
end |
|||
|
|||
local function Err (msg) |
|||
return g.Cmt (g.Cc (msg) * g.Carg (2), ErrorCall) |
|||
end |
|||
|
|||
local SingleLineComment = P"//" * (1 - S"\n\r")^0 |
|||
local MultiLineComment = P"/*" * (1 - P"*/")^0 * P"*/" |
|||
local Space = (S" \n\r\t" + P"\239\187\191" + SingleLineComment + MultiLineComment)^0 |
|||
|
|||
local PlainChar = 1 - S"\"\\\n\r" |
|||
local EscapeSequence = (P"\\" * g.C (S"\"\\/bfnrt" + Err "unsupported escape sequence")) / escapechars |
|||
local HexDigit = R("09", "af", "AF") |
|||
local function UTF16Surrogate (match, pos, high, low) |
|||
high, low = tonumber (high, 16), tonumber (low, 16) |
|||
if 0xD800 <= high and high <= 0xDBff and 0xDC00 <= low and low <= 0xDFFF then |
|||
return true, unichar ((high - 0xD800) * 0x400 + (low - 0xDC00) + 0x10000) |
|||
else |
|||
return false |
|||
end |
|||
end |
|||
local function UTF16BMP (hex) |
|||
return unichar (tonumber (hex, 16)) |
|||
end |
|||
local U16Sequence = (P"\\u" * g.C (HexDigit * HexDigit * HexDigit * HexDigit)) |
|||
local UnicodeEscape = g.Cmt (U16Sequence * U16Sequence, UTF16Surrogate) + U16Sequence/UTF16BMP |
|||
local Char = UnicodeEscape + EscapeSequence + PlainChar |
|||
local String = P"\"" * g.Cs (Char ^ 0) * (P"\"" + Err "unterminated string") |
|||
local Integer = P"-"^(-1) * (P"0" + (R"19" * R"09"^0)) |
|||
local Fractal = P"." * R"09"^0 |
|||
local Exponent = (S"eE") * (S"+-")^(-1) * R"09"^1 |
|||
local Number = (Integer * Fractal^(-1) * Exponent^(-1))/str2num |
|||
local Constant = P"true" * g.Cc (true) + P"false" * g.Cc (false) + P"null" * g.Carg (1) |
|||
local SimpleValue = Number + String + Constant |
|||
local ArrayContent, ObjectContent |
|||
|
|||
-- The functions parsearray and parseobject parse only a single value/pair |
|||
-- at a time and store them directly to avoid hitting the LPeg limits. |
|||
local function parsearray (str, pos, nullval, state) |
|||
local obj, cont |
|||
local npos |
|||
local t, nt = {}, 0 |
|||
repeat |
|||
obj, cont, npos = pegmatch (ArrayContent, str, pos, nullval, state) |
|||
if not npos then break end |
|||
pos = npos |
|||
nt = nt + 1 |
|||
t[nt] = obj |
|||
until cont == 'last' |
|||
return pos, setmetatable (t, state.arraymeta) |
|||
end |
|||
|
|||
local function parseobject (str, pos, nullval, state) |
|||
local obj, key, cont |
|||
local npos |
|||
local t = {} |
|||
repeat |
|||
key, obj, cont, npos = pegmatch (ObjectContent, str, pos, nullval, state) |
|||
if not npos then break end |
|||
pos = npos |
|||
t[key] = obj |
|||
until cont == 'last' |
|||
return pos, setmetatable (t, state.objectmeta) |
|||
end |
|||
|
|||
local Array = P"[" * g.Cmt (g.Carg(1) * g.Carg(2), parsearray) * Space * (P"]" + Err "']' expected") |
|||
local Object = P"{" * g.Cmt (g.Carg(1) * g.Carg(2), parseobject) * Space * (P"}" + Err "'}' expected") |
|||
local Value = Space * (Array + Object + SimpleValue) |
|||
local ExpectedValue = Value + Space * Err "value expected" |
|||
ArrayContent = Value * Space * (P"," * g.Cc'cont' + g.Cc'last') * g.Cp() |
|||
local Pair = g.Cg (Space * String * Space * (P":" + Err "colon expected") * ExpectedValue) |
|||
ObjectContent = Pair * Space * (P"," * g.Cc'cont' + g.Cc'last') * g.Cp() |
|||
local DecodeValue = ExpectedValue * g.Cp () |
|||
|
|||
function json.decode (str, pos, nullval, ...) |
|||
local state = {} |
|||
state.objectmeta, state.arraymeta = optionalmetatables(...) |
|||
local obj, retpos = pegmatch (DecodeValue, str, pos, nullval, state) |
|||
if state.msg then |
|||
return nil, state.pos, state.msg |
|||
else |
|||
return obj, retpos |
|||
end |
|||
end |
|||
|
|||
-- use this function only once: |
|||
json.use_lpeg = function () return json end |
|||
|
|||
json.using_lpeg = true |
|||
|
|||
return json -- so you can get the module using json = require "dkjson".use_lpeg() |
|||
end |
|||
|
|||
if always_try_using_lpeg then |
|||
pcall (json.use_lpeg) |
|||
end |
|||
|
|||
return json |
|||
|
@ -0,0 +1,52 @@ |
|||
-- If you experience errors on the next line, |
|||
-- that means that you did not install lua-pam. |
|||
-- Run install_luapam.sh from the various-scripts directory. |
|||
local pam = require('pam') |
|||
local naughty = require("naughty") |
|||
|
|||
local function check_password(pw,username) |
|||
local function conversation(messages) |
|||
local responses = {} |
|||
for i, message in ipairs(messages) do |
|||
local msg_style, msg = message[1], message[2] |
|||
if msg_style == pam.PROMPT_ECHO_OFF then |
|||
-- Assume PAM asks us for the password |
|||
print("PAM Message: ",msg) |
|||
responses[i] = {pw, 0} |
|||
elseif msg_style == pam.PROMPT_ECHO_ON then |
|||
-- Assume PAM asks us for the username |
|||
print("PAM Message: ",msg) |
|||
responses[i] = {username or os.getenv("USER"), 0} |
|||
elseif msg_style == pam.ERROR_MSG then |
|||
print("PAM Error: ",msg) |
|||
responses[i] = {"", 0} |
|||
elseif msg_style == pam.TEXT_INFO then |
|||
print("PAM Info message: ",msg) |
|||
responses[i] = {"", 0} |
|||
else |
|||
print("Unsupported conversation message style for PAM: " .. msg_style) |
|||
print("PAM Message: ",msg) |
|||
end |
|||
end |
|||
return responses |
|||
end |
|||
local handler,err = pam.start("system-auth", nil, {conversation, nil}) |
|||
if not handler then |
|||
naughty.notify({title="PAM session start error: ",text=err,bg="#AA0000"}) |
|||
print("PAM session start error: ",err) |
|||
return false |
|||
end |
|||
local auth,err = pam.authenticate(handler) |
|||
if not auth then |
|||
print("PAM authentication error: ",err) |
|||
return false |
|||
end |
|||
local s_end,err = pam.endx(handler, pam.SUCCESS) |
|||
if not s_end then |
|||
naughty.notify({title="PAM session end error: ",text=err,bg="#AA0000"}) |
|||
print("PAM session end error: ",err) |
|||
return false |
|||
end |
|||
return true |
|||
end |
|||
return check_password |
@ -0,0 +1,29 @@ |
|||
-- A small utility function to generate thumbnails for images |
|||
local spawn = require("awful.spawn") |
|||
local thumbnailer = {} |
|||
-- annoying shit but that's what happens |
|||
if _VERSION ~= "Lua 5.1" then |
|||
execute = function(comm) |
|||
return select(3,os.execute(comm)) |
|||
end |
|||
else |
|||
execute = os.execute |
|||
end |
|||
thumbnailer.generate = function(path,thumb_path,height) |
|||
assert(type(path) == "string", "argumenr #1 (path) is not a string") |
|||
assert(type(thumb_path) == "string", "argument #2 (thumbnail path) is not a string") |
|||
assert(type(height) == "number","argument #3 (height) is not a number") |
|||
if execute("ls "..path) ~= 0 then |
|||
return false, "unable to access image directory" |
|||
end |
|||
if execute("ls "..thumb_path) == 0 then |
|||
return true |
|||
end |
|||
if execute("mkdir "..thumb_path) ~= 0 then |
|||
return false, "unable to create thumbnail directory" |
|||
end |
|||
spawn("mogrify -thumbnail x"..tostring(height).." -path '"..thumb_path.."' '"..path.."'/*.{jpg,png}") |
|||
return true |
|||
end |
|||
|
|||
return thumbnailer |
@ -0,0 +1,67 @@ |
|||
-- Base upon which modules are layered. |
|||
--libraries |
|||
local awful = require("awful") |
|||
local beautiful = require("beautiful") |
|||
local gears = require("gears") |
|||
global = {} |
|||
--error handling |
|||
if awesome.startup_errors then |
|||
print("Error during startup: "..awesome.startup_errors) |
|||
end |
|||
do |
|||
local in_error = false |
|||
awesome.connect_signal("debug::error",function(err) |
|||
if in_error then return end |
|||
in_error = true |
|||
print("Error during runtime: "..tostring(err)) |
|||
in_error = false |
|||
end) |
|||
end |
|||
|
|||
--theme |
|||
beautiful.init(gears.filesystem.get_themes_dir().."default/theme.lua") |
|||
|
|||
--screen setup |
|||
awful.screen.connect_for_each_screen(function(s) |
|||
awful.tag({ "1" }, s, awful.layout.suit.floating) |
|||
end) |
|||
|
|||
|
|||
--client mouse bindings |
|||
clientbuttons = gears.table.join( |
|||
awful.button({}, 1, function(c) |
|||
c:emit_signal("request::activate", "mouse_click", {raise = true}) |
|||
end) |
|||
) |
|||
|
|||
--client rules |
|||
awful.rules.rules = { |
|||
{ --catch-all rules |
|||
rule = {}, |
|||
properties = { |
|||
focus = awful.client.focus.filter, |
|||
raise = true, |
|||
keys = clientkeys, |
|||
buttons = clientbuttons, |
|||
screen = awful.screen.preferred, |
|||
placement = awful.placement.no_overlap+awful.placement.no_offscreen |
|||
} |
|||
} |
|||
} |
|||
|
|||
--client signals |
|||
client.connect_signal("manage", function(c) |
|||
-- append the window at the end rather than at the top. |
|||
-- if not awesome.startup then awful.client.setslave(c) end |
|||
if awesome.startup |
|||
--place client on available screens when screen count changes |
|||
and not c.size_hints.user_position |
|||
and not c.size_hints.program_position then |
|||
awful.placement.no_offscreen(c) |
|||
end |
|||
end) |
|||
|
|||
--screen setup |
|||
awful.screen.connect_for_each_screen(function(s) |
|||
awful.tag({ "1", "2", "3", "4" }, s, awful.layout.suit.floating) |
|||
end) |
@ -0,0 +1,100 @@ |
|||
-- Module that adds default keybindings |
|||
local awful = require("awful") |
|||
local gears = require("gears") |
|||
|
|||
global.modkey = global.modkey or "Mod4" |
|||
local keys = gears.table.join( |
|||
awful.key({global.modkey}, "Up", |
|||
function() |
|||
awful.client.focus.byidx(1) |
|||
end, |
|||
{description = "switch to next client", group = "client"}), |
|||
awful.key({global.modkey}, "Down", |
|||
function() |
|||
awful.client.focus.byidx(-1) |
|||
end, |
|||
{description = "switch to previous client", group = "client"}), |
|||
awful.key({global.modkey, "Control"}, "Up", |
|||
function() |
|||
awful.screen.focus_relative(1) |
|||
end, |
|||
{description = "switch to next screen", group = "screen"}), |
|||
awful.key({global.modkey, "Control"}, "Down", |
|||
function() |
|||
awful.screen.focus_relative(-1) |
|||
end, |
|||
{description = "switch to previous screen", group = "screen"}), |
|||
awful.key({global.modkey}, "Tab", |
|||
function() |
|||
awful.client.focus.history.previous() |
|||
if client.focus then |
|||
client.focus:raise() |
|||
end |
|||
end, |
|||
{description = "go back", group = "client"}), |
|||
awful.key({global.modkey}, "Return", |
|||
function() |
|||
awful.spawn(global.terminal) |
|||
end, |
|||
{description = "Open terminal", group = "launcher"}), |
|||
awful.key({global.modkey, "Shift"}, "Return", |
|||
function() |
|||
awful.spawn(global.browser) |
|||
end, |
|||
{description = "Open browser", group = "launcher"})) |
|||
root.keys(keys) |
|||
|
|||
local clientkeys = gears.table.join( |
|||
awful.key({global.modkey, "Shift"},"c", |
|||
function(c) |
|||
c:kill() |
|||
end, |
|||
{description = "close client", group = "client"}), |
|||
awful.key({global.modkey}, "o", |
|||
function(c) |
|||
c:move_to_screen() |
|||
end, |
|||
{description = "move to screen", group = "client"}), |
|||
awful.key({global.modkey}, "t", |
|||
function(c) |
|||
c.ontop = not c.ontop |
|||
end, |
|||
{description = "toggle ontop", group = "client"}), |
|||
awful.key({global.modkey}, "b", |
|||
function(c) |
|||
c.below = not c.below |
|||
end, |
|||
{description = "toggle below", group = "client"}), |
|||
awful.key({global.modkey}, "f", |
|||
function(c) |
|||
c.fullscreen = not c.fullscreen |
|||
c:raise() |
|||
end, |
|||
{description = "toggle fullscreen", group = "client"}), |
|||
awful.key({ global.modkey }, "n", |
|||
function (c) |
|||
c.minimized = true |
|||
end , |
|||
{description = "minimize", group = "client"}), |
|||
awful.key({ global.modkey }, "m", |
|||
function (c) |
|||
c.maximized = not c.maximized |
|||
c:raise() |
|||
end , |
|||
{description = "(un)maximize", group = "client"})) |
|||
awful.rules.rules[1].properties.keys = clientkeys |
|||
|
|||
local clientbuttons = gears.table.join( |
|||
awful.button({ }, 1, function (c) |
|||
c:emit_signal("request::activate", "mouse_click", {raise = true}) |
|||
end), |
|||
awful.button({ global.modkey }, 1, function (c) |
|||
c:emit_signal("request::activate", "mouse_click", {raise = true}) |
|||
awful.mouse.client.move(c) |
|||
end), |
|||
awful.button({ global.modkey }, 3, function (c) |
|||
c:emit_signal("request::activate", "mouse_click", {raise = true}) |
|||
awful.mouse.client.resize(c) |
|||
end)) |
|||
awful.rules.rules[1].properties.buttons = clientbuttons |
|||
|
@ -0,0 +1,15 @@ |
|||
-- Error logging module |
|||
local loghandler = io.open(os.getenv("HOME").."/.awesome_errors","w") |
|||
if awesome.startup_errors then |
|||
loghandler:write("[STARTUP] "..tostring(awesome.startup_errors).."\n") |
|||
end |
|||
do |
|||
local in_error = false |
|||
awesome.connect_signal("debug::error", function(err) |
|||
if in_error then return end |
|||
in_error = true |
|||
loghandler:write("[RUNTIME] "..tostring(err).."\n") |
|||
in_error = false |
|||
end) |
|||
end |
|||
|
@ -0,0 +1,5 @@ |
|||
-- Global settings |
|||
global = {} |
|||
global.terminal = "xfce4-terminal" --Mod+Enter (spawn terminal) |
|||
global.browser = "librewolf" --Mod+Shift+Enter (spawn browser) |
|||
global.modkey = "Mod4" -- Default modifier key |
@ -0,0 +1,62 @@ |
|||
-- Static set of tags that you find in the default awesomewm config |
|||
local awful = require("awful") |
|||
local gears = require("gears") |
|||
awful.screen.connect_for_each_screen(function(s) |
|||
-- Clear tags |
|||
for _, tag in pairs(s.tags) do |
|||
tag:delete() |
|||
end |
|||
-- Add 9 default tags |
|||
awful.tag({"1", "2", "3", "4", "5", "6", "7", "8", "9"}, s, |
|||
awful.layout.suit.floating) |
|||
end) |
|||
-- keybindings for tags |
|||
local keys = root.keys() |
|||
keys = gears.table.join(keys, |
|||
awful.key({global.modkey}, "Left", |
|||
awful.tag.viewprev, |
|||
{description = "view next tag", group = "tag"}), |
|||
awful.key({global.modkey}, "Right", |
|||
awful.tag.viewnext, |
|||
{description = "view previous tag", group = "tag"})) |
|||
|
|||
for i = 1,9 do |
|||
keys = gears.table.join(keys, |
|||
awful.key({global.modkey}, "#"..i+9, |
|||
function() |
|||
local tag = awful.screen.focused().tags[i] |
|||
if tag then |
|||
tag:view_only() |
|||
end |
|||
end, |
|||
{description = "view tag #"..i, group = "tag"}), |
|||
awful.key({global.modkey, "Control"}, "#"..i+9, |
|||
function() |
|||
local tag = awful.screen.focused().tags[i] |
|||
if tag then |
|||
awful.tag.viewtoggle(tag) |
|||
end |
|||
end, |
|||
{description = "toggle tag #"..i, group = "tag"}), |
|||
awful.key({global.modkey, "Shift"}, "#"..i+9, |
|||
function() |
|||
if client.focus then |
|||
local tag = awful.screen.focused().tags[i] |
|||
if tag then |
|||
client.focus:move_to_tag(tag) |
|||
end |
|||
end |
|||
end, |
|||
{description = "move client to tag #"..i, group = "tag"}), |
|||
awful.key({global.modkey, "Shift", "Control"}, "#"..i+9, |
|||
function() |
|||
if client.focus then |
|||
local tag = awful.screen.focused().tags[i] |
|||
if tag then |
|||
client.focus:move_to_tag(tag) |
|||
end |
|||
end |
|||
end, |
|||
{description = "toggle client on tag #"..i, group = "tag"})) |
|||
end |
|||
root.keys(keys) |
@ -0,0 +1,16 @@ |
|||
local awful = require("awful") |
|||
local gears = require("gears") |
|||
-- Wallpaper applied from homedir |
|||
awful.screen.connect_for_each_screen(function(s) |
|||
gears.wallpaper.maximized(root_path.."/background.jpg") |
|||
end) |
|||
|
|||
awful.rules.rules[1].properties.border_width = 2 |
|||
awful.rules.rules[1].properties.border_color = "#787B80" |
|||
client.connect_signal("focus", function(c) |
|||
c.border_color = "#3584E4" |
|||
end) |
|||
|
|||
client.connect_signal("unfocus", function(c) |
|||
c.border_color = "#787B80" |
|||
end) |
@ -1,61 +1,15 @@ |
|||
--libraries |
|||
local awful = require("awful") |
|||
local beautiful = require("beautiful") |
|||
local gears = require("gears") |
|||
|
|||
--error handling |
|||
if awesome.startup_errors then |
|||
print("Error during startup: "..awesome.startup_errors) |
|||
end |
|||
do |
|||
local in_error = false |
|||
awesome.connect_signal("debug::error",function(err) |
|||
if in_error then return end |
|||
in_error = true |
|||
print("Error during runtime: "..tostring(err)) |
|||
in_error = false |
|||
end) |
|||
end |
|||
|
|||
--theme |
|||
beautiful.init(gears.filesystem.get_themes_dir().."default/theme.lua") |
|||
|
|||
--screen setup |
|||
awful.screen.connect_for_each_screen(function(s) |
|||
awful.tag({ "1" }, s, awful.layout.suit.floating) |
|||
end) |
|||
|
|||
|
|||
--client mouse bindings |
|||
clientbuttons = gears.table.join( |
|||
awful.button({}, 1, function(c) |
|||
c:emit_signal("request::activate", "mouse_click", {raise = true}) |
|||
end) |
|||
) |
|||
|
|||
--client rules |
|||
awful.rules.rules = { |
|||
{ --catch-all rules |
|||
rule = {}, |
|||
properties = { |
|||
focus = awful.client.focus.filter, |
|||
raise = true, |
|||
keys = clientkeys, |
|||
buttons = clientbuttons, |
|||
screen = awful.screen.preferred, |
|||
placement = awful.placement.no_overlap+awful.placement.no_offscreen |
|||
} |
|||
} |
|||
} |
|||
|
|||
--client signals |
|||
client.connect_signal("manage", function(c) |
|||
-- append the window at the end rather than at the top. |
|||
-- if not awesome.startup then awful.client.setslave(c) end |
|||
if awesome.startup |
|||
--place client on available screens when screen count changes |
|||
and not c.size_hints.user_position |
|||
and not c.size_hints.program_position then |
|||
awful.placement.no_offscreen(c) |
|||
end |
|||
end) |
|||
-- Libraries path |
|||
root_path = os.getenv("HOME").."/.config/awesome" |
|||
package.path = package.path |
|||
..";"..root_path.."/libs/?.lua" |
|||
..";"..root_path.."/libs/?/init.lua" |
|||
package.cpath = package.cpath |
|||
..";"..root_path.."/libs/?.so" |
|||
|
|||
-- Modules list |
|||
require("modules.errorlog") |
|||
require("modules.base") |
|||
require("modules.global") |
|||
require("modules.binds") |
|||
require("modules.temp_crutches") |
|||
require("modules.static_tags") |
@ -0,0 +1,571 @@ |
|||
-- If LuaRocks is installed, make sure that packages installed through it are |
|||
-- found (e.g. lgi). If LuaRocks is not installed, do nothing. |
|||
pcall(require, "luarocks.loader") |
|||
|
|||
-- Standard awesome library |
|||
local gears = require("gears") |
|||
local awful = require("awful") |
|||
require("awful.autofocus") |
|||
-- Widget and layout library |
|||
local wibox = require("wibox") |
|||
-- Theme handling library |
|||
local beautiful = require("beautiful") |
|||
-- Notification library |
|||
local naughty = require("naughty") |
|||
local menubar = require("menubar") |
|||
local hotkeys_popup = require("awful.hotkeys_popup") |
|||
-- Enable hotkeys help widget for VIM and other apps |
|||
-- when client with a matching name is opened: |
|||
require("awful.hotkeys_popup.keys") |
|||
|
|||
-- {{{ Error handling |
|||
-- Check if awesome encountered an error during startup and fell back to |
|||
-- another config (This code will only ever execute for the fallback config) |
|||
if awesome.startup_errors then |
|||
naughty.notify({ preset = naughty.config.presets.critical, |
|||
title = "Oops, there were errors during startup!", |
|||
text = awesome.startup_errors }) |
|||
end |
|||
|
|||
-- Handle runtime errors after startup |
|||
do |
|||
local in_error = false |
|||
awesome.connect_signal("debug::error", function (err) |
|||
-- Make sure we don't go into an endless error loop |
|||
if in_error then return end |
|||
in_error = true |
|||
|
|||
naughty.notify({ preset = naughty.config.presets.critical, |
|||
title = "Oops, an error happened!", |
|||
text = tostring(err) }) |
|||
in_error = false |
|||
end) |
|||
end |
|||
-- }}} |
|||
|
|||
-- {{{ Variable definitions |
|||
-- Themes define colours, icons, font and wallpapers. |
|||
beautiful.init(gears.filesystem.get_themes_dir() .. "default/theme.lua") |
|||
|
|||
-- This is used later as the default terminal and editor to run. |
|||
terminal = "xterm" |
|||
editor = os.getenv("EDITOR") or "nano" |
|||
editor_cmd = terminal .. " -e " .. editor |
|||
|
|||
-- Default modkey. |
|||
-- Usually, Mod4 is the key with a logo between Control and Alt. |
|||
-- If you do not like this or do not have such a key, |
|||
-- I suggest you to remap Mod4 to another key using xmodmap or other tools. |
|||
-- However, you can use another modifier like Mod1, but it may interact with others. |
|||
modkey = "Mod4" |
|||
|
|||
-- Table of layouts to cover with awful.layout.inc, order matters. |
|||
awful.layout.layouts = { |
|||
awful.layout.suit.floating, |
|||
awful.layout.suit.tile, |
|||
awful.layout.suit.tile.left, |
|||
awful.layout.suit.tile.bottom, |
|||
awful.layout.suit.tile.top, |
|||
awful.layout.suit.fair, |
|||
awful.layout.suit.fair.horizontal, |
|||
awful.layout.suit.spiral, |
|||
awful.layout.suit.spiral.dwindle, |
|||
awful.layout.suit.max, |
|||
awful.layout.suit.max.fullscreen, |
|||
awful.layout.suit.magnifier, |
|||
awful.layout.suit.corner.nw, |
|||
-- awful.layout.suit.corner.ne, |
|||
-- awful.layout.suit.corner.sw, |
|||
-- awful.layout.suit.corner.se, |
|||
} |
|||
-- }}} |
|||
|
|||
-- {{{ Menu |
|||
-- Create a launcher widget and a main menu |
|||
myawesomemenu = { |
|||
{ "hotkeys", function() hotkeys_popup.show_help(nil, awful.screen.focused()) end }, |
|||
{ "manual", terminal .. " -e man awesome" }, |
|||
{ "edit config", editor_cmd .. " " .. awesome.conffile }, |
|||
{ "restart", awesome.restart }, |
|||
{ "quit", function() awesome.quit() end }, |
|||
} |
|||
|
|||
mymainmenu = awful.menu({ items = { { "awesome", myawesomemenu, beautiful.awesome_icon }, |
|||
{ "open terminal", terminal } |
|||
} |
|||
}) |
|||
|
|||
mylauncher = awful.widget.launcher({ image = beautiful.awesome_icon, |
|||
menu = mymainmenu }) |
|||
|
|||
-- Menubar configuration |
|||
menubar.utils.terminal = terminal -- Set the terminal for applications that require it |
|||
-- }}} |
|||
|
|||
-- Keyboard map indicator and switcher |
|||
mykeyboardlayout = awful.widget.keyboardlayout() |
|||
|
|||
-- {{{ Wibar |
|||
-- Create a textclock widget |
|||
mytextclock = wibox.widget.textclock() |
|||
|
|||
-- Create a wibox for each screen and add it |
|||
local taglist_buttons = gears.table.join( |
|||
awful.button({ }, 1, function(t) t:view_only() end), |
|||
awful.button({ modkey }, 1, function(t) |
|||
if client.focus then |
|||
client.focus:move_to_tag(t) |
|||
end |
|||
end), |
|||
awful.button({ }, 3, awful.tag.viewtoggle), |
|||
awful.button({ modkey }, 3, function(t) |
|||
if client.focus then |
|||
client.focus:toggle_tag(t) |
|||
end |
|||
end), |
|||
awful.button({ }, 4, function(t) awful.tag.viewnext(t.screen) end), |
|||
awful.button({ }, 5, function(t) awful.tag.viewprev(t.screen) end) |
|||
) |
|||
|
|||
local tasklist_buttons = gears.table.join( |
|||
awful.button({ }, 1, function (c) |
|||
if c == client.focus then |
|||
c.minimized = true |
|||
else |
|||
c:emit_signal( |
|||
"request::activate", |
|||
"tasklist", |
|||
{raise = true} |
|||
) |
|||
end |
|||
end), |
|||
awful.button({ }, 3, function() |
|||
awful.menu.client_list({ theme = { width = 250 } }) |
|||
end), |
|||
awful.button({ }, 4, function () |
|||
awful.client.focus.byidx(1) |
|||
end), |
|||
awful.button({ }, 5, function () |
|||
awful.client.focus.byidx(-1) |
|||
end)) |
|||
|
|||
local function set_wallpaper(s) |
|||
-- Wallpaper |
|||
if beautiful.wallpaper then |
|||
local wallpaper = beautiful.wallpaper |
|||
-- If wallpaper is a function, call it with the screen |
|||
if type(wallpaper) == "function" then |
|||
wallpaper = wallpaper(s) |
|||
end |
|||
gears.wallpaper.maximized(wallpaper, s, true) |
|||
end |
|||
end |
|||
|
|||
-- Re-set wallpaper when a screen's geometry changes (e.g. different resolution) |
|||
screen.connect_signal("property::geometry", set_wallpaper) |
|||
|
|||
awful.screen.connect_for_each_screen(function(s) |
|||
-- Wallpaper |
|||
set_wallpaper(s) |
|||
|
|||
-- Each screen has its own tag table. |
|||
awful.tag({ "5", "6", "7", "8", "9" }, s, awful.layout.layouts[1]) |
|||
|
|||
-- Create a promptbox for each screen |
|||
s.mypromptbox = awful.widget.prompt() |
|||
-- Create an imagebox widget which will contain an icon indicating which layout we're using. |
|||
-- We need one layoutbox per screen. |
|||
s.mylayoutbox = awful.widget.layoutbox(s) |
|||
s.mylayoutbox:buttons(gears.table.join( |
|||
awful.button({ }, 1, function () awful.layout.inc( 1) end), |
|||
awful.button({ }, 3, function () awful.layout.inc(-1) end), |
|||
awful.button({ }, 4, function () awful.layout.inc( 1) end), |
|||
awful.button({ }, 5, function () awful.layout.inc(-1) end))) |
|||
-- Create a taglist widget |
|||
s.mytaglist = awful.widget.taglist { |
|||
screen = s, |
|||
filter = awful.widget.taglist.filter.all, |
|||
buttons = taglist_buttons |
|||
} |
|||
|
|||
-- Create a tasklist widget |
|||
s.mytasklist = awful.widget.tasklist { |
|||
screen = s, |
|||
filter = awful.widget.tasklist.filter.currenttags, |
|||
buttons = tasklist_buttons |
|||
} |
|||
|
|||
-- Create the wibox |
|||
s.mywibox = awful.wibar({ position = "top", screen = s }) |
|||
|
|||
-- Add widgets to the wibox |
|||
s.mywibox:setup { |
|||
layout = wibox.layout.align.horizontal, |
|||
{ -- Left widgets |
|||
layout = wibox.layout.fixed.horizontal, |
|||
mylauncher, |
|||
s.mytaglist, |
|||
s.mypromptbox, |
|||
}, |
|||
s.mytasklist, -- Middle widget |
|||
{ -- Right widgets |
|||
layout = wibox.layout.fixed.horizontal, |
|||
mykeyboardlayout, |
|||
wibox.widget.systray(), |
|||
mytextclock, |
|||
s.mylayoutbox, |
|||
}, |
|||
} |
|||
end) |
|||
-- }}} |
|||
|
|||
-- {{{ Mouse bindings |
|||
root.buttons(gears.table.join( |
|||
awful.button({ }, 3, function () mymainmenu:toggle() end), |
|||
awful.button({ }, 4, awful.tag.viewnext), |
|||
awful.button({ }, 5, awful.tag.viewprev) |
|||
)) |
|||
-- }}} |
|||
|
|||
-- {{{ Key bindings |
|||
globalkeys = gears.table.join( |
|||
awful.key({ modkey, }, "s", hotkeys_popup.show_help, |
|||
{description="show help", group="awesome"}), |
|||
awful.key({ modkey, }, "Left", awful.tag.viewprev, |
|||
{description = "view previous", group = "tag"}), |
|||
awful.key({ modkey, }, "Right", awful.tag.viewnext, |
|||
{description = "view next", group = "tag"}), |
|||
awful.key({ modkey, }, "Escape", awful.tag.history.restore, |
|||
{description = "go back", group = "tag"}), |
|||
|
|||
awful.key({ modkey, }, "j", |
|||
function () |
|||
awful.client.focus.byidx( 1) |
|||
end, |
|||
{description = "focus next by index", group = "client"} |
|||
), |
|||
awful.key({ modkey, }, "k", |
|||
function () |
|||
awful.client.focus.byidx(-1) |
|||
end, |
|||
{description = "focus previous by index", group = "client"} |
|||
), |
|||
awful.key({ modkey, }, "w", function () mymainmenu:show() end, |
|||
{description = "show main menu", group = "awesome"}), |
|||
|
|||
-- Layout manipulation |
|||
awful.key({ modkey, "Shift" }, "j", function () awful.client.swap.byidx( 1) end, |
|||
{description = "swap with next client by index", group = "client"}), |
|||
awful.key({ modkey, "Shift" }, "k", function () awful.client.swap.byidx( -1) end, |
|||
{description = "swap with previous client by index", group = "client"}), |
|||
awful.key({ modkey, "Control" }, "j", function () awful.screen.focus_relative( 1) end, |
|||
{description = "focus the next screen", group = "screen"}), |
|||
awful.key({ modkey, "Control" }, "k", function () awful.screen.focus_relative(-1) end, |
|||
{description = "focus the previous screen", group = "screen"}), |
|||
awful.key({ modkey, }, "u", awful.client.urgent.jumpto, |
|||
{description = "jump to urgent client", group = "client"}), |
|||
awful.key({ modkey, }, "Tab", |
|||
function () |
|||
awful.client.focus.history.previous() |
|||
if client.focus then |
|||
client.focus:raise() |
|||
end |
|||
end, |
|||
{description = "go back", group = "client"}), |
|||
|
|||
-- Standard program |
|||
awful.key({ modkey, }, "Return", function () awful.spawn(terminal) end, |
|||
{description = "open a terminal", group = "launcher"}), |
|||
awful.key({ modkey, "Control" }, "r", awesome.restart, |
|||
{description = "reload awesome", group = "awesome"}), |
|||
awful.key({ modkey, "Shift" }, "q", awesome.quit, |
|||
{description = "quit awesome", group = "awesome"}), |
|||
|
|||
awful.key({ modkey, }, "l", function () awful.tag.incmwfact( 0.05) end, |
|||
{description = "increase master width factor", group = "layout"}), |
|||
awful.key({ modkey, }, "h", function () awful.tag.incmwfact(-0.05) end, |
|||
{description = "decrease master width factor", group = "layout"}), |
|||
awful.key({ modkey, "Shift" }, "h", function () awful.tag.incnmaster( 1, nil, true) end, |
|||
{description = "increase the number of master clients", group = "layout"}), |
|||
awful.key({ modkey, "Shift" }, "l", function () awful.tag.incnmaster(-1, nil, true) end, |
|||
{description = "decrease the number of master clients", group = "layout"}), |
|||
awful.key({ modkey, "Control" }, "h", function () awful.tag.incncol( 1, nil, true) end, |
|||
{description = "increase the number of columns", group = "layout"}), |
|||
awful.key({ modkey, "Control" }, "l", function () awful.tag.incncol(-1, nil, true) end, |
|||
{description = "decrease the number of columns", group = "layout"}), |
|||
awful.key({ modkey, }, "space", function () awful.layout.inc( 1) end, |
|||
{description = "select next", group = "layout"}), |
|||
awful.key({ modkey, "Shift" }, "space", function () awful.layout.inc(-1) end, |
|||
{description = "select previous", group = "layout"}), |
|||
|
|||
awful.key({ modkey, "Control" }, "n", |
|||
function () |
|||
local c = awful.client.restore() |
|||
-- Focus restored client |
|||
if c then |
|||
c:emit_signal( |
|||
"request::activate", "key.unminimize", {raise = true} |
|||
) |
|||
end |
|||
end, |
|||
{description = "restore minimized", group = "client"}), |
|||
|
|||
-- Prompt |
|||
awful.key({ modkey }, "r", function () awful.screen.focused().mypromptbox:run() end, |
|||
{description = "run prompt", group = "launcher"}), |
|||
|
|||
awful.key({ modkey }, "x", |
|||
function () |
|||
awful.prompt.run { |
|||
prompt = "Run Lua code: ", |
|||
textbox = awful.screen.focused().mypromptbox.widget, |
|||
exe_callback = awful.util.eval, |
|||
history_path = awful.util.get_cache_dir() .. "/history_eval" |
|||
} |
|||
end, |
|||
{description = "lua execute prompt", group = "awesome"}), |
|||
-- Menubar |
|||
awful.key({ modkey }, "p", function() menubar.show() end, |
|||
{description = "show the menubar", group = "launcher"}) |
|||
) |
|||
|
|||
clientkeys = gears.table.join( |
|||
awful.key({ modkey, }, "f", |
|||
function (c) |
|||
c.fullscreen = not c.fullscreen |
|||
c:raise() |
|||
end, |
|||
{description = "toggle fullscreen", group = "client"}), |
|||
awful.key({ modkey, "Shift" }, "c", function (c) c:kill() end, |
|||
{description = "close", group = "client"}), |
|||
awful.key({ modkey, "Control" }, "space", awful.client.floating.toggle , |
|||
{description = "toggle floating", group = "client"}), |
|||
awful.key({ modkey, "Control" }, "Return", function (c) c:swap(awful.client.getmaster()) end, |
|||
{description = "move to master", group = "client"}), |
|||
awful.key({ modkey, }, "o", function (c) c:move_to_screen() end, |
|||
{description = "move to screen", group = "client"}), |
|||
awful.key({ modkey, }, "t", function (c) c.ontop = not c.ontop end, |
|||
{description = "toggle keep on top", group = "client"}), |
|||
awful.key({ modkey, }, "n", |
|||
function (c) |
|||
-- The client currently has the input focus, so it cannot be |
|||
-- minimized, since minimized clients can't have the focus. |
|||
c.minimized = true |
|||
end , |
|||
{description = "minimize", group = "client"}), |
|||
awful.key({ modkey, }, "m", |
|||
function (c) |
|||
c.maximized = not c.maximized |
|||
c:raise() |
|||
end , |
|||
{description = "(un)maximize", group = "client"}), |
|||
awful.key({ modkey, "Control" }, "m", |
|||
function (c) |
|||
c.maximized_vertical = not c.maximized_vertical |
|||
c:raise() |
|||
end , |
|||
{description = "(un)maximize vertically", group = "client"}), |
|||
awful.key({ modkey, "Shift" }, "m", |
|||
function (c) |
|||
c.maximized_horizontal = not c.maximized_horizontal |
|||
c:raise() |
|||
end , |
|||
{description = "(un)maximize horizontally", group = "client"}) |
|||
) |
|||
|
|||
awful.screen.connect_for_each_screen(function(s) |
|||
for _, t in pairs(s.tags) do |
|||
t:delete() |
|||
end |
|||
awful.tag({ "1", "2", "3", "4", "5" }, s, awful.layout.layouts[1]) |
|||
end) |
|||
-- Bind all key numbers to tags. |
|||
-- Be careful: we use keycodes to make it work on any keyboard layout. |
|||
-- This should map on the top row of your keyboard, usually 1 to 9. |
|||
for i = 1, 5 do |
|||
globalkeys = gears.table.join(globalkeys, |
|||
-- View tag only. |
|||
awful.key({ modkey }, "#" .. i + 9, |
|||
function () |
|||
local screen = awful.screen.focused() |
|||
local tag = screen.tags[i] |
|||
if tag then |
|||
tag:view_only() |
|||
end |
|||
end, |
|||
{description = "view tag #"..i, group = "tag"}), |
|||
-- Toggle tag display. |
|||
awful.key({ modkey, "Control" }, "#" .. i + 9, |
|||
function () |
|||
local screen = awful.screen.focused() |
|||
local tag = screen.tags[i] |
|||
if tag then |
|||
awful.tag.viewtoggle(tag) |
|||
end |
|||
end, |
|||
{description = "toggle tag #" .. i, group = "tag"}), |
|||
-- Move client to tag. |
|||
awful.key({ modkey, "Shift" }, "#" .. i + 9, |
|||
function () |
|||
if client.focus then |
|||
local tag = client.focus.screen.tags[i] |
|||
if tag then |
|||
client.focus:move_to_tag(tag) |
|||
end |
|||
end |
|||
end, |
|||
{description = "move focused client to tag #"..i, group = "tag"}), |
|||
-- Toggle tag on focused client. |
|||
awful.key({ modkey, "Control", "Shift" }, "#" .. i + 9, |
|||
function () |
|||
if client.focus then |
|||
local tag = client.focus.screen.tags[i] |
|||
if tag then |
|||
client.focus:toggle_tag(tag) |
|||
end |
|||
end |
|||
end, |
|||
{description = "toggle focused client on tag #" .. i, group = "tag"}) |
|||
) |
|||
end |
|||
|
|||
clientbuttons = gears.table.join( |
|||
awful.button({ }, 1, function (c) |
|||
c:emit_signal("request::activate", "mouse_click", {raise = true}) |
|||
end), |
|||
awful.button({ modkey }, 1, function (c) |
|||
c:emit_signal("request::activate", "mouse_click", {raise = true}) |
|||
awful.mouse.client.move(c) |
|||
end), |
|||
awful.button({ modkey }, 3, function (c) |
|||
c:emit_signal("request::activate", "mouse_click", {raise = true}) |
|||
awful.mouse.client.resize(c) |
|||
end) |
|||
) |
|||
|
|||
-- Set keys |
|||
root.keys(globalkeys) |
|||
-- }}} |
|||
|
|||
-- {{{ Rules |
|||
-- Rules to apply to new clients (through the "manage" signal). |
|||
awful.rules.rules = { |
|||
-- All clients will match this rule. |
|||
{ rule = { }, |
|||
properties = { border_width = beautiful.border_width, |
|||
border_color = beautiful.border_normal, |
|||
focus = awful.client.focus.filter, |
|||
raise = true, |
|||
keys = clientkeys, |
|||
buttons = clientbuttons, |
|||
screen = awful.screen.preferred, |
|||
placement = awful.placement.no_overlap+awful.placement.no_offscreen |
|||
} |
|||
}, |
|||
|
|||
-- Floating clients. |
|||
{ rule_any = { |
|||
instance = { |
|||
"DTA", -- Firefox addon DownThemAll. |
|||
"copyq", -- Includes session name in class. |
|||
"pinentry", |
|||
}, |
|||
class = { |
|||
"Arandr", |
|||
"Blueman-manager", |
|||
"Gpick", |
|||
"Kruler", |
|||
"MessageWin", -- kalarm. |
|||
"Sxiv", |
|||
"Tor Browser", -- Needs a fixed window size to avoid fingerprinting by screen size. |
|||
"Wpa_gui", |
|||
"veromix", |
|||
"xtightvncviewer"}, |
|||
|
|||
-- Note that the name property shown in xprop might be set slightly after creation of the client |
|||
-- and the name shown there might not match defined rules here. |
|||
name = { |
|||
"Event Tester", -- xev. |
|||
}, |
|||
role = { |
|||
"AlarmWindow", -- Thunderbird's calendar. |
|||
"ConfigManager", -- Thunderbird's about:config. |
|||
"pop-up", -- e.g. Google Chrome's (detached) Developer Tools. |
|||
} |
|||
}, properties = { floating = true }}, |
|||
|
|||
-- Add titlebars to normal clients and dialogs |
|||
{ rule_any = {type = { "normal", "dialog" } |
|||
}, properties = { titlebars_enabled = true } |
|||
}, |
|||
|
|||
-- Set Firefox to always map on the tag named "2" on screen 1. |
|||
-- { rule = { class = "Firefox" }, |
|||
-- properties = { screen = 1, tag = "2" } }, |
|||
} |
|||
-- }}} |
|||
|
|||
-- {{{ Signals |
|||
-- Signal function to execute when a new client appears. |
|||
client.connect_signal("manage", function (c) |
|||
-- Set the windows at the slave, |
|||
-- i.e. put it at the end of others instead of setting it master. |
|||
-- if not awesome.startup then awful.client.setslave(c) end |
|||
|
|||
if awesome.startup |
|||
and not c.size_hints.user_position |
|||
and not c.size_hints.program_position then |
|||
-- Prevent clients from being unreachable after screen count changes. |
|||
awful.placement.no_offscreen(c) |
|||
end |
|||
end) |
|||
|
|||
-- Add a titlebar if titlebars_enabled is set to true in the rules. |
|||
client.connect_signal("request::titlebars", function(c) |
|||
-- buttons for the titlebar |
|||
local buttons = gears.table.join( |
|||
awful.button({ }, 1, function() |
|||
c:emit_signal("request::activate", "titlebar", {raise = true}) |
|||
awful.mouse.client.move(c) |
|||
end), |
|||
awful.button({ }, 3, function() |
|||
c:emit_signal("request::activate", "titlebar", {raise = true}) |
|||
awful.mouse.client.resize(c) |
|||
end) |
|||
) |
|||
|
|||
awful.titlebar(c) : setup { |
|||
{ -- Left |
|||
awful.titlebar.widget.iconwidget(c), |
|||
buttons = buttons, |
|||
layout = wibox.layout.fixed.horizontal |
|||
}, |
|||
{ -- Middle |
|||
{ -- Title |
|||
align = "center", |
|||
widget = awful.titlebar.widget.titlewidget(c) |
|||
}, |
|||
buttons = buttons, |
|||
layout = wibox.layout.flex.horizontal |
|||
}, |
|||
{ -- Right |
|||
awful.titlebar.widget.floatingbutton (c), |
|||
awful.titlebar.widget.maximizedbutton(c), |
|||
awful.titlebar.widget.stickybutton (c), |
|||
awful.titlebar.widget.ontopbutton (c), |
|||
awful.titlebar.widget.closebutton (c), |
|||
layout = wibox.layout.fixed.horizontal() |
|||
}, |
|||
layout = wibox.layout.align.horizontal |
|||
} |
|||
end) |
|||
|
|||
-- Enable sloppy focus, so that focus follows mouse. |
|||
client.connect_signal("mouse::enter", function(c) |
|||
c:emit_signal("request::activate", "mouse_enter", {raise = false}) |
|||
end) |
|||
|
|||
client.connect_signal("focus", function(c) c.border_color = beautiful.border_focus end) |
|||
client.connect_signal("unfocus", function(c) c.border_color = beautiful.border_normal end) |
|||
-- }}} |
|||
|
Write
Preview
Loading…
Cancel
Save
Reference in new issue