Adding AwesomeWM to the dotfiles finally.

.config/awesome/autostart.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+function run {
+  if ! pgrep $1 ;
+  then
+    $@&
+  fi
+}
+#run "xrandr --output VGA-1 --primary --mode 1360x768 --pos 0x0 --rotate normal"
+#run "xrandr --output HDMI2 --mode 1920x1080 --pos 1920x0 --rotate normal --output HDMI1 --primary --mode 1920x1080 --pos 0x0 --rotate normal --output VIRTUAL1 --off"
+run "nm-applet"
+#run "caffeine"
+run "xfce4-power-manager"
+run "blueberry-tray"
+run "/usr/lib/polkit-gnome/polkit-gnome-authentication-agent-1"
+run "numlockx on"
+run "volumeicon"
+run "nitrogen --restore"
+#run "conky -c $HOME/.config/awesome/system-overview"
+
+#run applications from startup
+#run "firefox"
+#run "atom"
+#run "dropbox"
+#run "insync start"
+#run "spotify"

.config/awesome/freedesktop/awesome-freedesktop-scm-1.rockspec

@@ -0,0 +1,20 @@
+package = "awesome-freedesktop"
+version = "scm-1"
+source = {
+   url = "https://github.com/lcpz/awesome-freedesktop",
+   tag = "scm-1`"
+}
+description = {
+   summary = "Freedesktop.org menu and desktop icons support for Awesome WM",
+   homepage = "https://github.com/lcpz/awesome-freedesktop",
+   license = "GPL v2"
+}
+dependencies = {
+   "lua >= 5.3",
+   "awesome >= 4.0"
+}
+supported_platforms = { "linux" }
+build = {
+   type = "builtin",
+   modules = { freedesktop = "init.lua" }
+}

.config/awesome/freedesktop/desktop.lua

