dotfiles/.local/bin

Phundrak’s executable scripts

• Presentation
• 4chandl
• Askpass
• Backup
• ConnectWifi
• Cppnew
• Cnew
• Dart Language Server
• Dmenu
• Emoji picker
• lsl
• Polybar-launch
• Rofi-mount
  • Get the mountable elements
  • Get the mount point
  • Mount a USB drive, hard drive or partition
  • Mount an Android device
  • Mount a CD drive
  • Ask what type of drive we want to mount
  • Launch the mounting functions
• Rofi-pass
• Rofi-umount
  • Get the unmountable drives
  • Unmount disk partitions
  • Unmount Android device
  • Unmount CD drive
  • Ask what type of drive to unmount
  • Launch the unmounting functions
• Starwars
• UpdateFlutter
• Wacom setup
  • Set our variables
  • Select our screen
  • Adjust the tablet
  • Lauch the functions
• Yadm

Presentation

This file will present all the executable scripts I wrote. It is also their original source code, all the following code snippets are exported and tangled from this file to the actual executables.

Please do not forget to run the following before tangling files from this file to make sure the tangled files will be executables.

  (defun phundrak/make-tangled-files-executable ()
    (set-file-modes (buffer-file-name) #o755))
  (add-hook 'org-babel-post-tangle-hook 'phundrak/make-tangled-files-executable)

4chandl

Usage: 4chandl [ URL TO THREAD ]

I made this small script to download the attached files of 4chan threads. First of all, let’s declare it as a fish script.

#!/usr/bin/env fish

Now, let’s check if any arguments were passed to the executable. If none were passed, the script should be aborted.

  if ! count $argv > /dev/null
      echo 'No URL specified! Give the URL to thread as the only argument.'
      exit 1
  end

Now, let’s store the regex we use to get the link to the attached files.

set regex_4cdn '\/\/is2\.4chan\.org\/[a-z]+\/[A-Za-z0-9]+\.[A-Za-z]{3,4}'

We’ll use a thread counter to get a visual indication on how the download is going.

  set thread_counter 1

Now, we will use each of the arguments passed as a URL to download the files from.

for url in $argv

As a visual indicator, let’s get the amount of elements we are going to download from the current thread and print it.

  set file_total (curl -ks $url | grep -oE $regex_4cdn | uniq | wc -l)
  echo total files to download in current thread: $file_total

Let’s set a file counter so we can visualize the download progress.

set file_counter 1

Now, let’s download each file from the current thread.

  for image_url in (curl -k -s $url | grep -Eo $regex_4cdn | uniq | sed 's/^/https:/')
      echo -n Downloading image $counter of $total...
      wget --no-check-certificate -q -nc $image_url
      echo ' Done (thread: $thread_counter/thread_total\tfile: $file_counter/file_total)'
      set file_counter (math $file_counter + 1)
  end

Let’s increment the thread counter.

set thread_counter (math $thread_counter + 1)

Let’s now close the for loop.

end

Askpass

Askpass is a simple script that invokes rofi as a way to get from a GUI the user’s sudo password. It is inspired by this original tool, rewritten in fish and with rofi support instead of dmenu. As you can see, this is a oneliner if we ignore the initial shebang. This executable is pointed at by the

  #!/usr/bin/env fish
  rofi -dmenu -font 'DejaVu Sans 10' -password -no-fixed-num-lines \
  -p (printf $argv[1] | sed s/://)

Backup

backup is a very simple, oneliner script that will create a local copy of a file and add the date at which it was copied in the filename. You can see its source code here:

  #!/usr/bin/env fish
  cp $argv[1] $argv[1].bak.(date +"%Y%m%d%H%M%S")

ConnectWifi

connect-wifi is a small utility tool that allows the user to connect to available WiFi networks. The first thing to do is to select the WiFi we want to connect to. We’ll use the nmcli c s command to get the list of the available networks, and we’ll chose one with rofi.

  #!/usr/bin/env fish
  set SELECTEDWIFI (nmcli d w l | egrep -o '([0-9A-F]{2}:){5}[0-9A-F]{2}\s*(.*)Infra' | egrep -o '\s+(.*)\s+' | awk '{$1=$1}1' | rofi -dmenu -p "Select your WiFi network")

Now, if a network was selected, let’s attempt to connect to it. Otherwise, let’s just send a notification no network was selected.

  if test -z $SELECTEDWIFI
      notify-send "No WiFi network selected" -u low && exit
  end
  nmcli c u $SELECTEDWIFI

Cppnew

cppnew is a small utility that helps you create a new C++ project. Several templates are available, the default one using CMake, and three others that are a bit more advances, based on:

• CMake + Conan
• Meson + Ninja
• Meson + Ninja + Conan

There is also a default Doxygen file included for your documentation, ready to go. I even made it so that you can execute it as an executable file, like ./doc/Doxyfile from the project root.

The choice is given to the user which of them to use with options that will be given to cppnew.

#!/usr/bin/env fish

First of all, if no arguments were passed, return an error.

  if ! count $argv >/dev/null
      echo "Missing argument: PROJECT" && return -1
  end

Now, let’s set a couple of variables which will prove useful later on when trying to set up our project.

Cnew

cnew is a small utility script similar to but simpler than cppnew that creates a CMake template C project from the template that already exists in ~/dev/templateC. This script is a fish script, so let’s insert the shebang.

#!/usr/bin/env fish

If no argument was passed, display an error message and exit.

  if ! count $argv > /dev/null
      echo "Missing argument: PROJECT" && return -1
  end

Pass the first argument to a switch statement.

switch "$argv[1]"

If the argument is -h or --help, then display the help message and exit the script normally.

  case -h --help
      man ~/dev/fishfunctions/cnew.man
      exit 0

Else, the argument is the name of the project the user wants to create.

  case '*'
      set -g project_name $argv[1]

Let’s close the switch statement.

end

Now, let’s copy the template where the user is executing cnew from, give it the name of the project and move to the project.

  cp -r ~/dev/templateC $argv[1]
  cd $argv[1]

The default files have a placeholder for the name of the project. Let’s replace these placeholders with the project’s name.

  sed -i "s/PROJECTNAME/$argv[1]/g" CMakeLists.txt
  sed -i "s/PROJECTNAME/$argv[1]/g" README.org
  sed -i "s/CPROJECTNAME/$argv[1]/g" doc/Doxyfile

Now, let’s create a git repository and initialize it.

  git init
  git add .
  git commit -m "initial commit"

And we’re done!

Dart Language Server

Spacemacs' recommendations on how to use Dart with LSP is outdated, since dart_language_server is obsolete. As recommended by the repo owner, we should launch instead the following code:

  #!/usr/bin/env fish
  /usr/bin/dart $DART_SDK/snapshots/analysis_server.dart.snapshot --lsp

So, instead of using the obsolete executable, instead we will be calling the analysis server as requested.

Dmenu

I wrote this very simple script in order to replace dmenu with rofi’s emulation of dmenu, since I prefer rofi’s appearance. It basically calls rofi’s dmenu emulation with the arguments initially passed to dmenu.

  #!/usr/bin/env fish
  rofi -dmenu $argv

Emoji picker

The emoji picker is a simple fish script that uses rofi and ~/.config/emoji.txt to provide a small, local search for emojis. Once the emoji is selected, it is copied to the clipboard using xclipboard.

  #!/usr/bin/env fish
  grep -v "#" ~/.config/emoji.txt | rofi -dmenu -p "Select emoji" -i | awk '{print $1}' | tr -d '\n' | xclip -selection clipboard

Also, let’s send a notification telling the user the emoji has been copied!

  set emoji (xclip -o -selection clipboard | tr -d '\n')
  test -z "$emoji" && notify-send "No emoji copied" -u low && exit
  set -a emoji "copied to clipboard"
  pgrep -x dunst >/dev/null && notify-send -u low $emoji

It is inspired from this video from Luke Smith, rewritten in Fish.

lsl

lsl is a former abbreviation I used to use in fish. However, a recent update of this abbreviation made it harder to use as is, and I believe a function will better fulfil its role than an abbreviation. As you’ll see, it is a very simple script:

  #!/usr/bin/fish
  ls -ahlX --group-directories-first $argv | bat

Polybar-launch

This scripts allows the user to kill polybar and relaunch it, or to simply launch it if polybar isn’t launched yet. This script is a bash script, so let’s declare its shebang.

#!/usr/bin/env bash

First thing to do is kill all polybar processes.

killall -q polybar

Now we have to wait untill all polybar processes have been shut down.

while pgrep -u $UID -x polybar >/dev/null; do sleep 1; done

Now that our system isn’t running polybar anymore, we’ll launch it again on all of our screens. By the way, I have two bars, so I’ll have to lauch them both.

  if type "xrandr"; then
      for m in $(xrandr --query | grep " connected" | cut -d" " -f1); do
          MONITOR=$m polybar --reload top &
          MONITOR=$m polybar --reload bottom &
      done
  else
      polybar --reload top &
      polybar --reload bottom &
  fi

And we’re done! Let’s just launch a notification polybar has been relaunched.

  notify-send "Polybar restarted!" -a "polybar-launch"

Rofi-mount

rofimount is a script inspired by this one, based on dmenu, which interactively asks the user what to mount, and where to mount it. What I did was replace dmenu with rofi, and fix a couple of bugs I encountered in the original script. For the record, this is a fish script. Let’s declare our shebang.

#!/usr/bin/env fish

Get the mountable elements

  begin

What the script does first is detect everything that can be mounted. Between a begin and end, let’s set LFS as a local variable. This si in order to get sane variables in the current block.

set -l LFS

Now, let’s detect the amount of mountable Android filesystems, and if any are detected, let’s read them into a global variable.

  set -l a (math (jmtpfs -l | wc -l) - 2)
  test $a -ge 0 && jmtpfs -l 2> /dev/null | tail -n $a | read -zg anddrives

We’ll do the same for external and internal drives and partitions that can be mounted here.

  lsblk -rpo "name,type,size,mountpoint" | \
  awk '$2=="part"&&$4==""{printf "%s (%s)\n",$1,$3}' | \
  read -zg usbdrives

Finally, we look for any CD drive that could be mounted on our device.

  blkid /dev/sr0 | awk '{print $1}' | sed 's/://' | read -z cddrives

And that’s the end of our first block!

  end

Alright, we’ll save what kind on drives we can mount in a temporary file called /tmp/drives. We’ll make sure it’s blank by erasing it then creating it again with touch, like so. The -f flag on rm is here so we get no error if we try to delete a file that doesn’t exist (yet).

  set -g TMPDRIVES /tmp/drives
  rm -f $TMPDRIVES
  touch $TMPDRIVES

Now, let’s write what type of drives we can mount in this temporary file.

  test -n "$usbdrives" && echo "USB" >> $TMPDRIVES
  test -n "$cddrives" && echo "CD" >> $TMPDRIVES
  test -n "$anddrives" && echo "Android" >> $TMPDRIVES

Now, we want to declare where to look for mount directories. For now, we’ll only look in /media, but you can add more if you wish.

  set -g basemount /media

Get the mount point

Now, let’s declare a function that will allow us to chose the drive we want to mount.

  function getmount

First, we want to get our mount point. We’ll run a find command on each of the directories listed in $basemount to look for folders on which our drive could be mounted. This list will be passed to rofi from which we will chose our mount point.

  set -g mp (for d in $basemount
      find $d -maxdepth 5 -type d
  end | rofi -dmenu -i -p 'Type in mount point.')

We should verify that something has been actually selected, otherwise we should abort the script.

  if test -z $mp || test $mp = ""
      return 1
  end

Now, if the selected mount point does not exist, we’ll ask the user whether the directory should be created. If no, the script will abort. If yes, an attempt will be made at creating the directory as the user; if that fails, a new attempt will be made as sudo.

  if test ! -d $mp
      switch (printf "No\\nYes" | rofi -dmenu -i -p "$mp does not exist. Create it?")
          case 'Yes'
              mkdir -p $mp || sudo -A mkdir -p $mp
          case '*'
              return 1
      end
  end

Finally, let’s close the function

  end

Mount a USB drive, hard drive or partition

Alright, we want to mount a partition that answers by the name of /dev/sdXX, how do we do that? Let’s create first the function mountusb that will take care of it for us.

function mountusb

Now, the first thing we want to do is select the partition we want to mount. Remember, we stored those in $usbdrives earlier, so let’s pipe them into rofi so we can chose from it. Also, awk will get their path in /dev.

  set -g chosen (echo $usbdrives | \
  rofi -dmenu -i -p "Mount which drive?" | \
  awk '{print $1}')

As usual after a user selection, let’s verify something has actually been selected. If not, let’s abort the script.

test -z $chosen && return 1

Now, let’s select the mount point of our partition. We’ll call the function getmount described in Get the mount point to select it.

getmount

Let’s verify the variable mp set in getmount is not empty, otherwise abort the script.

test -z $mp && return 1

Now, let’s mount it! We’ll use a switch which will detect the filesystem used so we know how to mount the partition.

switch (lsblk -no "fstype" $chosen)

We have two named case: vfat filesystems.

  case "vfat"
      sudo -A mount -t vfat $chosen $mp -o rw,umask=0000

And ntfs filesystems.

  case "ntfs"
      sudo -A mount -t ntfs $chosen $mp -o rw,umask=0000

Else, we’ll let mount determine which filesystem is used by the partition (generally ext4).

  case '*'
      sudo -A mount $chosen $mp

We’ll also run a chown on this newly mounted filesystem so the user can access it without any issues.

  sudo -A chown -R $USER:(id -g $USER) $mp

Let’s close the switch block and send a notification the partition has been mounted.

end && notify-send -a "dmount" "💻 USB mounting" "$chosen mounted to $mp."

And let’s close the function.

end

Mount an Android device

The function that manages to mount Android filesystems is mountandroid. Let’s declare it.

function mountandroid -d "Mount an Android device"

We’ll select which Android we want to mount. We will be asked through rofi.

set chosen (echo $anddrives | rofi -dmenu -i -p "Which Android device?" | awk '{print $1 $2}' | sed 's/,$//')

Now, we need to get the bus of the Android device we want to mount. It will be useful later, after we authorized mounting from our device, to get the path to our partition.

set bus (echo $chosen | sed 's/,.*//')

Let’s temporarily mount our device.

jmtpfs -device=$chosen $mp

Now, we need to allow our computer to mount our Android device. Depending on the Android version it is running on, we either need to specify our device is USB connected in order to exchange files, or Android will explicitely ask us if it is OK for our computer to access it. Let’s inform the user of that.

  echo "OK" | \
  rofi -dmenu -i -p "Press (Allow) on your phone screen, or set your USB settings to allow file transfert"

Now, let’s get the actual path of our Android filesystem we wish to mount, and let’s unmount the previous temporary filesystem.

  set newchosen (jmtpfs -l | grep $bus | awk '{print $1 $2}' | sed 's/,$//')
  sudo -A umount $mp

Now we cam mount the new filesystem and send a notification if everything went well.

  jmtpfs -device=$newchosen $mp && \
  notify-send -a "dmount" "🤖 Android Mounting" "Android device mounted to $mp."

And now, we can close our function.

end

Mount a CD drive

This part is way easier than the previous functions. As we will see, the function mountcd's body is only three lines long. First, let’s declare the function.

function mountcd

Now, let’s chose the CD drive we want to mount using rofi.

  set chosen (echo $cddrives | rofi -dmenu -i -p "Which CD drive?")

We’ll also get the mountpoint thanks to the getmount function described earlier.

getmount

And finally, let’s mount it and send the notification everything went well.

  sudo -A mount $chosen $mp && \
  notify-send -a "dmount" "💿 CD mounting" "$chosen mounted."

Finally, let’s close our function.

end

Ask what type of drive we want to mount

The first thing we will be asked if different types of drives are detected is which of these types the user wishes to mount. This is done with the function asktype which is declared below.

function asktype

We will use a switch statement which will use our anwser to rofi about what we wish to mount.

switch (cat $TMPDRIVES | rofi -dmenu -i -p "Mount which drive?")

If we chose the option "USB", we’ll mount a hard drive, partition or USB drive. In which case we’ll call the mountusb function.

  case "USB"
      mountusb

If we chose the "Android" option, the mountandroid function is called.

  case "Android"
      mountandroid

Else if we chose the "CD" option, we’ll call the mountcd function.

  case "CD"
      mountcd

If nothing is selected, the function will naturally exit. Now, let’s close our switch statement and our function.

end
end

Launch the mounting functions

Now that we have declared our functions and set our variables, we’ll read the temporary file described in Get the mountable elements. The amount of lines is passed in a switch statement.

switch (wc -l < $TMPDRIVES)

If the file has no lines, i.e. it is empty, we have no mountable media. Let’s inform our user this is the case.

  case 0
      notify-send "No USB drive or Android device or CD detected" -a "dmount"

If we only have one line, we have only one type of mountable media. We’ll pass this line to a second switch statement.

  case 1
      switch (cat $TMPDRIVES)

This will allow the script to automatically detect what type of media it is, and mount the corresponding function.

  case "USB"
      mountusb
  case "Android"
      mountandroid
  case "CD"
      mountCD

Let’s close this nested switch case.

end

If we have more than one line, we’ll have to ask the user what type of media they want to mount.

  case '*'
      asktype

Now, let’s end our switch statement!

end

Finally, we’ll delete our temporary file.

rm -f $TMPDRIVES

And with that, this is the end of our script!

Rofi-pass

rofi-pass is a simple utility that gets a password stored in the pass password manager with rofi as its interface, and then stores the password in the clipboard. It is a fish script, so let’s declare it as one.

#!/usr/bin/env fish

Let’s parse all the arguments passed to the script. If one of them is --type, -t or type, the script will attempt to type the password to the text area already selected without pasting the password to the clipboard.

  for arg in $argv
      switch $arg
          case '--type'
              set -g TYPE "yes"
          case '-t'
              set -g TYPE "yes"
          case 'type'
              set -g TYPE "yes"
          case '*'
              printf 'Unknown argument: %s\n.' $arg
              exit 1
      end
  end

Now, let’s get the list of the passwords that exist in our pass repository.

  set passwords (find $HOME/.password-store -type f -name "*.gpg" | \
  string replace -r ".*.password-store/" "" | \
  string replace -r ".gpg" "" | sort)

Let the user choose which password they wish to select.

  set password (for elem in $passwords
      echo $elem
  end | rofi -dmenu -i -p "Select your password")

Let’s verify we actually selected a password and not just exited. If no password was selected, let’s simply exit the script.

  if test -z $password
      exit
  end

Depending on the arguments passed earlier, we might want some different behavior.

  if test $TYPE = "yes"
      <<rofi-pass-type>>
  else
      <<rofi-pass-copy>>
  end

The default behavior is to copy the password to the clipboard for 45 seconds, so let’s do that.

  pass show -c $password 2> /dev/null

Else, if we passed --type, -t or type as an argument of the script, we want it to attempt to type our password in the currently selected text input. Let’s do that.

  set -l IFS
  <<rofi-pass-type-get-password>>
  printf %s $pass | xvkbd -file -

To correctly get the password from pass, we need to parse the output and only get the first line, hence the following command.

set pass (pass show $password | string split -n \n)[1]

Rofi-umount

rofiumount is the counterpart of rofimount for unmounting our mounted partitions. It is a fish script, so let’s declare it as that with its shebang.

#!/usr/bin/env fish

Get the unmountable drives

First, we will need to list all the drives that can be safely unmounted. Let’s run this.

  set -g drives (lsblk -nrpo "name,type,size,mountpoint" | \
  awk '$2=="part"&&$4!~/\/boot|\/home$|SWAP/&&length($4)>1{printf "%s (%s)\n",$4,$3}')

Now, let’s get the android devices that are mounted.

set -g androids (awk '/jmtpfs/ {print $2}' /etc/mtab)

And let’s get the CD drives that are mounted.

set -g cds (awk '/sr0/ {print $2}' /etc/mtab)

We’ll store all of our information in a temporary file, /tmp/undrives.

set -g undrivefile /tmp/undrives

Let’s make sure we begin with a clean, empty file.

  rm -f $undrivefile
  touch $undrivefile

Depending on if the related variables are set, write the different types of mounted drives in the temporary file.

  test -n "$drives" && echo "USB" >> $undrivefile
  test -n "$cds" && echo "CD" >> $undrivefile
  test -n "$androids" && echo "Android" >> $undrivefile

Unmount disk partitions

The function unmountusb will take care of unmounting any drive we can safely unmount. First, let’s declare the function.

function unmountusb

Let’s chose the drive to unmount with rofi.

  set chosen (echo $drives | \
  rofi -dmenu -i -p "Unmount which drive?" | \
  awk '{print $1}')

Let’s verify if the user actually selected any drive. If no, let’s abort the script.

test -z "$chosen" && exit 0

Now, let’s unmount the chosen drive and send a notification if it has been done.

  sudo -A umount $chosen && \
  notify-send "💻 USB unmounting" "$chosen unmounted." -a "dumount"

Now, let’s close the function.

end

Unmount Android device

The function unmountandroid will take care of unmounting any mounted Android device. First, let’s declare our function.

function unmountandroid

Let the user choose which Android device to unmount.

set chosen (echo $androids | rofi -dmenu -i -p "Unmount which device?")

We’ll verify the user chose any device.

  test -z "$chosen" && exit 0

If a device has been chosen, let’s unmount it and send a notification it has been successfuly unmounted.

  sudo -A umount -l $chosen && \
  notify-send "🤖 Android unmounting" "$chosen unmounted." -a "dumount"

Finally, let’s close the function.

end

Unmount CD drive

unmountcd will take care of unmounting any mounted CD drive. Let’s declare this function.

function unmountcd

As before, let the user chose which CD drive to unmount.

set chosen (echo "$cds" | rofi -dmenu -i -p "Unmount which CD?")

We’ll verify the user chose any device.

  test -z "$chosen" && exit 0

If a drive has been chosen, let’s unmount it and send a notification it has been successfuly unmounted.

  sudo -A umount -l $chosen && \
  notify-send "💿 CD unmounting" "$chosen unmounted." -a "dumount"

Now, let’s close the function.

end

Ask what type of drive to unmount

If several types of unmountable drives are available, let’s ask the user which type to unmount based on the content of the temporary file declared in Get the unmountable drives. First, let’s declare the function.

function asktype

Let’s create a switch statement to which will be passed the selection of the user from rofi.

  switch (cat $undrivefile | rofi -dmenu -i -p "Unmount which type of device?")

Three types of values can be returned: "USB", "CD", or "Android". These values will be used to launch their corresponding function.

  case 'USB'
      unmountusb
  case 'CD'
      unmountcd
  case 'Android'
      unmountandroid

Let’s close the switch statement.

end

Let’s now close the function.

end

Launch the unmounting functions

Now back to the body of our script, let’s input in a switch case the number of lines contained in our temporary file.

switch (wc -l < $undrivefile)

If the file containes no lines. i.e. it is empty, nothing is to be unmounted. Let’s inform the user of that.

  case 0
      notify-send "No USB drive or Android device or CD to unmount" -a "dumount"

Else, if there is only one type of drive, we’ll automatically let our script choose based on the content of this sole line.

  case 1
      switch (cat $undrivefile)
          case 'USB'
              unmountusb
          case 'CD'
              unmountcd
          case 'Android'
              unmountandroid
      end

And if there are more types than one, let’s ask the user.

case '*'
     asktype

Let’s close our main switch statement.

end

And finally, let’s delete our temporary file.

rm -f $undrivefile

Starwars

This is a one-liner that allows you to watch Star Wars episode 4 in ASCII art in your terminal. Here is the code:

  #!/usr/bin/env fish
  telnet towel.blinkenlights.nl

UpdateFlutter

This is a simple utility to be ran when the flutter package is updated.

  #!/usr/bin/fish
  sudo chown -R :flutterusers /opt/flutter
  sudo chmod -R g+w /opt/flutter
  sudo chmod a+rw /opt/flutter/version
  sudo chown $USER:(id -g $USER) /opt/flutter/bin/cache

Wacom setup

I made a small and quick utility to set up my Wacom tablet so it is only bound to one screen. This is a fish script, so let’s insert the sheband.

#!/usr/bin/env fish

Set our variables

Let’s first declare our function that will be called to set our variables.

function set_device

We need some variables in order to correctly set our tablet. First, let’s get declare what the name of our tablet is, and what the name of its touchpad is.

  set -g DEVICE "Wacom USB Bamboo PAD Pen stylus"
  set -g DEVICETOUCH "Wacom USB Bamboo PAD Finger touch"

We will also modify two settings: the speed of the cursor on the touchpad, and the scroll speed. Let’s declare the name of these two settings.

  set -g WACOMPROPTOUCHSPEED "Device Accel Velocity Scaling"
  set -g WACOMPROPSCROLLPSEED "ScrollDistance"

To get the correct values for the area it can cover, we’ll need to reset our tablet.

xsetwacom set "$DEVICE" ResetArea

Now we can get the X and Y areas.

  set -l AREATOT (xsetwacom get "$DEVICE" Area)
  set -g AREAX (echo $AREATOT | awk '{print $3}')
  set -g AREAY (echo $AREATOT | awk '{print $4}')

Now let’s close our function.

end

Select our screen

This function will allow us to select the screen on which the tablet will be active. We can also select the option “desktop” so that all screens are selected. Let’s declare our function.

function set_screen

First, let’s set what screens are available, including the desktop option.

  set CONNECTED_DISPLAYS (xrandr -q --current | \
  sed -n 's/^\([^ ]\+\) connected .*/\1/p') desktop

Now, let’s select the one we wish to use using rofi.

  set -g SCREEN (for d in $CONNECTED_DISPLAYS
      echo $d
  end | rofi -dmenu -i -p "Select your dispaly" | tr -d '\n')

Now, let’s get the resolution of our selected screen.

  set -l LINE (xrandr -q --current | if [ "$SCREEN" = "desktop" ]
      sed -n 's/^Screen 0:.*, current \([0-9]\+\) x \([0-9]\+\),.*/\1 \2/p'
  else
      sed -n "s/^$SCREEN"' connected \(primary \)\{0,1\}\([0-9]\+\)x\([0-9]\+\)+.*/\2 \3/p'
  end)

From that, let’s get the vertical and horizontal resolution of our screen.

echo $LINE | read -g WIDTH HEIGHT

If any of our WIDTH ou HEIGHT it empty, we’ll have to abort the script.

  if test -z $WIDTH || test -z $HEIGHT
      exit 1
  end

Let’s close our function now.

end

Adjust the tablet

This function will take care of adjusting our tablet to our screen. Let’s declare our function.

function adjust_device

If our screen is too high or too wide for our tablet, we will have to adjust the height or width of the area used by the tablet. So let’s get the theoretical new height and width of the area.

  set RATIOAREAY (math ceil \($AREAX \* $HEIGHT \/ $WIDTH\))
  set RATIOAREAX (math ceil \($AREAY \* $WIDTH \/ $HEIGHT\))

Now, if the current height of the tablet’s area is greater than the theoretical new area, it means the current area is too high. Otherwise, it should be the other way around. Let’s set NEWAREAX and NEWAREAY that will be used to set the new area for the tablet.

  if test $AREAY -gt $RATIOAREAY
      set -g NEWAREAX $AREAX
      set -g NEWAREAY $RATIOAREAY
  else
      set -g NEWAREAX $RATIOAREAX
      set -g NEWAREAY $AREAY
  end

Alright, now let’s set the new area with these new variables.

  xsetwacom set "$DEVICE" Area 0 0 $NEWAREAX $NEWAREAY
  xsetwacom set "$DEVICE" MapToOutput "$SCREEN"

Let’s slow down the cursor’s speed on the touchpad.

xinput set-float-prop $DEVICETOUCH $WACOMPROPTOUCHSPEED 0.5

Let’s also slow down the scroll speed of the touchpad.

  xsetwacom set $DEVICETOUCH $WACOMPROPSCROLLPSEED "90"

Now, let’s close the function.

end

Lauch the functions

Back to the main body of the script, we can now launch the functions sequencially.

  set_device
  set_screen
  adjust_device

Yadm

For some reason, yadm won’t stop making polybar crash. So, I created this script that will wrap yadm with a call to yadm, and then a call to polybar-launch declared in Polybar-launch. This is a oneliner, as you can see below:

  #!/usr/bin/env fish
  /usr/bin/yadm $argv; polybar-launch 2>/dev/null >/dev/null