diff options
| author | 2022-06-04 13:57:53 +0000 | |
|---|---|---|
| committer | 2022-06-04 13:57:53 +0000 | |
| commit | 1c6183dc830542c3eba02744db772da9ffd6d4e4 (patch) | |
| tree | 998c28f70abc352354424529492417461a9fb0ca | |
| parent | 7553af7dd5961eae6608b003bae83aa69c7a58aa (diff) | |
adicionados scripts de dmenu e pastas do kmonad e do sdorfehs
| -rwxr-xr-x | bin/dmenu_man | 10 | ||||
| -rwxr-xr-x | bin/dmenu_wrapper | 10 | ||||
| -rw-r--r-- | kmonad/akko.kbd | 580 | ||||
| -rw-r--r-- | kmonad/ideapad.kbd | 411 | ||||
| -rwxr-xr-x | sdorfehs/autovscreen | 23 | ||||
| -rwxr-xr-x | sdorfehs/bar_script.py | 16 | ||||
| -rw-r--r-- | sdorfehs/config | 300 | ||||
| -rw-r--r-- | sdorfehs/history | 20 |
8 files changed, 1370 insertions, 0 deletions
diff --git a/bin/dmenu_man b/bin/dmenu_man new file mode 100755 index 0000000..b97bfce --- /dev/null +++ b/bin/dmenu_man @@ -0,0 +1,10 @@ +#!/bin/sh + +command -v man > /dev/null || echo 'man not found' +command -v dmenu > /dev/null || echo 'dmenu not found' + +prompt="manpage:" + +# simple script to select man page from dmenu + +man -k . | sed -e 's;[0-9];;' | tr -d '(),' | dmenu_wrapper -p "$prompt" | xargs --no-run-if-empty xterm -e man > /dev/null diff --git a/bin/dmenu_wrapper b/bin/dmenu_wrapper new file mode 100755 index 0000000..186fce0 --- /dev/null +++ b/bin/dmenu_wrapper @@ -0,0 +1,10 @@ +#!/bin/sh + +font="Terminus:style=Regular:size=16" +bg_color="#101112" +fg_color="#f5f5f5" +hl_color="#e60053" + +opts="-i -l 6" + +dmenu -fn "$font" -nb "$bg_color" -nf "$fg_color" -sb "$hl_color" $opts "$@" diff --git a/kmonad/akko.kbd b/kmonad/akko.kbd new file mode 100644 index 0000000..aec3999 --- /dev/null +++ b/kmonad/akko.kbd @@ -0,0 +1,580 @@ +(defcfg + ;; For Linux + input (device-file "/dev/input/by-id/usb-ROYUAN_AKKO_Multi-modes_Keyboard-B-event-kbd") + output (uinput-sink "akko" + "/usr/bin/sleep 1 && /usr/bin/setxkbmap -option compose:ralt && /usr/bin/xset r rate 250 40") + cmp-seq ralt ;; Set the compose key to `RightAlt' + ;;cmp-seq-delay 5 ;; 5ms delay between each compose-key sequence press + + ;; Comment this is you want unhandled events not to be emitted + fallthrough true + + ;; Set this to false to disable any command-execution in KMonad + allow-cmd true +) + +(defsrc + esc 1 2 3 4 5 6 7 8 9 0 - = bspc grv + tab q w e r t y u i o p [ ] \ + caps a s d f g h j k l ; ' ret + lsft z x c v b n m , . / rsft + lctl lmet lalt spc ralt rctl +) + +(defalias + sym (tap-hold-next 1800 q (layer-toggle symbols)) + num (tap-hold-next 1800 z (layer-toggle numbers)) + nav (tap-hold-next 1800 v (layer-toggle nav)) + misc (tap-hold-next 1800 ' (layer-toggle misc)) + lnch (tap-hold-next 1800 = (layer-toggle launch)) + + cesc (tap-hold-next 1800 esc lctl) + tabm (tap-hold-next 1800 tab lmet) + brlm (tap-hold-next 1800 [ rmet) + + amet (tap-hold-next 1800 a lmet) + salt (tap-hold-next 1800 s lalt) + dsft (tap-hold-next 1800 d lsft) + fctl (tap-hold-next 1800 f lctl) + + jctl (tap-hold-next 1800 j rctl) + ksft (tap-hold-next 1800 k rsft) + lalt (tap-hold-next 1800 l lalt) + cmet (tap-hold-next 1800 ; rmet) +) + +(deflayer qwerty + esc 1 2 3 4 5 6 7 8 9 0 - @lnch bspc grv + tab @sym w e r t y u i o p [ ] \ + esc @amet @salt @dsft @fctl g h @jctl @ksft @lalt @cmet @misc ret + lsft @num x c @nav b n m , . / rsft + lctl lmet lalt spc ralt rctl +) + +(deflayer template + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ +) + +(deflayer numbers + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ \( / 7 8 9 - _ _ _ + _ _ _ _ _ \) * 4 5 6 + _ _ + _ _ _ _ _ . 0 1 2 3 _ _ + _ _ _ _ _ _ +) + +(deflayer nav + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ left down up right _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ +) + +(deflayer misc + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ caps _ _ _ slck _ _ _ _ + _ _ _ _ _ _ +) + +(defalias + file (cmd-button "$TERMINAL -e lf") + mix (cmd-button "$TERMINAL -e pulsemixer") + calc (cmd-button "$TERMINAL -e calc") + stat (cmd-button "$TERMINAL -e htop") + news (cmd-button "$TERMINAL -e tmux new -As news newsboat") + edit (cmd-button "$TERMINAL -e tmux new -As edit $EDITOR") + ytv (cmd-button "ytfzf -DNs") + yta (cmd-button "ytfzf -DNs --audio-only") + yts (cmd-button "ytfzf -DN -c S --sort") + www (cmd-button "firefox") + lock (cmd-button "xsecurelock") +) + +(deflayer launch + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ @edit _ _ @ytv _ _ _ _ _ _ _ + _ @yta @yts _ @file _ @stat _ _ @lock _ _ _ + _ _ _ @calc _ @www @news @mix _ _ _ _ + _ _ _ _ _ _ +) + + +#| -------------------------------------------------------------------------- + Optional: modded buttons + + Let's start by exploring the various special buttons that are supported by + KMonad by looking at 'modded' buttons, that is to say, buttons that activate + some kind of 'mod', then perform some button, and finally release that 'mod' + again. + + We have already seen an example of this style of button, our `kil` button is + one such button. Let's look at it in more detail: + C-A-del + + This looks like a simple declarative statement, but it's helpful to realize + that is simply syntactic sugar around 2 function calls. This statement is + equivalent to: + (around ctl (around alt del)) + + This highlights a core design principle in KMonad: we try to provide very + simple buttons, and then we provide rules and functions for combining them + into new buttons. Although note: still very much a work in progress. + + So, looking at this statement: + (around foo bar) + + Here, `around` is a function that takes two buttons and creates a new button. + This new button will, on a press, first press foo, then press bar, and on a + release first release bar, and then foo. Once created, this new button can be + passed to anything in KMonad that expects a button. + + We have already seen other examples of modded buttons, \(, \), *, and +. There + are no Keycodes for these buttons in KMonad, but they are buttons. They simply + evaluate to `(around lsft x)`. All shifted numbers have their corresponding + characters, the same is true for all capitals, and < > : ~ " | { } \_ + and ?. + + To wrap up 'modded-buttons', let's look back at C-A-del. We have 8 variants: + C- : (around lctl X) + A- : (around lalt X) + M- : (around lmet X) + S- : (around lsft X) + + Then RC-, RA-, RM-, and RS- behave exactly the same, except using the + right-modifier. + + These can be combined however you please: + C-A-M-S-x ;; Perfectly valid + C-% ;; Perfectly valid: same as C-S-5 + C-RC-RA-A-M-S-RS-m ;; Sure, but why would you? + + Also, note that although we provide special syntax for certain modifiers, + these buttons are in no way 'special' in KMonad. There is no concept of 'modifier'. + (around a (around b c)) ;; Perfectly valid + + -------------------------------------------------------------------------- |# + +(defalias + + ;; Something useful + cpy C-c + pst C-v + cut C-x + + ;; Something silly + md1 (around a (around b c)) ;; abc + md2 (around a (around lsft b)) ;; aB + md3 C-A-M-S-l + md4 (around % b) ;; BEWARE: %B, not %b, do you see why? +) + +#| -------------------------------------------------------------------------- + Optional: sticky keys + + KMonad also support so called "sticky keys". These are keys that will + behave as if they were pressed after just tapping them. This behaviour + wears off after the next button is pressed, which makes them ideal for + things like a quick control or shift. For example, tapping a sticky and + then pressing `abc' will result in `Abc'. + + You can create these keys with the `sticky-key' keyword: + + (defalias + slc (sticky-key 500 lctl)) + + The number after `sticky-key' is the timeout you want, in milliseconds. If + a key is tapped and that time has passed, it won't act like it's pressed + down when we receive the next keypress. + + It is also possible to combine sticky keys. For example, to + get a sticky shift+control you can do + + (defalias + ssc (around + (sticky-key 500 lsft) + (sticky-key 500 lctl))) + + -------------------------------------------------------------------------- |# + +;; Let's make both shift keys sticky +;;(defalias +;; sl (sticky-key 300 lsft) +;; sr (sticky-key 300 rsft)) + + +;; Now we define the 'tst' button as opening and closing a bunch of layers at +;; the same time. If you understand why this works, you're starting to grok +;; KMonad. +;; +;; Explanation: we define a bunch of testing-layers with buttons to illustrate +;; the various options in KMonad. Each of these layers makes sure to have its +;; buttons not overlap with the buttons from the other layers, and specifies all +;; its other buttons as transparent. When we use the nested `around` statement, +;; whenever we push the button linked to '@tst' (check `qwerty` layer, we bind +;; it to `rctl`), any button we press when holding `rctl` will be pressed in the +;; context of those 4 layers overlayed on the stack. When we release `rctl`, all +;; these layers will be popped again. + +#| -------------------------------------------------------------------------- + Optional: tap-macros + + Let's look at a button we haven't seen yet, tap-macros. + + `tap-macro` is a function that takes an arbitrary number of buttons and + returns a new button. When this new button is pressed it rapidly taps all its + stored buttons in quick succesion except for its last button, which it only + presses. This last button gets released when the `tap-macro` gets released. + + There are two ways to define a `tap-macro`, using the `tap-macro` function + directly, or through the #() syntactic sugar. Both evaluate to exactly the + same button. + + (tap-macro K M o n a d) + #(K M o n a d) + + If you are going to use a `tap-macro` to perform a sequence of actions inside + some program you probably want to include short pauses between inputs to give + the program time to register all the key-presses. Therefore we also provide + the 'pause' function, which simply pauses processing for a certain amount of + milliseconds. Pauses can be created like this: + + (pause 20) + P20 + + You can also pause between each key stroke by specifying the `:delay' keyword, + as well as a time in ms, at the end of a `tap-macro': + + (tap-macro K M o n a d :delay 5) + #(K M o n a d :delay 5) + + The above would be equivalent to e.g. + + (tap-macro K P5 M P5 o P5 n P5 a P5 d) + + WARNING: DO NOT STORE YOUR PASSWORDS IN PLAIN TEXT OR IN YOUR KEYBOARD + + I know it might be tempting to store your password as a macro, but there are 2 + huge risks: + 1. You accidentally leak your config and expose your password + 2. Anyone who knows about the button can get clear-text representation of your + password with any text editor, shell, or text-input field. + + Support for triggering shell commands directly from KMonad is described in the + command buttons section below. + + This concludes this public service announcement. + + -------------------------------------------------------------------------- |# + +(defalias + mc1 #(K M o n a d) + mc2 #(C-c P50 A-tab P50 C-v) ;; Careful, this might do something + mc3 #(P200 h P150 4 P100 > < P50 > < P20 0 r z 1 ! 1 ! !) + mc4 (tap-macro a (pause 50) @md2 (pause 50) c) + mc5 #(@mc3 spc @mc3 spc @mc3) +) + +#| -------------------------------------------------------------------------- + Optional: layer manipulation + + You have already seen the basics of layer-manipulation. The `layer-toggle` + button. This button adds a layer to the top of KMonad's layer stack when + pressed, and removes it again when released. There are a number of other ways + to manipulate the layer stack, some safer than others. Let's go through all of + them from safest to least safe: + + `layer-toggle` works as described before, 2 things to note: + 1. If you are confused or worried about pressing a key, changing layers, and + then releasing a key and this causing issues: don't be. KMonad handles + presses and releases in very different ways. Presses get passed directly to + the stacked keymap as previously described. When a KMonad button has its + press-action triggered, it then registers a callback that will catch its + own release before we ever touch the keymap. This guarantees that the + button triggered by the press of X *will be* the button whose release is + triggered by the release of X (the release of X might trigger other things + as well, but that is besides the point.) + 2. If `layer-toggle` can only ever add and then necessarily remove 1 layer + from the stack, then it will never cause a permanent change, and is + perfectly safe. + + `layer-delay`, once pressed, temporarily switches to some layer for some + milliseconds. Just like `layer-toggle` this will never permanently mess-up the + layer stack. This button was initially implemented to provide some + 'leader-key' style behavior. Although I think in the future better solutions + will be available. For now this will temporarily add a layer to the top of the + stack: + (layer-delay 500 my-layer) + + `layer-next`, once pressed, primes KMonad to handle the next press from some + arbitrary layer. This aims to fill the same usecase as `layer-delay`: the + beginnings of 'leader-key' style behavior. I think this whole button will get + deleted soon, because the more general `around-next` now exists (see below) + and this is nothing more than: + (around-next (layer-toggle layer-name)) + Until then though, use `layer-next` like this: + (layer-next layer-name) + + `layer-switch`: change the base-layer of KMonad. As described at the top of + this document, the first `deflayer` statement is the layer that is active when + KMonad starts. Since `layer-toggle` can only ever add on and remove from the + top of that, it can never change the base-layer. The following button will + unregister the bottom-most layer of the keymap, and replace it with another + layer. + (layer-switch my-layer) + + This is where things start getting potentially dangerous (i.e. get KMonad into + an unusuable state until a restart has occured). It is perfectly possible to + switch into a layer that you can never get out of. Or worse, you could + theoretically have a layer full of only `XX`s and switch into that, rendering + your keyboard unuseable until you somehow manage to kill KMonad (without using + your keyboard). + + However, when handled well, `layer-switch` is very useful, letting you switch + between 'modes' for your keyboard. I have a tiny keyboard with a weird keymap, + but I switch into a simple 'qwerty' keymap shifted 1 button to the right for + gaming. Just make sure that any 'mode' you switch into has a button that + allows you to switch back out of the 'mode' (or content yourself restarting + KMonad somehow). + + `layer-add` and `layer-rem`. This is where you can very quickly cause yourself + a big headache. Originally I didn't expose these operations, but someone + wanted to use them, and I am not one to deny someone else a chainsaw. As the + names might give away: + (layer-add name) ;; Add a layer to the top of the stack + (layer-rem name) ;; Remove a layer by name (noop if no such layer) + + To use `layer-add` and `layer-rem` well, you should take a moment to think + about how to create a layout that will prevent you from getting into + situations where you enter a key-configuration you cannot get out of again. + These two operations together, however, are very useful for activating a + permanent overlay for a while. This technique is illustrated in the tap-hold + overlay a bit further down. + + + -------------------------------------------------------------------------- |# + +(defalias + + yah (layer-toggle asking-for-trouble) ;; Completely safe + nah (layer-add asking-for-trouble) ;; Completely unsafe + + ld1 (layer-delay 500 numbers) ;; One way to get a leader-key + ld2 (layer-next numbers) ;; Another way to get a leader key + + ;; NOTE, this is safe because both `qwerty` and `colemak` contain the `@tst` + ;; button which will get us to the `layer-test` layer, which itself contains + ;; both `@qwe` and `@col`. + qwe (layer-switch qwerty) ;; Set qwerty as the base layer +) + +(defalias lol #(: - D)) + +;; Contrived example +(deflayer asking-for-trouble + @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol + @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol + @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol + @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol @lol + @lol @lol @lol @lol @lol @lol +) + +;; One way to safely use layer-add and layer-rem: the button bound to layer-add +;; is the same button bound to layer-rem in the layer that `add` adds to the +;; stack. I.e., it becomes impossible to add or remove multiple copies of a +;; layer. +(defalias + add (layer-add multi-overlay) ;; multi-overlay is defined in the next + rem (layer-rem multi-overlay) ;; section below this + ) + +#| -------------------------------------------------------------------------- + Optional: Multi-use buttons + + Perhaps one of the most useful features of KMonad, where a lot of work has + gone into, but also an area with many buttons that are ever so slightly + different. The naming and structuring of these buttons might change sometime + soon, but for now, this is what there is. + + For the next section being able to talk about examples is going to be handy, + so consider the following scenario and mini-language that will be the same + between scenarios. + - We have some button `foo` that will be different between scenarios + - `foo` is bound to 'Esc' on the input keyboard + - the letters a s d f are bound to themselves + - Px signifies the press of button x on the keyboard + - Rx signifies the release of said button + - Tx signifies the sequential and near instantaneous press and release of x + - 100 signifies 100ms pass + + So for example: + Tesc Ta: + tap of 'Esc' (triggering `foo`), tap of 'a' triggering `a` + Pesc 100 Ta Tb Resc: + press of 'Esc', 100ms pause, tap of 'a', tap of 'b', release of 'Esc' + + The `tap-next` button takes 2 buttons, one for tapping, one for holding, and + combines them into a single button. When pressed, if the next event is its own + release, we tap the 'tapping' button. In all other cases we first press the + 'holding' button then we handle the event. Then when the `tap-next` gets + released, we release the 'holding' button. + + So, using our mini-language, we set foo to: + (tap-next x lsft) + Then: + Tesc -> x + Tesc Ta -> xa + Pesc Ta Resc -> A + Pesc Ta Tr Resc -> AR + + The `tap-hold` button is very similar to `tap-next` (a theme, trust me). The + difference lies in how the decision is made whether to tap or hold. A + `tap-hold` waits for a particular timeout, if the `tap-hold` is released + anywhere before that moment we execute a tap immediately. If the timeout + occurs and the `tap-hold` is still held, we switch to holding mode. + + The additional feature of a `tap-hold` is that it pauses event-processing + until it makes its decision and then rolls back processing when the decision + has been made. + + So, again with the mini-language, we set foo to: + (tap-hold 200 x lsft) ;; Like tap-next, but with a 200ms timeout + Then: + Tesc -> x + Tesc Ta -> xa + Pesc 300 a -> A (the moment you press a) + Pesc a 300 -> A (after 200 ms) + Pesc a 100 Resc -> xa (both happening immediately on Resc) + + The `tap-hold-next` button is a combination of the previous 2. Essentially, + think of it as a `tap-next` button, but it also switches to held after a + period of time. This is useful, because if you have a (tap-next ret ctl) for + example, and you press it thinking you want to press C-v, but then you change + your mind, you now cannot release the button without triggering a 'ret', that + you then have to backspace. With the `tap-hold-next` button, you simply + outwait the delay, and you're good. I see no benefit of `tap-next` over + `tap-hold-next` with a decent timeout value. + + You can use the `:timeout-button` keyword to specify a button other than the + hold button which should be held when the timeout expires. For example, we + can construct a button which types one x when tapped, multiple x's when held, + and yet still acts as shift when another button is pressed before the timeout + expires. So, using the minilanguage and foo as: + (tap-hold-next 200 x lsft :timeout-button x) + Then: + Tesc -> Tx + Pesc 100 a -> A (the moment you press a) + Pesc 5000 Resc -> xxxxxxx (some number of auto-repeated x's) + + Note that KMonad does not itself auto-repeat the key. In this last example, + KMonad emits 200 Px 4800 Rx, and the operating system's auto-repeat feature, + if any, emits multiple x's because it sees that the x key is held for 4800 ms. + + The `tap-next-release` is like `tap-next`, except it decides whether to tap or + hold based on the next release of a key that was *not* pressed before us. This + also performs rollback like `tap-hold`. So, using the minilanguage and foo as: + (tap-next-release x lsft) + Then: + Tesc Ta -> xa + Pa Pesc Ra Resc -> ax (because 'a' was already pressed when we started, so + foo decides it is tapping) + Pesc Ta Resc -> A (because a was pressed *and* released after we started, + so foo decides it is holding) + + These increasingly stranger buttons are, I think, coming from the stubborn + drive of some of my more eccentric (and I mean that in the most positive way) + users to make typing with modifiers on the home-row more comfortable. + Especially layouts that encourage a lot of rolling motions are nicer to use + with the `release` style buttons. + + The `tap-hold-next-release` (notice a trend?) is just like `tap-next-release`, + but it comes with an additional timeout that, just like `tap-hold-next` will + jump into holding-mode after a timeout. + + I honestly think that `tap-hold-next-release`, although it seems the most + complicated, probably is the most comfortable to use. But I've put all of them + in a testing layer down below, so give them a go and see what is nice. + + -------------------------------------------------------------------------- |# + +(defalias + xtn (tap-next x lsft) ;; Shift that does 'x' on tap + xth (tap-hold 400 x lsft) ;; Long delay for easier testing + thn (tap-hold-next 400 x lsft) + tnr (tap-next-release x lsft) + tnh (tap-hold-next-release 2000 x lsft) + + ;; Used it the colemak layer + xcp (tap-hold-next 400 esc ctl) +) + +;; Some of the buttons used here are defined in the next section +(deflayer multi-overlay + @mt _ _ _ _ _ _ _ _ _ _ _ @rem _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ + @thn _ _ _ _ _ _ _ _ _ _ _ _ + @xtn _ _ _ _ _ _ _ _ _ _ @xth + @tnr _ _ _ _ _ +) + + +#| -------------------------------------------------------------------------- + Optional: Multi-tap + + Besides the tap-hold style buttons there is another multi-use button (with. + only 1 variant, at the moment). The `multi-tap`. + + A `multi-tap` codes for different buttons depending on how often it is tapped. + It is defined by a series of delays and buttons, followed by a last button + without delay. As long as you tap the `multi-tap` within the delay specified, + it will jump to the next button. Once the delay is exceeded the selected + button is pressed. If the last button in the list is reached, it is + immediately pressed. When another key is pressed down while we're tapping, + `multi-tap' also immediately exits and taps the current button. + + Note that you can actually hold the button, so in the below example, going: + tap-tap-hold (wait 300ms) will get you a pressed c, until you release again. + + -------------------------------------------------------------------------- |# + +(defalias + mt (multi-tap 300 a 300 b 300 c 300 d e)) + + +#| -------------------------------------------------------------------------- + Optional: Around-next + + The `around-next` function creates a button that primes KMonad to perform the + next button-press inside some context. This could be the context of 'having + Shift pressed' or 'being inside some layer' or, less usefully, 'having d + pressed'. It is a more general and powerful version of `layer-next`. + + There is also an `around-next-timeout` button that does the same thing as + `around-next`, except that if some other button press is not detected within + some timeout, some other button is tapped. This can be used to create a + leader-key that simply times out (by passing a non-button), or a key that can + still function as a normal key, but also as a leader key when used slowly. + + I think expansion of this button-style is probably the future of leader-key, + hydra-style functionality support in KMonad. + + -------------------------------------------------------------------------- |# + +(defalias + ns (around-next sft) ;; Shift the next press + nnm (around-next @num) ;; Perform next press in numbers layer +;; ntm (around-next-timeout 500 sft XX) +) + +(deflayer symbols + _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ +` +^ _ _ _ _ _ _ _ _ _ _ + _ _ +' +~ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ +) diff --git a/kmonad/ideapad.kbd b/kmonad/ideapad.kbd new file mode 100644 index 0000000..7d04896 --- /dev/null +++ b/kmonad/ideapad.kbd @@ -0,0 +1,411 @@ +(defcfg + input (device-file "/dev/input/by-path/platform-i8042-serio-0-event-kbd") + output (uinput-sink "ideapad" + "/usr/bin/sleep 1 && /usr/bin/setxkbmap -model abnt2 -layout br -variant abnt2 -option compose:ralt && /usr/bin/xset r rate 250 40") + cmp-seq ralt ;; Set the compose key to `RightAlt' + ;;cmp-seq-delay 5 ;; 5ms delay between each compose-key sequence press + fallthrough true + allow-cmd false +) + +(defsrc + esc f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12 + ' 1 2 3 4 5 6 7 8 9 0 - = bspc + tab q w e r t y u i o p [ [ ret + caps a s d f g h j k l ; grv ] + lsft \ z x c v b n m , . ; rsft + lctl lmet lalt spc ralt / +) + +(defalias + num (tap-hold-next 1800 z (layer-toggle numbers)) + misc (tap-hold-next 1800 . (layer-toggle misc)) ;; misc layer + nav (tap-hold-next 1800 v (layer-toggle nav)) + lnch (tap-hold-next 1800 \ (layer-toggle launch)) + ces (tap-hold-next 1800 esc lctrl) + wm1 (tap-hold-next 1800 tab lmet) + wm2 (tap-hold-next 1800 [ rmet) + + amet (tap-hold-next 1800 a lmet) + salt (tap-hold-next 1800 s lalt) + dsft (tap-hold-next 1800 d lsft) + fctl (tap-hold-next 1800 f lctl) + + jctl (tap-hold-next 1800 j rctl) + ksft (tap-hold-next 1800 k rsft) + lalt (tap-hold-next 1800 l lalt) + cmet (tap-hold-next 1800 รง rmet) +) + +(deflayer qwerty + esc f1 f2 f3 f4 f5 f6 f7 f8 f9 f10 f11 f12 + ' 1 2 3 4 5 6 7 8 9 0 - = bspc + tab q w e r t y u i o p _ [ ret + esc @amet @salt @dsft @fctl g h @jctl @ksft @lalt @cmet _ ] + lsft @lnch @num x c @nav b n m , @misc ; rsft + lctl lmet lalt spc ralt / +) + +(deflayer template + _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ +) + +(deflayer numbers + _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ \( / 7 8 9 - _ _ + _ _ _ _ _ _ \) * 4 5 6 + _ + _ _ _ _ _ _ . 0 1 2 3 _ _ + _ _ _ _ _ _ +) + +(deflayer nav + _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ pgup _ _ _ + _ _ _ _ _ _ left down up right _ _ _ + _ _ _ _ _ _ _ pgdn _ _ _ _ _ + _ _ _ _ _ _ +) + +(deflayer launch + _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ +) + +(deflayer misc + _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ _ _ _ _ _ _ _ _ _ + _ _ _ _ caps _ _ _ slck _ _ _ _ + _ _ _ _ _ _ +) + +#| -------------------------------------------------------------------------- + Optional: modded buttons + + Let's start by exploring the various special buttons that are supported by + KMonad by looking at 'modded' buttons, that is to say, buttons that activate + some kind of 'mod', then perform some button, and finally release that 'mod' + again. + + We have already seen an example of this style of button, our `kil` button is + one such button. Let's look at it in more detail: + C-A-del + + This looks like a simple declarative statement, but it's helpful to realize + that is simply syntactic sugar around 2 function calls. This statement is + equivalent to: + (around ctl (around alt del)) + + This highlights a core design principle in KMonad: we try to provide very + simple buttons, and then we provide rules and functions for combining them + into new buttons. Although note: still very much a work in progress. + + So, looking at this statement: + (around foo bar) + + Here, `around` is a function that takes two buttons and creates a new button. + This new button will, on a press, first press foo, then press bar, and on a + release first release bar, and then foo. Once created, this new button can be + passed to anything in KMonad that expects a button. + + We have already seen other examples of modded buttons, \(, \), *, and +. There + are no Keycodes for these buttons in KMonad, but they are buttons. They simply + evaluate to `(around lsft x)`. All shifted numbers have their corresponding + characters, the same is true for all capitals, and < > : ~ " | { } \_ + and ?. + + To wrap up 'modded-buttons', let's look back at C-A-del. We have 8 variants: + C- : (around lctl X) + A- : (around lalt X) + M- : (around lmet X) + S- : (around lsft X) + + Then RC-, RA-, RM-, and RS- behave exactly the same, except using the + right-modifier. + + These can be combined however you please: + C-A-M-S-x ;; Perfectly valid + C-% ;; Perfectly valid: same as C-S-5 + C-RC-RA-A-M-S-RS-m ;; Sure, but why would you? + + Also, note that although we provide special syntax for certain modifiers, + these buttons are in no way 'special' in KMonad. There is no concept of 'modifier'. + (around a (around b c)) ;; Perfectly valid + + -------------------------------------------------------------------------- |# + +(defalias + + ;; Something useful + cpy C-c + pst C-v + cut C-x + + ;; Something silly + md1 (around a (around b c)) ;; abc + md2 (around a (around lsft b)) ;; aB + md3 C-A-M-S-l + md4 (around % b) ;; BEWARE: %B, not %b, do you see why? +) + +#| -------------------------------------------------------------------------- + Optional: sticky keys + + KMonad also support so called "sticky keys". These are keys that will + behave as if they were pressed after just tapping them. This behaviour + wears off after the next button is pressed, which makes them ideal for + things like a quick control or shift. For example, tapping a sticky and + then pressing `abc' will result in `Abc'. + + You can create these keys with the `sticky-key' keyword: + + (defalias + slc (sticky-key 500 lctl)) + + The number after `sticky-key' is the timeout you want, in milliseconds. If + a key is tapped and that time has passed, it won't act like it's pressed + down when we receive the next keypress. + + It is also possible to combine sticky keys. For example, to + get a sticky shift+control you can do + + (defalias + ssc (around + (sticky-key 500 lsft) + (sticky-key 500 lctl))) + + -------------------------------------------------------------------------- |# + +;; Let's make both shift keys sticky +;;(defalias +;; sl (sticky-key 300 lsft) +;; sr (sticky-key 300 rsft)) + + +;; Now we define the 'tst' button as opening and closing a bunch of layers at +;; the same time. If you understand why this works, you're starting to grok +;; KMonad. +;; +;; Explanation: we define a bunch of testing-layers with buttons to illustrate +;; the various options in KMonad. Each of these layers makes sure to have its +;; buttons not overlap with the buttons from the other layers, and specifies all +;; its other buttons as transparent. When we use the nested `around` statement, +;; whenever we push the button linked to '@tst' (check `qwerty` layer, we bind +;; it to `rctl`), any button we press when holding `rctl` will be pressed in the +;; context of those 4 layers overlayed on the stack. When we release `rctl`, all +;; these layers will be popped again. + +#| -------------------------------------------------------------------------- + Optional: tap-macros + + Let's look at a button we haven't seen yet, tap-macros. + + `tap-macro` is a function that takes an arbitrary number of buttons and + returns a new button. When this new button is pressed it rapidly taps all its + stored buttons in quick succesion except for its last button, which it only + presses. This last button gets released when the `tap-macro` gets released. + + There are two ways to define a `tap-macro`, using the `tap-macro` function + directly, or through the #() syntactic sugar. Both evaluate to exactly the + same button. + + (tap-macro K M o n a d) + #(K M o n a d) + + If you are going to use a `tap-macro` to perform a sequence of actions inside + some program you probably want to include short pauses between inputs to give + the program time to register all the key-presses. Therefore we also provide + the 'pause' function, which simply pauses processing for a certain amount of + milliseconds. Pauses can be created like this: + + (pause 20) + P20 + + You can also pause between each key stroke by specifying the `:delay' keyword, + as well as a time in ms, at the end of a `tap-macro': + + (tap-macro K M o n a d :delay 5) + #(K M o n a d :delay 5) + + The above would be equivalent to e.g. + + (tap-macro K P5 M P5 o P5 n P5 a P5 d) + + WARNING: DO NOT STORE YOUR PASSWORDS IN PLAIN TEXT OR IN YOUR KEYBOARD + + I know it might be tempting to store your password as a macro, but there are 2 + huge risks: + 1. You accidentally leak your config and expose your password + 2. Anyone who knows about the button can get clear-text representation of your + password with any text editor, shell, or text-input field. + + Support for triggering shell commands directly from KMonad is described in the + command buttons section below. + + This concludes this public service announcement. + + -------------------------------------------------------------------------- |# + +(defalias + mc1 #(K M o n a d) + mc2 #(C-c P50 A-tab P50 C-v) ;; Careful, this might do something + mc3 #(P200 h P150 4 P100 > < P50 > < P20 0 r z 1 ! 1 ! !) + mc4 (tap-macro a (pause 50) @md2 (pause 50) c) + mc5 #(@mc3 spc @mc3 spc @mc3) +) + +#| -------------------------------------------------------------------------- + Optional: layer manipulation + + You have already seen the basics of layer-manipulation. The `layer-toggle` + button. This button adds a layer to the top of KMonad's layer stack when + pressed, and removes it again when released. There are a number of other ways + to manipulate the layer stack, some safer than others. Let's go through all of + them from safest to least safe: + + `layer-toggle` works as described before, 2 things to note: + 1. If you are confused or worried about pressing a key, changing layers, and + then releasing a key and this causing issues: don't be. KMonad handles + presses and releases in very different ways. Presses get passed directly to + the stacked keymap as previously described. When a KMonad button has its + press-action triggered, it then registers a callback that will catch its + own release before we ever touch the keymap. This guarantees that the + button triggered by the press of X *will be* the button whose release is + triggered by the release of X (the release of X might trigger other things + as well, but that is besides the point.) + 2. If `layer-toggle` can only ever add and then necessarily remove 1 layer + from the stack, then it will never cause a permanent change, and is + perfectly safe. + + `layer-delay`, once pressed, temporarily switches to some layer for some + milliseconds. Just like `layer-toggle` this will never permanently mess-up the + layer stack. This button was initially implemented to provide some + 'leader-key' style behavior. Although I think in the future better solutions + will be available. For now this will temporarily add a layer to the top of the + stack: + (layer-delay 500 my-layer) + + `layer-next`, once pressed, primes KMonad to handle the next press from some + arbitrary layer. This aims to fill the same usecase as `layer-delay`: the + beginnings of 'leader-key' style behavior. I think this whole button will get + deleted soon, because the more general `around-next` now exists (see below) + and this is nothing more than: + (around-next (layer-toggle layer-name)) + Until then though, use `layer-next` like this: + (layer-next layer-name) + + `layer-switch`: change the base-layer of KMonad. As described at the top of + this document, the first `deflayer` statement is the layer that is active when + KMonad starts. Since `layer-toggle` can only ever add on and remove from the + top of that, it can never change the base-layer. The following button will + unregister the bottom-most layer of the keymap, and replace it with another + layer. + (layer-switch my-layer) + + This is where things start getting potentially dangerous (i.e. get KMonad into + an unusuable state until a restart has occured). It is perfectly possible to + switch into a layer that you can never get out of. Or worse, you could + theoretically have a layer full of only `XX`s and switch into that, rendering + your keyboard unuseable until you somehow manage to kill KMonad (without using + your keyboard). + + However, when handled well, `layer-switch` is very useful, letting you switch + between 'modes' for your keyboard. I have a tiny keyboard with a weird keymap, + but I switch into a simple 'qwerty' keymap shifted 1 button to the right for + gaming. Just make sure that any 'mode' you switch into has a button that + allows you to switch back out of the 'mode' (or content yourself restarting + KMonad somehow). + + `layer-add` and `layer-rem`. This is where you can very quickly cause yourself + a big headache. Originally I didn't expose these operations, but someone + wanted to use them, and I am not one to deny someone else a chainsaw. As the + names might give away: + (layer-add name) ;; Add a layer to the top of the stack + (layer-rem name) ;; Remove a layer by name (noop if no such layer) + + To use `layer-add` and `layer-rem` well, you should take a moment to think + about how to create a layout that will prevent you from getting into + situations where you enter a key-configuration you cannot get out of again. + These two operations together, however, are very useful for activating a + permanent overlay for a while. This technique is illustrated in the tap-hold + overlay a bit further down. + + + -------------------------------------------------------------------------- |# + +(defalias + + ld1 (layer-delay 500 numbers) ;; One way to get a leader-key + ld2 (layer-next numbers) ;; Another way to get a leader key + + ;; NOTE, this is safe because both `qwerty` and `colemak` contain the `@tst` + ;; button which will get us to the `layer-test` layer, which itself contains + ;; both `@qwe` and `@col`. + qwe (layer-switch qwerty) ;; Set qwerty as the base layer +) + +(defalias lol #(: - D)) + +;; One way to safely use layer-add and layer-rem: the button bound to layer-add +;; is the same button bound to layer-rem in the layer that `add` adds to the +;; stack. I.e., it becomes impossible to add or remove multiple copies of a +;; layer. + +#| -------------------------------------------------------------------------- + Optional: Multi-tap + + Besides the tap-hold style buttons there is another multi-use button (with. + only 1 variant, at the moment). The `multi-tap`. + + A `multi-tap` codes for different buttons depending on how often it is tapped. + It is defined by a series of delays and buttons, followed by a last button + without delay. As long as you tap the `multi-tap` within the delay specified, + it will jump to the next button. Once the delay is exceeded the selected + button is pressed. If the last button in the list is reached, it is + immediately pressed. When another key is pressed down while we're tapping, + `multi-tap' also immediately exits and taps the current button. + + Note that you can actually hold the button, so in the below example, going: + tap-tap-hold (wait 300ms) will get you a pressed c, until you release again. + + -------------------------------------------------------------------------- |# + +(defalias + mt (multi-tap 300 a 300 b 300 c 300 d e)) + + +#| -------------------------------------------------------------------------- + Optional: Around-next + + The `around-next` function creates a button that primes KMonad to perform the + next button-press inside some context. This could be the context of 'having + Shift pressed' or 'being inside some layer' or, less usefully, 'having d + pressed'. It is a more general and powerful version of `layer-next`. + + There is also an `around-next-timeout` button that does the same thing as + `around-next`, except that if some other button press is not detected within + some timeout, some other button is tapped. This can be used to create a + leader-key that simply times out (by passing a non-button), or a key that can + still function as a normal key, but also as a leader key when used slowly. + + I think expansion of this button-style is probably the future of leader-key, + hydra-style functionality support in KMonad. + + -------------------------------------------------------------------------- |# + +(defalias + ns (around-next sft) ;; Shift the next press + nnm (around-next @num) ;; Perform next press in numbers layer +;; ntm (around-next-timeout 500 sft XX) +) diff --git a/sdorfehs/autovscreen b/sdorfehs/autovscreen new file mode 100755 index 0000000..a527fa8 --- /dev/null +++ b/sdorfehs/autovscreen @@ -0,0 +1,23 @@ +#!/bin/sh + +# a script to assign specific windows to a specific vscreen in sdorfehs +# used in `newwindow` hook + +win_name=$(xdotool getwindowfocus getwindowclassname) + +case "$win_name" in + "Emacs") + sdorfehs -c 'vmove 0' + ;; + "XTerm") + sdorfehs -c 'vmove 0' + ;; + "mpv") + sdorfehs -c 'vmove 1' + ;; + "firefox" |"librewolf") + sdorfehs -c 'vmove 3' + ;; + *) + ;; +esac diff --git a/sdorfehs/bar_script.py b/sdorfehs/bar_script.py new file mode 100755 index 0000000..2c46b37 --- /dev/null +++ b/sdorfehs/bar_script.py @@ -0,0 +1,16 @@ +#!/usr/bin/env python3 + +import os +import sys +import subprocess + +bar = os.environ['HOME'] + '/.config/sdorfehs/bar' +slstatus = '/usr/local/bin/slstatus' + +if not os.path.exists(bar): + sys.exit('bar file not found') +elif not os.path.exists(slstatus): + sys.exit('slstatus executable not found') + +with open(bar, 'w') as b: + subprocess.call([slstatus, "-s"], stdout=b) diff --git a/sdorfehs/config b/sdorfehs/config new file mode 100644 index 0000000..5f44fb9 --- /dev/null +++ b/sdorfehs/config @@ -0,0 +1,300 @@ +# sdorfehs config + +# general + +set startupmessage 0 +set ignoreresizehints 1 +set rudeness 12 +set winliststyle column +set gap 5 +set onlyborder 1 +set padding 40 20 40 40 +set vscreens 4 +set font "Hack:style=Regular:size=12" +set stickyfmt %s%n: %60t +set border 2 + +# bar +set barinpadding 1 +set barborder 0 +set barpadding 0 6 +set barsticky 1 +set bargravity nw + +# colors +set bgcolor "#272822" +set fgcolor "#e60053" +set bwcolor "#101112" +set fwcolor "#799df6" + +# fix cursor shape +exec xsetroot -cursor_name left_ptr + +# launch emacs servers (apart from the main one, managed by runit) +exec emacs -f notmuch --daemon=mail + +# new kmaps for keybinding shenaningans +newkmap misc +newkmap youtube +newkmap terminal +newkmap browser +newkmap gui +newkmap emacs + +# keybindings for different keymaps +escape C-a # root keybinding +definekey top s-m readkey misc +definekey top s-y readkey youtube +definekey top s-t readkey terminal +definekey top s-b readkey browser +definekey top s-g readkey gui + +# --- root kmap --- # + +# unbinding not so useful keys for my setup +unbind space +unbind Return + +unbind i +unbind j +unbind k + +unbind K +unbind N +unbind P +unbind R +unbind Q + +unbind colon + +unbind Left +unbind Right +unbind Up +unbind Down + +unbind C-i + +unbind C-space +unbind C-Return +unbind C-underscore + +unbind C-Left +unbind C-Right +unbind C-Up +unbind C-Down + +# unbind all F[number] keys +unbind F1 +unbind F2 +unbind F3 +unbind F4 +unbind F5 +unbind F6 +unbind F7 +unbind F8 +unbind F9 +unbind F10 +unbind F11 +unbind F12 + +# abort readkey +bind Escape abort + +# command prompt +bind semicolon colon + +# remove frame +bind q remove +bind C-q remove + +# only frame +bind o only + +# restart sdorfehs +bind R restart + +# exec shell command +bind M-x exec + +# run terminal application +bind exclam exec term_app + +# quit sdorfehs +bind M-BackSpace quit + +# just like dwm! +bind j focus +bind k focusprev + +# select screen by number +bind C-0 select 0 +bind C-1 select 1 +bind C-2 select 2 +bind C-3 select 3 +bind C-4 select 4 +bind C-5 select 5 +bind C-6 select 6 + +# splitting frames +bind s split +bind C-s split +bind S hsplit +bind C-S hsplit + +# list virtual screens +bind W vscreens +bind C-W vscreens + +# start a terminal with tmux +bind c exec $TERMINAL -e tmux new -As shell +# clean terminal +bind C-c exec $TERMINAL +# tmux with default session +bind t exec $TERMINAL -e tmux new -As padrao +bind C-t exec $TERMINAL -e tmux new -As padrao + +# lock the screen +bind M-l exec slock + +# switch to emacs kmap +bind e readkey emacs +# launch emacs +bind C-e exec emacsclient -nc + +# tab goes between the same two frames +bind Tab focuslast +bind C-Tab focuslast + +# change to next monitor +bind comma prevscreen +bind C-comma prevscreen +bind period nextscreen +bind C-period nextscreen + +# send to primary monitor +bind less smove 0 +# send to second monitor +bind greater smove 1 + +# --- misc kmap --- # + +# list of commands +definekey misc question help misc + +# clears clipboard with xsel +definekey misc c exec xsel -bc + +# changes wallpaper with custom script +definekey misc w exec ~/bin/wallpaper + +# show sdorfehs manpage +definekey misc m exec $TERMINAL -e man sdorfehs + +# show manpage of arbitrary command given by user +definekey misc M exec ~/bin/dmenu_man + +# lock input (keyboard and mouse) +definekey misc l exec sleep 1 & xtrlock + +# clear dunst notifications +definekey misc n exec dunstctl close-all + +# --- youtube kmap --- # +definekey youtube question help youtube +definekey youtube v exec ytfzf -Ds --notify-playing +definekey youtube a exec ytfzf -Ds --notify-playing --audio-only +definekey youtube h exec ytfzf -DH + +# --- terminal kmap --- # +definekey terminal question help terminal +definekey terminal p exec $TERMINAL -e pulsemixer +definekey terminal s exec $TERMINAL -e tmux new -As ssh ssh -i ~/.ssh/tilde.town -4 pinoinha@tilde.town # ssh into tilde.town + +# --- browser kmap --- # +definekey browser question help browser +definekey browser f exec sdorfehs -c "echo iniciando navegador"; $BROWSER +definekey browser l exec sdorfehs -c "echo iniciando librewolf"; librewolf +definekey browser w exec $TERMINAL -e tmux new -As www w3m "duckduckgo.com" +definekey browser e exec emacs -f eww + +# --- gui kmap --- # +definekey gui question help gui +definekey gui s exec sdorfehs -c "echo iniciando steam"; steam +definekey gui c exec sdorfehs -c "echo iniciando vscode"; code +definekey gui x exec sdorfehs -c "echo iniciando vscode"; xournalpp + +# --- emacs kmap --- # +definekey emacs question help emacs +definekey emacs e exec emacs +definekey emacs m exec emacsclient -nc -s mail +definekey emacs f exec emacs -f elfeed + +# --- top kmap --- # + +definekey top M-F10 exec akko_config +definekey top M-F11 exec idea_config +# change to russian layout +definekey top M-F12 exec setxkbmap -layout ru -option ctrl:swapcaps + +# go to virtual screen +definekey top s-1 vselect 0 +definekey top s-2 vselect 1 +definekey top s-3 vselect 2 +definekey top s-4 vselect 3 + +# move window to vscreen +# note that s-exclam = s-S-1; s-at = s-S-2, etc. +definekey top s-exclam vmove 0 +definekey top s-at vmove 1 +definekey top s-numbersign vmove 2 +definekey top s-dollar vmove 3 + +# toggle fullscreen on active window +definekey top s-f exec xdotool getactivewindow windowstate --toggle FULLSCREEN + +# gopass +definekey top s-p exec gopass ls --flat | dmenu_wrapper -p 'senha:' | xargs --no-run-if-empty gopass show -c +# type the password +definekey top s-P exec gopass ls --flat | dmenu_wrapper -p 'senha:' | xargs --no-run-if-empty gopass show -o | xdotool type --clearmodifiers --file - + +# pulseaudio volume control +definekey top S-F1 exec sdorfehs -c "echo mudo: `pamixer --toggle-mute; pamixer --get-mute`" +definekey top S-F2 exec sdorfehs -c "echo volume: `pamixer -d 5; pamixer --get-volume`" +definekey top S-F3 exec sdorfehs -c "echo volume: `pamixer -i 5; pamixer --get-volume`" +definekey top S-F4 exec sdorfehs -c "echo mic mudo? `pamixer --default-source -t; pamixer --default-source --get-mute`" + +# mpd control +definekey top S-F5 exec mpc stop +definekey top S-F6 exec mpc prev +definekey top S-F7 exec mpc toggle +definekey top S-F8 exec mpc next + +# control players through MPRIS +definekey top C-F5 exec playerctl -p $(playerctl -l | dmenu_wrapper -p 'Stop: ') stop +definekey top C-F6 exec playerctl -p $(playerctl -l | dmenu_wrapper -p 'Previous: ') previous +definekey top C-F7 exec playerctl -p $(playerctl -l | dmenu_wrapper -p 'Play-pause: ') play-pause +definekey top C-F8 exec playerctl -p $(playerctl -l | dmenu_wrapper -p 'Next: ') next + +# brightness control +definekey top S-F11 exec sdorfehs -c "echo brilho: `xbacklight -dec 10; xbacklight -get`" +definekey top S-F12 exec sdorfehs -c "echo brilho: `xbacklight -inc 10; xbacklight -get`" + +# take some nice screenshots +# redundancy (Sys_Req) to avoid problems +definekey top Print exec scr.sh --selection +definekey top C-Sys_Req exec scr.sh --active-window +definekey top C-Print exec scr.sh --active-window +definekey top M-Sys_Req exec scr.sh --whole-screen +definekey top M-Print exec scr.sh --whole-screen + +# hooks +addhook newwindow exec ~/.config/sdorfehs/autovscreen + +# let popups stay centered +unmanage OpenSSH Authentication Passphrase Request +unmanage mpv +unmanage feh +unmanage termbar + +# bar script +exec ~/.config/sdorfehs/bar_script.py diff --git a/sdorfehs/history b/sdorfehs/history new file mode 100644 index 0000000..476a0cb --- /dev/null +++ b/sdorfehs/history @@ -0,0 +1,20 @@ +listhook newwindow +listhook deletewindow +listhook key +listhook quit +listhook restart +echo welcome! +echo welcome to sdorfehs +echo sdorfehs restartet +echo sdorfehs restarted +number 1 +set barsticky 0 +exec xfontsel +echo "$(tput setaf 4)" +set barsticky 1 +number 0 +set barsticky 0 +set padding 40 40 40 40 +set padding 40 50 40 40 +set barsticky 1 +set padding 40 20 40 40 |