@@ -0,0 +1,254 @@
+--[[
+
+     Awesome-Freedesktop
+     Freedesktop.org compliant desktop entries and menu
+
+     Desktop section
+
+     Licensed under GNU General Public License v2
+      * (c) 2016,      Luke Bonham
+      * (c) 2009-2015, Antonio Terceiro
+
+--]]
+
+local awful  = require("awful")
+local theme  = require("beautiful")
+local utils  = require("menubar.utils")
+local wibox  = require("wibox")
+
+local capi   = capi
+local io     = io
+local ipairs = ipairs
+local mouse  = mouse
+local os     = os
+local string = string
+local table  = table
+
+-- Desktop icons
+-- freedesktop.desktop
+local desktop = {
+    -- Default desktop basic icons
+    baseicons = {
+        [1] = {
+            label = "This PC",
+            icon  = "computer",
+            onclick = "computer://"
+        },
+        [2] = {
+            label = "Home",
+            icon  = "user-home",
+            onclick = os.getenv("HOME")
+        },
+        [3] = {
+            label = "Trash",
+            icon  = "user-trash",
+            onclick = "trash://"
+        }
+    },
+    -- Default parameters
+    iconsize   = { width = 48,  height = 48 },
+    labelsize  = { width = 140, height = 20 },
+    margin     = { x = 20, y = 20 },
+}
+
+-- MIME types list
+local mime_types = {}
+
+-- Icons positioning
+local desktop_current_pos = {}
+
+-- @return iterator on input pipe
+local function pipelines(...)
+    local f = assert(io.popen(...))
+    return function ()
+        local data = f:read()
+        if data == nil then f:close() end
+        return data
+    end
+end
+
+-- Adds an icon to desktop
+-- @param args settings from desktop.add_icons
+-- @param label icon string label
+-- @param icon icon string file path
+-- @param onclick function to execute on click
+function desktop.add_single_icon(args, label, icon, onclick)
+    local s = args.screen
+
+    -- define icon dimensions and position
+    if not desktop_current_pos[s] then
+        desktop_current_pos[s] = { x = (capi.screen[s].geometry.x + args.iconsize.width + args.margin.x), y = 40 }
+    end
+
+    local totheight = (icon and args.iconsize.height or 0) + (label and args.labelsize.height or 0)
+    if totheight == 0 then return end
+
+    if desktop_current_pos[s].y + totheight > capi.screen[s].geometry.height - 40 then
+        desktop_current_pos[s].x = desktop_current_pos[s].x + args.labelsize.width + args.iconsize.width + args.margin.x
+        desktop_current_pos[s].y = 40
+    end
+
+    local common = { screen = s, bg = "#00000000", visible = true, type = "desktop" }
+
+    -- create icon container
+    if icon then
+        common.width = args.iconsize.width
+        common.height = args.iconsize.height
+        common.x = desktop_current_pos[s].x
+        common.y = desktop_current_pos[s].y
+
+        icon = wibox.widget {
+            image = icon,
+            resize = false,
+            widget = wibox.widget.imagebox
+        }
+
+        icon:buttons(awful.button({ }, 1, nil, onclick))
+
+        icon_container = wibox(common)
+        icon_container:set_widget(icon)
+
+        desktop_current_pos[s].y = desktop_current_pos[s].y + args.iconsize.height + 5
+    end
+
+    -- create label container
+    if label then
+        common.width = args.labelsize.width
+        common.height = args.labelsize.height
+        common.x = desktop_current_pos[s].x - (args.labelsize.width/2) + args.iconsize.width/2
+        common.y = desktop_current_pos[s].y
+
+        caption = wibox.widget {
+            text          = label,
+            align         = "center",
+            forced_width  = common.width,
+            forced_height = common.height,
+            ellipsize     = "middle",
+            widget        = wibox.widget.textbox
+        }
+
+        caption:buttons(awful.button({ }, 1, onclick))
+        caption_container = wibox(common)
+        caption_container:set_widget(caption)
+    end
+
+    desktop_current_pos[s].y = desktop_current_pos[s].y + args.labelsize.height + args.margin.y
+end
+
+-- Adds base icons (This PC, Trash, etc) to desktop
+-- @param args settings from desktop.add_icons
+function desktop.add_base_icons(args)
+    for _,base in ipairs(args.baseicons) do
+        desktop.add_single_icon(args, base.label, utils.lookup_icon(base.icon), function()
+            awful.spawn(string.format("%s '%s'", args.open_with, base.onclick))
+        end)
+    end
+end
+
+-- Looks up a suitable icon for filename
+-- @param filename string file name
+-- @return icon file path (string)
+function desktop.lookup_file_icon(filename)
+    -- load system MIME types
+    if #mime_types == 0 then
+        for line in io.lines("/etc/mime.types") do
+            if not line:find("^#") then
+                local parsed = {}
+                for w in line:gmatch("[^%s]+") do
+                    table.insert(parsed, w)
+                end
+                if #parsed > 1 then
+                    for i = 2, #parsed do
+                        mime_types[parsed[i]] = parsed[1]:gsub("/", "-")
+                    end
+                end
+            end
+        end
+    end
+
+    -- try to search a possible icon among standards
+    local extension = filename:match("%a+$")
+    local mime = mime_types[extension] or ""
+    local mime_family = mime:match("^%a+") or ""
+
+    local possible_filenames = {
+        mime, "gnome-mime-" .. mime,
+        mime_family, "gnome-mime-" .. mime_family,
+        extension
+    }
+
+    for i, filename in ipairs(possible_filenames) do
+        local icon = utils.lookup_icon(filename)
+        if icon then return icon end
+    end
+
+    -- if we don"t find ad icon, then pretend is a plain text file
+    return utils.lookup_icon("text-x-generic")
+end
+
+-- Parse subdirectories and files list from input directory
+-- @input dir directory to parse (string)
+-- @return files table with found entries
+function desktop.parse_dirs_and_files(dir)
+    local files = {}
+    local paths = pipelines('find '..dir..' -maxdepth 1 -type d | tail -1')
+    for path in paths do
+        if path:match("[^/]+$") then
+            local file = {}
+            file.filename = path:match("[^/]+$")
+            file.path = path
+            file.show = true
+            file.icon = utils.lookup_icon("folder")
+            table.insert(files, file)
+        end
+    end
+    local paths = pipelines('find '..dir..' -maxdepth 1 -type f')
+    for path in paths do
+        if not path:find("%.desktop$") then
+            local file = {}
+            file.filename = path:match("[^/]+$")
+            file.path = path
+            file.show = true
+            file.icon = desktop.lookup_file_icon(file.filename)
+            table.insert(files, file)
+        end
+    end
+    return files
+end
+
+-- Adds subdirectories and files icons from args.dir
+-- @param args settings from desktop.add_icons
+function desktop.add_dirs_and_files_icons(args)
+    for _, file in ipairs(desktop.parse_dirs_and_files(args.dir)) do
+        if file.show then
+            local label = args.showlabels and file.filename or nil
+            local onclick = function () awful.spawn(string.format("%s '%s'", args.open_with, file.path)) end
+            desktop.add_single_icon(args, label, file.icon, onclick)
+        end
+    end
+end
+
+-- Main function, adds base, directory and files icons
+-- @param args user defined settings, with fallback on defaults
+function desktop.add_icons(args)
+    args            = args or {}
+    args.screen     = args.screen or mouse.screen
+    args.dir        = args.dir or os.getenv("HOME") .. "/Desktop"
+    args.showlabels = args.showlabel or true
+    args.open_with  = args.open_with or "xdg_open"
+    args.baseicons  = args.baseicons or desktop.baseicons
+    args.iconsize   = args.iconsize or desktop.iconsize
+    args.labelsize  = args.labelsize or desktop.labelsize
+    args.margin     = args.margin or desktop.margin
+
+    -- trying to fallback on Adwaita if theme.icon_theme is not defined
+    -- if Adwaita is missing too, no icons will be shown
+    if not theme.icon_theme then
+        theme.icon_theme = args.icon_theme or "Adwaita"
+    end
+
+    desktop.add_base_icons(args)
+    desktop.add_dirs_and_files_icons(args)
+end
+
+return desktop

