diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..34ce596 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,8 @@ +[submodule "awesome/awesome-wm-widgets"] + path = awesome/awesome-wm-widgets + url = https://github.com/streetturtle/awesome-wm-widgets + branch = master +[submodule "awesome/volume-control"] + path = awesome/volume-control + url = https://github.com/deficient/volume-control.git + branch = master diff --git a/awesome/autorun.sh b/awesome/autorun.sh new file mode 100755 index 0000000..5a6e042 --- /dev/null +++ b/awesome/autorun.sh @@ -0,0 +1,12 @@ +#!/usr/bin/env bash + +function run { + if ! pgrep -f $1 ; + then + $@& + fi +} + +run setxkbmap -option caps:escape -layout us -variant altgr-intl +run pulseaudio --start +~/.dotfiles/change-wallpaper.sh diff --git a/awesome/awesome-wm-widgets b/awesome/awesome-wm-widgets new file mode 160000 index 0000000..6fc9f66 --- /dev/null +++ b/awesome/awesome-wm-widgets @@ -0,0 +1 @@ +Subproject commit 6fc9f668491ecdb19578a0ac6c5a1be0b8b42881 diff --git a/awesome/freedesktop/LICENSE b/awesome/freedesktop/LICENSE new file mode 100644 index 0000000..23cb790 --- /dev/null +++ b/awesome/freedesktop/LICENSE @@ -0,0 +1,339 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Lesser General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + {description} + Copyright (C) {year} {fullname} + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License along + with this program; if not, write to the Free Software Foundation, Inc., + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + {signature of Ty Coon}, 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. diff --git a/awesome/freedesktop/README.rst b/awesome/freedesktop/README.rst new file mode 100644 index 0000000..eecfb40 --- /dev/null +++ b/awesome/freedesktop/README.rst @@ -0,0 +1,52 @@ +Awesome-Freedesktop +=================== + +------------------------------------------------------------------- +Freedesktop.org menu and desktop icons support for Awesome WM 4.x +------------------------------------------------------------------- + +:Original author: Antonio Terceiro +:Maintainer: Luca CPZ +:Version: git +:License: GNU-GPL2_ +:Source: https://github.com/lcpz/awesome-freedesktop + +Description +----------- + +This is a port of awesome-freedesktop_ to Awesome_ 4.x. + +See branches_ for previous versions. + +Since the introduction of Menubar_ as core library for providing Freedesktop.org menu functionalities in Awesome, +we can now avoid all the dirty work by just exploiting ``menubar.utils`` functions. + +At the initial status of this port, the menu is pretty much complete, while the desktop icons are very basic, +so the long term objective will be to complete functionalities on this part too. + +More specifically, the todo list is: + +- A better way to handle desktop icons path +- Ability to drag and line up icons +- Event-based signals, in particular: + - Updating trash icon according to its status + - Dynamic update (no need to restart Awesome to see changes on desktop) + +Screenshot +---------- + +.. image:: screenshot.png + :align: center + :alt: Showcase of Freedesktop support in Awesome, using Adwaita icons + +Installation and usage +---------------------- + +Read the wiki_. + +.. _GNU-GPL2: http://www.gnu.org/licenses/gpl-2.0.html +.. _awesome-freedesktop: https://github.com/terceiro/awesome-freedesktop +.. _Awesome: https://github.com/awesomeWM/awesome +.. _branches: https://github.com/lcpz/awesome-freedesktop/branches +.. _Menubar: https://github.com/awesomeWM/awesome/tree/master/lib/menubar +.. _wiki: https://github.com/lcpz/awesome-freedesktop/wiki diff --git a/awesome/freedesktop/awesome-freedesktop-scm-1.rockspec b/awesome/freedesktop/awesome-freedesktop-scm-1.rockspec new file mode 100644 index 0000000..36cab17 --- /dev/null +++ b/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" } +} diff --git a/awesome/freedesktop/desktop.lua b/awesome/freedesktop/desktop.lua new file mode 100644 index 0000000..748debd --- /dev/null +++ b/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 diff --git a/awesome/freedesktop/init.lua b/awesome/freedesktop/init.lua new file mode 100644 index 0000000..9350b44 --- /dev/null +++ b/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") +} diff --git a/awesome/freedesktop/menu.lua b/awesome/freedesktop/menu.lua new file mode 100644 index 0000000..a58559b --- /dev/null +++ b/awesome/freedesktop/menu.lua @@ -0,0 +1,133 @@ +--[[ + + 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 io, pairs, string, table, os = io, 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"))) + +-- Expecting a wm_name of awesome omits too many applications and tools +menu_utils.wm_name = "" + +-- Menu +-- freedesktop.menu +local menu = {} + +-- Determines if a path points to a directory, by checking if it can be read +-- (which is `nil` also for empty files) and if its size is not 0. +-- @author blueyed +-- @param path the path to check +function menu.is_dir(path) + local f = io.open(path) + return f and not f:read(0) and f:seek("end") ~= 0 and f:close() +end + +-- Remove non existent paths in order to avoid issues +local existent_paths = {} +for k,v in pairs(menu_gen.all_menu_dirs) do + if menu.is_dir(v) then + table.insert(existent_paths, v) + end +end +menu_gen.all_menu_dirs = existent_paths + +-- 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 diff --git a/awesome/freedesktop/screenshot.png b/awesome/freedesktop/screenshot.png new file mode 100644 index 0000000..bf254ac Binary files /dev/null and b/awesome/freedesktop/screenshot.png differ diff --git a/awesome/rc.lua b/awesome/rc.lua new file mode 100644 index 0000000..c2595dc --- /dev/null +++ b/awesome/rc.lua @@ -0,0 +1,627 @@ +-- 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").widget +-- Enable hotkeys help widget for VIM and other apps +-- when client with a matching name is opened: +require("awful.hotkeys_popup.keys") + +-- Load Debian menu entries +local debian = require("debian.menu") +local has_fdo, freedesktop = pcall(require, "freedesktop") +-- Improve startup time of menubar +menubar.menu_gen.lookup_category_icons = function() end + +-- {{{ 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 = "x-terminal-emulator" +editor = os.getenv("EDITOR") or "editor" +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, +} +-- }}} + +-- {{{ Helper functions +local function client_menu_toggle_fn() + local instance = nil + + return function () + if instance and instance.wibox.visible then + instance:hide() + instance = nil + else + instance = awful.menu.clients({ theme = { width = 250 } }) + end + end +end +-- }}} + +-- {{{ Menu +-- Create a launcher widget and a main menu +myawesomemenu = { + { "hotkeys", function() return false, hotkeys_popup.show_help end}, + { "manual", terminal .. " -e man awesome" }, + { "edit config", editor_cmd .. " " .. awesome.conffile }, + { "restart", awesome.restart }, + { "quit", function() awesome.quit() end} +} + +local menu_awesome = { "awesome", myawesomemenu, beautiful.awesome_icon } +local menu_terminal = { "open terminal", terminal } + +if has_fdo then + mymainmenu = freedesktop.menu.build({ + before = { menu_awesome }, + after = { menu_terminal } + }) +else + mymainmenu = awful.menu({ + items = { + menu_awesome, + { "Debian", debian.menu.Debian_menu.Debian }, + menu_terminal, + } + }) +end + + +mylauncher = awful.widget.launcher({ image = beautiful.awesome_icon, + menu = mymainmenu }) + +-- Menubar configuration +menubar.utils.terminal = terminal -- Set the terminal for applications that require it +menubar.cache_entries = true +-- }}} + +-- Keyboard map indicator and switcher +mykeyboardlayout = awful.widget.keyboardlayout() + +-- {{{ Wibar +-- imports +local cpu_widget = require("awesome-wm-widgets.cpu-widget.cpu-widget") +local ram_widget = require("awesome-wm-widgets.ram-widget.ram-widget") +local volume_control = require("volume-control") +volumecfg = volume_control {device="pulse"} + +-- 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 + -- Without this, the following + -- :isvisible() makes no sense + c.minimized = false + if not c:isvisible() and c.first_tag then + c.first_tag:view_only() + end + -- This will also un-minimize + -- the client, if needed + client.focus = c + c:raise() + end + end), + awful.button({ }, 3, client_menu_toggle_fn()), + 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({ "1", "2", "3", "4", "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(s, awful.widget.taglist.filter.all, taglist_buttons) + + -- Create a tasklist widget + s.mytasklist = awful.widget.tasklist(s, awful.widget.tasklist.filter.currenttags, tasklist_buttons) + + -- Create the wibox + s.mywibox = awful.wibar({ position = "top", screen = s }) + + local sep = wibox.widget { + widget = wibox.widget.separator + } + + -- 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, + cpu_widget(), + ram_widget(), + sep, + volumecfg.widget, + sep, + 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 + client.focus = c + c:raise() + 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"}), + + -- Volume + awful.key({}, "XF86AudioRaiseVolume", function() volumecfg:up() end), + awful.key({}, "XF86AudioLowerVolume", function() volumecfg:down() end), + awful.key({}, "XF86AudioMute", function() volumecfg:toggle() end), + + -- applications + awful.key({}, "XF86Calculator", function() awful.util.spawn("qalculate-gtk") end), + awful.key({}, "XF86Launch5", function() awful.util.spawn_with_shell("echo -e 'connect 44:EA:D8:39:BB:4B\nquit' | bluetoothctl") end), + awful.key({}, "XF86Launch6", function() awful.util.spawn_with_shell("echo -e 'disconnect 44:EA:D8:39:BB:4B\nquit' | bluetoothctl") end), + awful.key({}, "Print", function() awful.util.spawn_with_shell("spectacle") end), + awful.key({ modkey }, "Print", function() awful.util.spawn_with_shell("spectacle -r") end) +) + +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"}) +) + +-- 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, 9 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) client.focus = c; c:raise() end), + awful.button({ modkey }, 1, awful.mouse.client.move), + awful.button({ modkey }, 3, awful.mouse.client.resize)) + +-- 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. + }, + class = { + "Arandr", + "Gpick", + "Kruler", + "MessageWin", -- kalarm. + "Sxiv", + "Wpa_gui", + "pinentry", + "veromix", + "xtightvncviewer"}, + + name = { + "Event Tester", -- xev. + }, + role = { + "AlarmWindow", -- Thunderbird's calendar. + "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() + client.focus = c + c:raise() + awful.mouse.client.move(c) + end), + awful.button({ }, 3, function() + client.focus = c + c:raise() + 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) + if awful.layout.get(c.screen) ~= awful.layout.suit.magnifier + and awful.client.focus.filter(c) then + client.focus = c + end +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) +-- }}} + +-- Autostart {{{ +autorun = true +autorunApps = +{ + "nextcloud", + "clementine", + "keepassxc", +} +if autorun then + for app = 1, #autorunApps do + awful.util.spawn(autorunApps[app]) + end +end +-- }}} + +-- own settings {{{ +awful.spawn.with_shell("~/.config/awesome/autorun.sh") +-- }}} diff --git a/awesome/volume-control b/awesome/volume-control new file mode 160000 index 0000000..56dee54 --- /dev/null +++ b/awesome/volume-control @@ -0,0 +1 @@ +Subproject commit 56dee54d7711a8be619d339bf66747db2e13cd17