.config/awesome/freedesktop/init.lua

@@ -0,0 +1,15 @@
+--[[
+
+     Awesome-Freedesktop
+     Freedesktop.org compliant desktop entries and menu
+
+     Licensed under GNU General Public License v2
+      * (c) 2016,      Luke Bonham
+      * (c) 2009-2015, Antonio Terceiro
+
+--]]
+
+return {
+    desktop  = require("freedesktop.desktop"),
+    menu     = require("freedesktop.menu")
+}

.config/awesome/freedesktop/menu.lua

@@ -0,0 +1,125 @@
+--[[
+
+     Awesome-Freedesktop
+     Freedesktop.org compliant desktop entries and menu
+
+     Menu section
+
+     Licensed under GNU General Public License v2
+      * (c) 2016, Luke Bonham
+      * (c) 2014, Harvey Mittens
+
+--]]
+
+local awful_menu = require("awful.menu")
+local menu_gen   = require("menubar.menu_gen")
+local menu_utils = require("menubar.utils")
+local icon_theme = require("menubar.icon_theme")
+local gls        = require("gears.filesystem")
+
+local pairs, string, table, os = pairs, string, table, os
+
+-- Add support for NixOS systems too
+table.insert(menu_gen.all_menu_dirs, string.format("%s/.nix-profile/share/applications", os.getenv("HOME")))
+
+-- Remove non existent paths in order to avoid issues
+local existent_paths = {}
+for k,v in pairs(menu_gen.all_menu_dirs) do
+    if gls.is_dir(v) then
+        table.insert(existent_paths, v)
+    end
+end
+menu_gen.all_menu_dirs = existent_paths
+
+-- Expecting a wm_name of awesome omits too many applications and tools
+menu_utils.wm_name = ""
+
+-- Menu
+-- freedesktop.menu
+local menu = {}
+
+-- Determines whether an table includes a certain element
+-- @param tab a given table
+-- @param val the element to search for
+-- @return true if the given string is found within the search table; otherwise, false if not
+function menu.has_value (tab, val)
+    for index, value in pairs(tab) do
+        if val:find(value) then
+            return true
+        end
+    end
+    return false
+end
+
+-- Use MenuBar parsing utils to build a menu for Awesome
+-- @return awful.menu
+function menu.build(args)
+    local args       = args or {}
+    local icon_size  = args.icon_size
+    local before     = args.before or {}
+    local after      = args.after or {}
+    local skip_items = args.skip_items or {}
+    local sub_menu   = args.sub_menu or false
+
+    local result     = {}
+    local _menu      = awful_menu({ items = before })
+
+    menu_gen.generate(function(entries)
+        -- Add category icons
+        for k, v in pairs(menu_gen.all_categories) do
+            table.insert(result, { k, {}, v.icon })
+        end
+
+        -- Get items table
+        for k, v in pairs(entries) do
+            for _, cat in pairs(result) do
+                if cat[1] == v.category then
+                    if not menu.has_value(skip_items, v.name) then
+                        table.insert(cat[2], { v.name, v.cmdline, v.icon })
+                    end
+                    break
+                end
+            end
+        end
+
+        -- Cleanup things a bit
+        for i = #result, 1, -1 do
+            local v = result[i]
+            if #v[2] == 0 then
+                -- Remove unused categories
+                table.remove(result, i)
+            else
+                --Sort entries alphabetically (by name)
+                table.sort(v[2], function (a, b) return string.byte(a[1]) < string.byte(b[1]) end)
+                -- Replace category name with nice name
+                v[1] = menu_gen.all_categories[v[1]].name
+            end
+        end
+
+        -- Sort categories alphabetically also
+        table.sort(result, function(a, b) return string.byte(a[1]) < string.byte(b[1]) end)
+
+        -- Add menu item to hold the generated menu
+        if sub_menu then
+            result = {{sub_menu, result}}
+        end
+
+        -- Add items to menu
+        for _, v in pairs(result) do _menu:add(v) end
+        for _, v in pairs(after)  do _menu:add(v) end
+    end)
+
+    -- Set icon size
+    if icon_size then
+        for _,v in pairs(menu_gen.all_categories) do
+            v.icon = icon_theme():find_icon_path(v.icon_name, icon_size)
+        end
+    end
+
+    -- Hold the menu in the module
+    menu.menu = _menu
+
+    return _menu
+end
+
+return menu

.config/awesome/lain/helpers.lua

@@ -0,0 +1,203 @@
+--[[
+
+     Licensed under GNU General Public License v2
+      * (c) 2013, Luca CPZ
+
+--]]
+
+local spawn      = require("awful.spawn")
+local timer      = require("gears.timer")
+local debug      = require("debug")
+local io         = { lines = io.lines,
+                     open  = io.open }
+local pairs      = pairs
+local rawget     = rawget
+local table      = { sort  = table.sort }
+
+-- Lain helper functions for internal use
+-- lain.helpers
+local helpers = {}
+
+helpers.lain_dir    = debug.getinfo(1, 'S').source:match[[^@(.*/).*$]]
+helpers.icons_dir   = helpers.lain_dir .. 'icons/'
+helpers.scripts_dir = helpers.lain_dir .. 'scripts/'
+
+-- {{{ Modules loader
+
+function helpers.wrequire(table, key)
+    local module = rawget(table, key)
+    return module or require(table._NAME .. '.' .. key)
+end
+
+-- }}}
+
+-- {{{ File operations
+
+-- check if the file exists and is readable
+function helpers.file_exists(path)
+    local file = io.open(path, "rb")
+    if file then file:close() end
+    return file ~= nil
+end
+
+-- get a table with all lines from a file
+function helpers.lines_from(path)
+    local lines = {}
+    for line in io.lines(path) do
+        lines[#lines + 1] = line
+    end
+    return lines
+end
+
+-- get a table with all lines from a file matching regexp
+function helpers.lines_match(regexp, path)
+    local lines = {}
+    for line in io.lines(path) do
+        if string.match(line, regexp) then
+            lines[#lines + 1] = line
+        end
+    end
+    return lines
+end
+
+-- get first line of a file
+function helpers.first_line(path)
+    local file, first = io.open(path, "rb"), nil
+    if file then
+        first = file:read("*l")
+        file:close()
+    end
+    return first
+end
+
+-- get first non empty line from a file
+function helpers.first_nonempty_line(path)
+    for line in io.lines(path) do
+        if #line then return line end
+    end
+    return nil
+end
+
+-- }}}
+
+-- {{{ Timer maker
+
+helpers.timer_table = {}
+
+function helpers.newtimer(name, timeout, fun, nostart, stoppable)
+    if not name or #name == 0 then return end
+    name = (stoppable and name) or timeout
+    if not helpers.timer_table[name] then
+        helpers.timer_table[name] = timer({ timeout = timeout })
+        helpers.timer_table[name]:start()
+    end
+    helpers.timer_table[name]:connect_signal("timeout", fun)
+    if not nostart then
+        helpers.timer_table[name]:emit_signal("timeout")
+    end
+    return stoppable and helpers.timer_table[name]
+end
+
+-- }}}
+
+-- {{{ Pipe operations
+
+-- run a command and execute a function on its output (asynchronous pipe)
+-- @param cmd the input command
+-- @param callback function to execute on cmd output
+-- @return cmd PID
+function helpers.async(cmd, callback)
+    return spawn.easy_async(cmd,
+    function (stdout, stderr, reason, exit_code)
+        callback(stdout, exit_code)
+    end)
+end
+
+-- like above, but call spawn.easy_async with a shell
+function helpers.async_with_shell(cmd, callback)
+    return spawn.easy_async_with_shell(cmd,
+    function (stdout, stderr, reason, exit_code)
+        callback(stdout, exit_code)
+    end)
+end
+
+-- run a command and execute a function on its output line by line
+function helpers.line_callback(cmd, callback)
+    return spawn.with_line_callback(cmd, {
+        stdout = function (line)
+            callback(line)
+        end,
+    })
+end
+
+-- }}}
+
+-- {{{ A map utility
+
+helpers.map_table = {}
+
+function helpers.set_map(element, value)
+    helpers.map_table[element] = value
+end
+
+function helpers.get_map(element)
+    return helpers.map_table[element]
+end
+
+-- }}}
+
+-- {{{ Misc
+
+-- check if an element exist on a table
+function helpers.element_in_table(element, tbl)
+    for _, i in pairs(tbl) do
+        if i == element then
+            return true
+        end
+    end
+    return false
+end
+
+-- iterate over table of records sorted by keys
+function helpers.spairs(t)
+    -- collect the keys
+    local keys = {}
+    for k in pairs(t) do keys[#keys+1] = k end
+
+    table.sort(keys)
+
+    -- return the iterator function
+    local i = 0
+    return function()
+        i = i + 1
+        if keys[i] then
+            return keys[i], t[keys[i]]
+        end
+    end
+end
+
+-- create the partition of singletons of a given set
+-- example: the trivial partition set of {a, b, c}, is {{a}, {b}, {c}}
+function helpers.trivial_partition_set(set)
+    local ss = {}
+    for _,e in pairs(set) do
+        ss[#ss+1] = {e}
+    end
+    return ss
+end
+
+-- creates the powerset of a given set
+function helpers.powerset(s)
+    if not s then return {} end
+    local t = {{}}
+    for i = 1, #s do
+        for j = 1, #t do
+            t[#t+1] = {s[i],unpack(t[j])}
+        end
+    end
+    return t
+end
+
+-- }}}
+
+return helpers

.config/awesome/lain/icons/openweathermap/04n.png

@@ -0,0 +1 @@
+04d.png

.config/awesome/lain/icons/openweathermap/09n.png

@@ -0,0 +1 @@
+09d.png

.config/awesome/lain/icons/openweathermap/10n.png

@@ -0,0 +1 @@
+10d.png