diff options
36 files changed, 3120 insertions, 1370 deletions
diff --git a/.local/share/kaomoji b/.local/share/kaomoji index b03258a..8e98b20 100644 --- a/.local/share/kaomoji +++ b/.local/share/kaomoji @@ -1,3 +1,7 @@ +ᵔᴗᵔ smile +ᐢᗜᐢ :D +˘ᗜ˘ :D +˃ᗜ˂ smile ʕ•ₒ•ʔ Bear Shocked ʕ•ᴥ•ʔ Bear ʕ ·ᴥ·ʔ RBear @@ -451,4 +455,4 @@ o(>< )o⌒* Mad (3) (；^＿^)ッ☆( ゜o゜) Slapping ＼（～Ｏ～）／ Good Morning \＿(´▽｀)♪＿/ Bathtub -( • )( • )ԅ(≖‿≖ԅ) BOOB +( • )( • )ԅ(≖‿≖ԅ) BOOB @@ -57,7 +57,7 @@ dzen2.font: mononoki URxvt*depth: 32 ! *.font: mononoki:minispace=False:size=10:antialias=true -*.font: FiraMono Nerd Font:minispace=False:size=10:antialias=true +*.font: FiraMono Nerd Font:size=10:antialias=true URxvt.font: font1,font2,font3,font4 URxvt.boldFont: font1:style=bold,font2:style=bold,font3:style=bold,font4 diff --git a/config/bspwm/bspwmrc b/config/bspwm/bspwmrc index c138806..bc49ff3 100755 --- a/config/bspwm/bspwmrc +++ b/config/bspwm/bspwmrc @@ -11,11 +11,17 @@ xsetroot -cursor_name left_ptr & xrdb ~/.config/Xdefaults pgrep -x sxhkd > /dev/null || sxhkd & -pgrep -x picom > /dev/null || picom & +pgrep -x picom > /dev/null || picom --root-pixmap-shader "/home/x/.config/picom/shaders/glitch.glsl" & pgrep -x xss-lock > /dev/null || xss-lock slock & pgrep -x bg.sh > /dev/null || $HOME/.scripts/bg.sh > /dev/null & -[ -f "$HOME/.config/xrandr.sh" ] && . $HOME/.config/xrandr.sh +if [ -f "$HOME/.config/xrandr.sh" ] ; then + . $HOME/.config/xrandr.sh +else + if [ -f "$HOME/.scripts/xrandr.sh" ] ; then + . $HOME/.scripts/xrandr.sh + fi +fi primary=$(bspc query --monitors -m primary) set -- a b c d e f g h i j k l m n o diff --git a/config/gtk-3.0/settings.ini b/config/gtk-3.0/settings.ini index 416e679..d2972d4 100644 --- a/config/gtk-3.0/settings.ini +++ b/config/gtk-3.0/settings.ini @@ -6,7 +6,7 @@ gtk-cursor-theme-size=24 gtk-decoration-layout=icon:minimize,maximize,close gtk-enable-animations=true gtk-fallback-icon-theme=gnome -gtk-font-name=mononoki 10 +gtk-font-name=FiraMono Nerd Font 10 gtk-icon-theme-name=Vimix-dark gtk-menu-images=1 gtk-primary-button-warps-slider=false diff --git a/config/picom/picom.conf b/config/picom/picom.conf index 1179a80..87c0383 100644 --- a/config/picom/picom.conf +++ b/config/picom/picom.conf @@ -1,121 +1,67 @@ ################################# -# Corners # -################################# -# requires: https://github.com/sdhand/compton -corner-radius = 4; -round-borders = 0; - -# Specify a list of border width rules, in the format `PIXELS:PATTERN`, -# Note we don't make any guarantee about possible conflicts with the -# border_width set by the window manager. -# -# example: -# round-borders-rule = [ "2:class_g = 'URxvt'" ]; -# -round-borders-rule = [ -]; - -################################# # Shadows # ################################# - -# Enabled client-side shadows on windows. Note desktop windows -# (windows with '_NET_WM_WINDOW_TYPE_DESKTOP') never get shadow, +# Enabled client-side shadows on windows. Note desktop windows +# (windows with '_NET_WM_WINDOW_TYPE_DESKTOP') never get shadow, # unless explicitly requested using the wintypes option. # -#shadow = false +# Can be set per-window using rules. +# +# Default: false shadow = true; -# The blur radius for shadows, in pixels. (defaults to 12) -# shadow-radius = 12 -shadow-radius = 20; - -# The opacity of shadows. (1.0 - 1.0, defaults to 0.75) -shadow-opacity = 0.7; - -# The left offset for shadows, in pixels. (defaults to -15) -# shadow-offset-x = -15 -shadow-offset-x = -20; - -# The top offset for shadows, in pixels. (defaults to -15) -# shadow-offset-y = -15 -shadow-offset-y = -20; - -# Don't draw shadows on drag-and-drop windows. This option is deprecated, -# you should use the *wintypes* option in your config file instead. +# The blur radius for shadows, in pixels. # -#no-dnd-shadow = true -#no-dock-shadow = false - -# Red color value of shadow (0.0 - 1.0, defaults to 0). -#shadow-red = 0.86328125 - -# Green color value of shadow (0.0 - 1.0, defaults to 0). -#shadow-green = 0.2109375 - -# Blue color value of shadow (0.0 - 1.0, defaults to 0). -#shadow-blue = 0.015625 +# Default: 12 +shadow-radius = 12; -# Do not paint shadows on shaped windows. Note shaped windows -# here means windows setting its shape through X Shape extension. -# Those using ARGB background is beyond our control. -# Deprecated, use -# shadow-exclude = 'bounding_shaped' -# or -# shadow-exclude = 'bounding_shaped && !rounded_corners' -# instead. +# The opacity of shadows. # -# shadow-ignore-shaped = '' +# Range: 0.0 - 1.0 +# Default: 0.75 +# shadow-opacity = .75 -# Specify a list of conditions of windows that should have no shadow. +# The left offset for shadows, in pixels. # -# examples: -# shadow-exclude = "n:e:Notification"; +# Default: -15 +shadow-offset-x = -7; + +# The top offset for shadows, in pixels. # -# shadow-exclude = [] -shadow-exclude = [ - "_GTK_FRAME_EXTENTS@:c", - #"_NET_WM_STATE@:32a" -]; +# Default: -15 +shadow-offset-y = -7; -# Specify a X geometry that describes the region in which shadow should not -# be painted in, such as a dock window region. Use -# shadow-exclude-reg = "x10+0+0" -# for example, if the 10 pixels on the bottom of the screen should not have shadows painted on. +# Hex string color value of shadow. Formatted like "#RRGGBB", e.g. "#C0FFEE". # -# shadow-exclude-reg = "" +# Default: #000000 +# shadow-color = "#000000" -# Crop shadow of a window fully on a particular Xinerama screen to the screen. -# xinerama-shadow-crop = false +# Crop shadow of a window fully on a particular monitor to that monitor. This is +# currently implemented using the X RandR extension. +# +# Default: false +# crop-shadow-to-monitor = false ################################# # Fading # ################################# - # Fade windows in/out when opening/closing and when opacity changes, -# unless no-fading-openclose is used. -# fading = false -fading = false; +# unless no-fading-openclose is used. Can be set per-window using rules. +# +# Default: false +fading = true; # Opacity change between steps while fading in. (0.01 - 1.0, defaults to 0.028) -# fade-in-step = 0.028 -fade-in-step = 0.03; +fade-in-step = 0.012; # Opacity change between steps while fading out. (0.01 - 1.0, defaults to 0.03) -# fade-out-step = 0.03 -fade-out-step = 0.03; +fade-out-step = 0.012; # The time between steps in fade step, in milliseconds. (> 0, defaults to 10) -fade-delta = 4 - -# Specify a list of conditions of windows that should not be faded. -# don't need this, we disable fading for all normal windows with wintypes: {} -fade-exclude = [ - "class_g = 'slop'" # maim -] +fade-delta = 2 # Do not fade on window open/close. # no-fading-openclose = false @@ -128,321 +74,252 @@ fade-exclude = [ # Transparency / Opacity # ################################# - -# Opacity of inactive windows. (0.1 - 1.0, defaults to 1.0) -# inactive-opacity = 1 - -# Opacity of window titlebars and borders. (0.1 - 1.0, disabled by default) -# frame-opacity = 1.0 - -# Default opacity for dropdown menus and popup menus. (0.0 - 1.0, defaults to 1.0) -# menu-opacity = 1.0 - -# Let inactive opacity set by -i override the '_NET_WM_OPACITY' values of windows. -# inactive-opacity-override = true -inactive-opacity-override = true; - -# Default opacity for active windows. (0.0 - 1.0, defaults to 1.0) -active-opacity = 1.0; - -# Dim inactive windows. (0.0 - 1.0, defaults to 0.0) -inactive-dim = 0.0 - -# Specify a list of conditions of windows that should always be considered focused. -# focus-exclude = [] -focus-exclude = [ - "class_g = 'slop'" # maim -]; +# Opacity of window titlebars and borders. +# +# Range: 0.1 - 1.0 +# Default: 1.0 (disabled) +frame-opacity = 0.7; # Use fixed inactive dim value, instead of adjusting according to window opacity. -# inactive-dim-fixed = 1.0 - -# Specify a list of opacity rules, in the format `PERCENT:PATTERN`, -# like `50:name *= "Firefox"`. picom-trans is recommended over this. -# Note we don't make any guarantee about possible conflicts with other -# programs that set '_NET_WM_WINDOW_OPACITY' on frame or client windows. -# example: -# opacity-rule = [ "80:class_g = 'URxvt'" ]; # -# opacity-rule = [] -opacity-rule = [ - "100:class_g = 'slop'", # maim -]; - +# Default: false +# inactive-dim-fixed = true ################################# -# Background-Blurring # +# Corners # ################################# +# Sets the radius of rounded window corners. When > 0, the compositor will +# round the corners of windows. Does not interact well with +# `transparent-clipping`. +# +# Default: 0 (disabled) +corner-radius = 0 + +################################# +# Blur # +################################# -# Parameters for background blurring, see the *BLUR* section for more information. -# blur-method = gaussian +# Parameters for background blurring, see BLUR section in the man page for more information. +# blur-method = # blur-size = 12 # # blur-deviation = false +# +# blur-strength = 5 -# Blur background of semi-transparent / ARGB windows. -# Bad in performance, with driver-dependent behavior. -# The name of the switch may change without prior notifications. +# Blur background of semi-transparent / ARGB windows. +# Can be set per-window using rules. # -blur-background = true; +# Default: false +# blur-background = false -# Blur background of windows when the window frame is not opaque. +# Blur background of windows when the window frame is not opaque. # Implies: -# blur-background -# Bad in performance, with driver-dependent behavior. The name may change. +# blur-background # -# blur-background-frame = false; - +# Default: false +# blur-background-frame = false # Use fixed blur strength rather than adjusting according to window opacity. -# blur-background-fixed = false; +# +# Default: false +# blur-background-fixed = false # Specify the blur convolution kernel, with the following format: # example: # blur-kern = "5,5,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1"; +# Can also be a pre-defined kernel, see the man page. # -# blur-kern = '' -# blur-kern = "3x3box"; - -blur: { - # requires: https://github.com/ibhagwan/picom - #method = "none"; - method = "kawase"; - strength = 3; - deviation = 1.0; - background = true; - background-frame = false; - background-fixed = false; - kern = "3x3box"; -} - -# Exclude conditions for background blur. -blur-background-exclude = [ - "class_g != 'St'", - "_GTK_FRAME_EXTENTS@:c" -]; - +# Default: "" +blur-kern = "3x3box"; ################################# # General Settings # ################################# +# Enable remote control via D-Bus. See the man page for more details. +# +# Default: false +# dbus = true + # Daemonize process. Fork to background after initialization. Causes issues with certain (badly-written) drivers. -daemon = true +# daemon = false -# Specify the backend to use: `xrender`, `glx`, or `xr_glx_hybrid`. -# `xrender` is the default one. +# Specify the backend to use: `xrender`, `glx`, or `egl`. # -experimental-backends = true; -backend = "glx"; +# Default: "xrender" +backend = "glx" -vsync = false +# Use higher precision during rendering, and apply dither when presenting the +# rendered screen. Reduces banding artifacts, but may cause performance +# degradation. Only works with OpenGL. +dithered-present = false; -# Enable remote control via D-Bus. See the *D-BUS API* section below for more details. -# dbus = false - -# Try to detect WM windows (a non-override-redirect window with no -# child that has 'WM_STATE') and mark them as active. +# Enable/disable VSync. # -# mark-wmwin-focused = false -mark-wmwin-focused = true; - -# Mark override-redirect windows that doesn't have a child window with 'WM_STATE' focused. -# mark-ovredir-focused = false -mark-ovredir-focused = true; +# Default: false +vsync = true; -# Try to detect windows with rounded corners and don't consider them +# Try to detect windows with rounded corners and don't consider them # shaped windows. The accuracy is not very high, unfortunately. # +# Has nothing to do with `corner-radius`. +# +# Default: false detect-rounded-corners = true; -# Detect '_NET_WM_OPACITY' on client windows, useful for window managers -# not passing '_NET_WM_OPACITY' of client windows to frame windows. +# Detect '_NET_WM_WINDOW_OPACITY' on client windows, useful for window managers +# not passing '_NET_WM_WINDOW_OPACITY' of client windows to frame windows. # -#detect-client-opacity = false +# Default: false detect-client-opacity = true; -# Specify refresh rate of the screen. If not specified or 0, picom will -# try detecting this with X RandR extension. -# -# refresh-rate = 60 -refresh-rate = 0 - -# Limit picom to repaint at most once every 1 / 'refresh_rate' second to -# boost performance. This should not be used with -# vsync drm/opengl/opengl-oml -# as they essentially does sw-opti's job already, -# unless you wish to specify a lower refresh rate than the actual value. -# -# sw-opti = - -# Use EWMH '_NET_ACTIVE_WINDOW' to determine currently focused window, -# rather than listening to 'FocusIn'/'FocusOut' event. Might have more accuracy, +# Use EWMH '_NET_ACTIVE_WINDOW' to determine currently focused window, +# rather than listening to 'FocusIn'/'FocusOut' event. May be more accurate, # provided that the WM supports it. # +# Default: false # use-ewmh-active-win = false -# Unredirect all windows if a full-screen opaque window is detected, -# to maximize performance for full-screen windows. Known to cause flickering -# when redirecting/unredirecting windows. paint-on-overlay may make the flickering less obvious. +# Unredirect all windows if a full-screen opaque window is detected, +# to maximize performance for full-screen windows. Known to cause flickering +# when redirecting/unredirecting windows. # -# unredir-if-possible = true +# Default: false +# unredir-if-possible = false -# Delay before unredirecting the window, in milliseconds. Defaults to 0. +# Delay before unredirecting the window, in milliseconds. +# +# Default: 0. # unredir-if-possible-delay = 0 -# Conditions of windows that shouldn't be considered full-screen for unredirecting screen. -# unredir-if-possible-exclude = [] - -# Use 'WM_TRANSIENT_FOR' to group windows, and consider windows +# Use 'WM_TRANSIENT_FOR' to group windows, and consider windows # in the same group focused at the same time. # -# detect-transient = false -detect-transient = true +# Default: false +detect-transient = true; -# Use 'WM_CLIENT_LEADER' to group windows, and consider windows in the same -# group focused at the same time. 'WM_TRANSIENT_FOR' has higher priority if -# detect-transient is enabled, too. +# Use 'WM_CLIENT_LEADER' to group windows, and consider windows in the same +# group focused at the same time. This usually means windows from the same application +# will be considered focused or unfocused at the same time. +# 'WM_TRANSIENT_FOR' has higher priority if detect-transient is enabled, too. # +# Default: false # detect-client-leader = false -detect-client-leader = true - -# Resize damaged region by a specific number of pixels. -# A positive value enlarges it while a negative one shrinks it. -# If the value is positive, those additional pixels will not be actually painted -# to screen, only used in blur calculation, and such. (Due to technical limitations, -# with use-damage, those pixels will still be incorrectly painted to screen.) -# Primarily used to fix the line corruption issues of blur, -# in which case you should use the blur radius value here -# (e.g. with a 3x3 kernel, you should use `--resize-damage 1`, -# with a 5x5 one you use `--resize-damage 2`, and so on). -# May or may not work with *--glx-no-stencil*. Shrinking doesn't function correctly. -# -# resize-damage = 1 - -# Specify a list of conditions of windows that should be painted with inverted color. -# Resource-hogging, and is not well tested. -# -# invert-color-include = [] -# GLX backend: Avoid using stencil buffer, useful if you don't have a stencil buffer. -# Might cause incorrect opacity when rendering transparent content (but never -# practically happened) and may not work with blur-background. -# My tests show a 15% performance boost. Recommended. +# Use of damage information for rendering. This cause the only the part of the +# screen that has actually changed to be redrawn, instead of the whole screen +# every time. Should improve performance. # -# glx-no-stencil = false +# Default: false +use-damage = false; -# GLX backend: Avoid rebinding pixmap on window damage. -# Probably could improve performance on rapid window content changes, -# but is known to break things on some drivers (LLVMpipe, xf86-video-intel, etc.). -# Recommended if it works. +# Use X Sync fence to wait for the completion of rendering of other windows, +# before using their content to render the current screen. # -# glx-no-rebind-pixmap = false - -# Disable the use of damage information. -# This cause the whole screen to be redrawn everytime, instead of the part of the screen -# has actually changed. Potentially degrades the performance, but might fix some artifacts. -# The opposing option is use-damage +# Required for explicit sync drivers, such as nvidia. # -# no-use-damage = false -use-damage = true +# Default: false +# xrender-sync-fence = false -# Use X Sync fence to sync clients' draw calls, to make sure all draw -# calls are finished before picom starts drawing. Needed on nvidia-drivers -# with GLX backend for some users. +# GLX backend: Use specified GLSL fragment shader for rendering window +# contents. Read the man page for a detailed explanation of the interface. # -xrender-sync-fence = true - -# GLX backend: Use specified GLSL fragment shader for rendering window contents. -# See `compton-default-fshader-win.glsl` and `compton-fake-transparency-fshader-win.glsl` -# in the source tree for examples. +# Can be set per-window using rules. # -# glx-fshader-win = '' +#window-shader-fg = "~/.config/picom/shaders/glitch_animation.glsl" -# Force all windows to be painted with blending. Useful if you -# have a glx-fshader-win that could turn opaque pixels transparent. +# Force all windows to be painted with blending. Useful if you +# have a `window-shader-fg` that could turn opaque pixels transparent. # +# Default: false # force-win-blend = false -# Do not use EWMH to detect fullscreen windows. +# Do not use EWMH to detect fullscreen windows. # Reverts to checking if a window is fullscreen based only on its size and coordinates. # +# Default: false # no-ewmh-fullscreen = false -# Dimming bright windows so their brightness doesn't exceed this set value. -# Brightness of a window is estimated by averaging all pixels in the window, -# so this could comes with a performance hit. -# Setting this to 1.0 disables this behaviour. Requires --use-damage to be disabled. (default: 1.0) +# Dimming bright windows so their brightness doesn't exceed this set value. +# Brightness of a window is estimated by averaging all pixels in the window, +# so this could comes with a performance hit. +# Setting this to 1.0 disables this behaviour. Requires --use-damage to be disabled. # +# Default: 1.0 (disabled) # max-brightness = 1.0 # Make transparent windows clip other windows like non-transparent windows do, -# instead of blending on top of them. +# instead of blending on top of them. e.g. placing a transparent window on top +# of another window will cut a "hole" in that window, and show the desktop background +# underneath. # +# Default: false # transparent-clipping = false # Set the log level. Possible values are: # "trace", "debug", "info", "warn", "error" -# in increasing level of importance. Case doesn't matter. -# If using the "TRACE" log level, it's better to log into a file +# in increasing level of importance. Case insensitive. +# If using the "TRACE" log level, it's better to log into a file # using *--log-file*, since it can generate a huge stream of logs. # -# log-level = "debug" -log-level = "info"; +# Default: "warn" +# log-level = "warn"; # Set the log file. -# If *--log-file* is never specified, logs will be written to stderr. -# Otherwise, logs will to written to the given file, though some of the early -# logs might still be written to the stderr. +# If *--log-file* is never specified, logs will be written to stderr. +# Otherwise, logs will to written to the given file, though some of the early +# logs might still be written to the stderr. # When setting this option from the config file, it is recommended to use an absolute path. # -# log-file = '/path/to/your/log/file' - -# Show all X errors (for debugging) -# show-all-xerrors = false +# log-file = "/path/to/your/log/file" # Write process ID to a file. -# write-pid-path = '/path/to/your/log/file' - -# Window type settings -# -# 'WINDOW_TYPE' is one of the 15 window types defined in EWMH standard: -# "unknown", "desktop", "dock", "toolbar", "menu", "utility", -# "splash", "dialog", "normal", "dropdown_menu", "popup_menu", -# "tooltip", "notification", "combo", and "dnd". -# -# Following per window-type options are available: :: -# -# fade, shadow::: -# Controls window-type-specific shadow and fade settings. -# -# opacity::: -# Controls default opacity of the window type. -# -# focus::: -# Controls whether the window of this type is to be always considered focused. -# (By default, all window types except "normal" and "dialog" has this on.) -# -# full-shadow::: -# Controls whether shadow is drawn under the parts of the window that you -# normally won't be able to see. Useful when the window has parts of it -# transparent, and you want shadows in those areas. -# -# redir-ignore::: -# Controls whether this type of windows should cause screen to become -# redirected again after been unredirected. If you have unredir-if-possible -# set, and doesn't want certain window to cause unnecessary screen redirection, -# you can set this to `true`. -# -wintypes: +# write-pid-path = "/path/to/your/log/file" + +# Rule-based per-window options. +# +# See WINDOW RULES section in the man page for how these work. +rules: ({ + match = "window_type = 'tooltip'"; + fade = false; + shadow = true; + opacity = 0.9; + full-shadow = false; +}, { + match = "window_type = 'dock' || " + "window_type = 'desktop' || " + "_GTK_FRAME_EXTENTS@"; + blur-background = false; +}, { + match = "window_type != 'dock'"; +}, { + match = "window_type = 'dock' || " + "window_type = 'desktop'"; + corner-radius = 0; +}, { + match = "name = 'Notification' || " + "class_g = 'Conky' || " + "class_g ?= 'Notify-osd' || " + "class_g = 'Cairo-clock' || " + "_GTK_FRAME_EXTENTS@"; + shadow = false; +}, { - normal = { fade = true; shadow = true;} - tooltip = { fade = true; shadow = true; opacity = 0.75; focus = true; full-shadow = false; }; - dock = { full-shadow = true; } - dnd = { shadow = true; } - popup_menu = { shadow = true; } - dropdown_menu = { shadow = true; } -}; -unredir-if-possible = false + match = "window_type = 'desktop'"; + shader = "/home/x/.config/picom/shaders/glitch.glsl"; +}, +{ + match = "window_type != 'desktop'"; + shader = "/home/x/.config/picom/shaders/glitch_animation.glsl"; +}); + +# `@include` directive can be used to include additional configuration files. +# Relative paths are search either in the parent of this configuration file +# (when the configuration is loaded through a symlink, the symlink will be +# resolved first). Or in `$XDG_CONFIG_HOME/picom/include`. +# +# @include "extra.conf" + diff --git a/config/picom/shaders/OldCRT.glsl b/config/picom/shaders/OldCRT.glsl new file mode 100644 index 0000000..6e02812 --- /dev/null +++ b/config/picom/shaders/OldCRT.glsl @@ -0,0 +1,190 @@ +#version 430 +#define PI 3.1415926538 +uniform float opacity; +uniform float time; + +// Works best with fullscreen windows +// Made this to play retro games the way god intended + +uniform float sc_freq = 0.2; // Frequency for the scanlines + +uniform float sc_intensity = 0.6; // Intensity of the scanline effect + +uniform bool grid = false; // Whether to also apply scanlines to x axis or not + +uniform int distortion_offset = 2; // Pixel offset for red/blue distortion + +uniform int downscale_factor = 2; // How many pixels of the window + // make an actual "pixel" (or block) + +uniform float sph_distance = 500; // Distance from the theoretical sphere + // we use for our curvature transform + +uniform float curvature = 1.5; // How much the window should "curve" + +uniform float shadow_cutoff = 1; // How "early" the shadow starts affecting + // pixels close to the edges + // I'd keep this value very close to 1 + +uniform int shadow_intensity = 1; // Intensity level of the shadow effect (from 1 to 5) + +vec4 outside_color = vec4(0 ,0 ,0, opacity); // Color for the outside of the window + +float flash_speed = 0; // Speed of flashing effect, set to 0 to deactivate + +float flash_intensity = 0.8; // Intensity of flashing effect + + +// You can play with different values for all the variables above + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + +ivec2 window_size = textureSize(tex, 0); +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); +float radius = (window_size.x/curvature); +int flash = int(round(flash_speed*time/(10000/window_size.y))) % window_size.y; + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// Darkens a pixels near the edges +vec4 darken_color(vec4 color, vec2 coords) +{ + // If shadow intensity is 0, change nothing + if (shadow_intensity == 0) + { + return color; + } + + // Get how far the coords are from the center + vec2 distances_from_center = abs(window_center - coords); + + // Darken pixels close to the edges of the screen in a polynomial fashion + float brightness = 1; + brightness *= -pow((distances_from_center.y/window_center.y)*shadow_cutoff, + (5/shadow_intensity)*2)+1; + brightness *= -pow((distances_from_center.x/window_center.x)*shadow_cutoff, + (5/shadow_intensity)*2)+1; + color.xyz *= brightness; + + return color; +} + +// Applies a transformation to our window pixels to simulate +// a curved screen +ivec2 curve_coords_spheric(vec2 coords) +{ + // Offset coords + coords -= window_center; + vec2 curved_coords; + + // For this transform imagine a sphere in a 3d space with the + // window as a 2d plane tangent to that sphere + // For simplicity, we center the sphere at 0,0,0 + // The coordinates of the projection share x and y with our window pixel + // We find Z using the formula for a sphere + vec3 projection_coords3d = vec3(coords.x, coords.y, + sqrt(pow(radius+sph_distance,2)- + pow(coords.x,2)- + pow(coords.y,2))); + + // That vector goes from the center of the sphere to the projection of a pixel + // of our window onto the sphere's surface + // Let's scale it until it hits our window plane + projection_coords3d *= ((radius+sph_distance)/projection_coords3d.z); + curved_coords = projection_coords3d.xy; + + // Compensate for starting coords offset + curved_coords += window_center; + + return ivec2(curved_coords); +} + + +// Gets a color for a pixel with all the coordinate and +// downscale changes +vec4 get_pixel(vec2 coords) +{ + // If pixel is at the edge of the window, return a completely black color + if (coords.x >=window_size.x-1 || coords.y >=window_size.y-1 || + coords.x <=0 || coords.y <=0) + { + return outside_color; + } + vec4 color = texelFetch(tex, ivec2(coords), 0); + return default_post_processing(color); +} + +// Gets the color from a downscaled block +vec4 get_block_color(vec2 coords) +{ + // If downscale is set to 1, just return a pixel + if (downscale_factor < 2) + { + return get_pixel(coords); + } + + // Relative position of pixel inside the block + ivec2 relative_position; + relative_position.xy = ivec2(coords).xy % downscale_factor; + + // Average all colors from pixels inside the block + vec4 average = vec4(0, 0 , 0, 0); + for (int i = 0; i < downscale_factor; i++) + { + for (int j = 0; j < downscale_factor; j++) + { + average.xyzw += get_pixel(vec2(coords.x + i - relative_position.x, + coords.y + j - relative_position.y)); + } + } + average /= pow(downscale_factor, 2); + + return average; +} + + +// Main shader function +vec4 window_shader() { + + // Apply curvature transform to coords + vec2 curved_coords = curve_coords_spheric(texcoord); + + // Fetch the color + vec4 c = get_block_color(curved_coords); + + // Fetch colors from close pixels to apply color distortion + vec4 c_right = get_block_color(vec2(curved_coords.x+2, curved_coords.y)); + vec4 c_left = get_block_color(vec2(curved_coords.x-2, curved_coords.y)); + + // Mix red and blue colors + c = vec4(c_left.x, c.y, c_right.z, c.w); + + // Apply scanlines + c.xyz *= sin(2*PI*sc_freq*(texcoord).y)/(2/sc_intensity) + + 1 - sc_intensity/2; + + // Also apply scanlines to x axis if grid is enabled + if (grid == true) + { + c.xyz *= sin(2*PI*sc_freq*(texcoord).x)/(2/sc_intensity) + + 1 - sc_intensity/2; + } + + // Apply flash + if (curved_coords.y >=flash-(window_size.y/10) && curved_coords.y <=flash) + { + c.xyz *= flash_intensity*(pow(((flash-curved_coords.y)/(window_size.y/10))-1,2) + + 1/flash_intensity); + } + + // Darken pixel + c = darken_color(c, curved_coords); + return (c); +} diff --git a/config/picom/shaders/bg.glsl b/config/picom/shaders/bg.glsl new file mode 100644 index 0000000..e15c18d --- /dev/null +++ b/config/picom/shaders/bg.glsl @@ -0,0 +1,138 @@ +#version 330 + +int delta = 20; +float barh = 0.05; +float barw = 0.6; +int nbar = 8; + +float maxoff = 32; +float minoff = 2; +float hue = 0.3; + +// blinds +int blinds_spacing = 4; +int blinds_width = 1; +float blinds_intensity = 1.2; + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window +ivec2 window_size = textureSize(tex, 0); +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +uniform float time; // Time in miliseconds. + +float alpha = round(time/delta); // Like time, but in seconds and resets to + +vec4 blinds(vec4 c, vec2 coords) { + if (mod(coords.y, blinds_spacing) < blinds_width) { + return c * blinds_intensity; + } + + return c; +} + +vec3 hueShift( vec3 color, float hueAdjust ){ + + const vec3 kRGBToYPrime = vec3 (0.299, 0.587, 0.114); + const vec3 kRGBToI = vec3 (0.596, -0.275, -0.321); + const vec3 kRGBToQ = vec3 (0.212, -0.523, 0.311); + + const vec3 kYIQToR = vec3 (1.0, 0.956, 0.621); + const vec3 kYIQToG = vec3 (1.0, -0.272, -0.647); + const vec3 kYIQToB = vec3 (1.0, -1.107, 1.704); + + float YPrime = dot (color, kRGBToYPrime); + float I = dot (color, kRGBToI); + float Q = dot (color, kRGBToQ); + float hue = atan (Q, I); + float chroma = sqrt (I * I + Q * Q); + + hue += hueAdjust; + + Q = chroma * sin (hue); + I = chroma * cos (hue); + + vec3 yIQ = vec3 (YPrime, I, Q); + + return vec3( dot (yIQ, kYIQToR), dot (yIQ, kYIQToG), dot (yIQ, kYIQToB) ); + +} + +// Pseudo-random function (from original shader) +float random(float n) { + return fract(sin(n) * 43758.5453f); +} + +float get_box() { + float n = random(alpha)*(nbar); + + for(int i=0;i<n;i++){ + float y = random(mod(alpha, 2048)+i) * window_size.y; + float x = random(mod(alpha+128, 2048)+i) * window_size.x; + float w = random(mod(alpha+64, 2048)+i) * barw*window_size.x; + float h = random(mod(alpha+32, 2048)+i) * barh*window_size.y; + if (texcoord.y > y && texcoord.y < y + h + && texcoord.x > x && texcoord.x < x + w) { + return i*w*h*y*x*n; + } + } + return -1.0f; +} + +float rand_offset(float b) { + return (random(b*64) - 0.5) * (maxoff*2); +} + +vec4 window_color(vec2 uv) { + return blinds(texelFetch(tex, ivec2(uv), 0), uv); +} + +vec4 window_shader() { + float b = get_box(); + + if (b == -1.0) { + vec4 c = window_color(ivec2(texcoord)); + return default_post_processing(c); + } + //b = random(mod(alpha, 2000)); + + // Offsets in pixels for each color + vec2 uvr = vec2(rand_offset(b*1), rand_offset(b*6)); + vec2 uvg = vec2(rand_offset(b*2),rand_offset(b*7)); + vec2 uvb = vec2(rand_offset(b*3),rand_offset(b*8)); + + + // Calculate offset coords + uvr += texcoord; + uvg += texcoord; + uvb += texcoord; + + // Fetch colors using offset coords + vec3 offset_color; + offset_color.x = window_color(uvr).x; + offset_color.y = window_color(uvg).y; + offset_color.z = window_color(uvb).z; + + offset_color.x = hueShift(window_color(uvr).xyz, hue).x; + offset_color.y = hueShift(window_color(uvg).xyz, hue).y; + offset_color.z = hueShift(window_color(uvb).xyz, hue).z; + + offset_color.xyz = hueShift(offset_color.xyz, -hue); + // Set the new color + vec4 c; + c.w = texelFetch(tex, ivec2(uvr), 0).w; + c.xyz = offset_color; + + c.xyz = hueShift(c.xyz, random(mod(b, 2000))); + + return default_post_processing(c); +} + diff --git a/config/picom/shaders/cross.glsl b/config/picom/shaders/cross.glsl new file mode 100644 index 0000000..2241508 --- /dev/null +++ b/config/picom/shaders/cross.glsl @@ -0,0 +1,335 @@ +#version 430 +#define PI 3.14159265 + +// These shaders work by using a pinhole camera and raycasting +// The window 3d objects will always be (somewhat) centered at (0, 0, 0) +struct pinhole_camera +{ + float focal_offset; // Distance along the Z axis between the camera + // center and the focal point. Use negative values + // so the image doesn't flip + // This kinda works like FOV in games + + // Transformations + // Use these to modify the coordinate system of the camera plane + vec3 rotations; // Rotations in radians around each axis + // The camera plane rotates around + // its center point, not the origin + + vec3 translations; // Translations in pixels along each axis + + vec3 deformations; // Deforms the camera. Higher values on each axis + // means the window will be squashed in that axis + + // ---------------------------------------------------------------// + + // "Aftervalues" + // These will be set later with setup_camera(), leave them as 0 + vec3 base_x; + vec3 base_y; + vec3 base_z; + vec3 center_point; + vec3 focal_point; +}; + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + + +uniform float time; // Time in miliseconds. + +float time_cyclic = mod(time/10000,2); // Like time, but in seconds and resets to + // 0 when it hits 2. Useful for using it in + // periodic functions like cos and sine +// Time variables can be used to change transformations over time + + +ivec2 window_size = textureSize(tex, 0); // Size of the window + +float window_diagonal = length(window_size); // Diagonal of the window +// Try to keep focal offset and translations proportional to window_size components +// or window_diagonal as you see fit + +pinhole_camera camera = +pinhole_camera(-window_size.y/2, // Focal offset + vec3(0,0,0), // Rotations + vec3(0,0,0), // Translations + vec3(1,1,1), // Deformations + // Leave the rest as 0 + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Here are some presets you can use + +// Moves the camera up and down +pinhole_camera bobbing = +pinhole_camera(-window_size.y/2, + vec3(0,0,0), + vec3(0,cos(time_cyclic*PI)*window_size.y/16,-window_size.y/4), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Rotates camera around the origin +// Makes the window rotate around the Y axis from the camera's POV +// (if the window is centered) +pinhole_camera rotate_around_origin = +pinhole_camera(-window_diagonal, + vec3(0,-time_cyclic*PI-PI/2,0), + vec3(cos(time_cyclic*PI)*window_diagonal, + 0, + sin(time_cyclic*PI)*window_diagonal), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Rotate camera around its center +pinhole_camera rotate_around_itself = +pinhole_camera(-window_diagonal, + vec3(0,-time_cyclic*PI-PI/2,0), + vec3(0,0,-window_diagonal), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Here you can select the preset to use +pinhole_camera window_cam = rotate_around_origin; + + + +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// Sets up a camera by applying transformations and +// calculating xyz vector basis +pinhole_camera setup_camera(pinhole_camera camera) +{ + // Apply translations + camera.center_point += camera.translations; + + // Apply rotations + // We initialize our vector basis as normalized vectors + // in each axis * our deformations vector + camera.base_x = vec3(camera.deformations.x, 0, 0); + camera.base_y = vec3(0, camera.deformations.y, 0); + camera.base_z = vec3(0, 0, camera.deformations.z); + + + // Then we rotate them around following our rotations vector: + // First save these values to avoid redundancy + float cosx = cos(camera.rotations.x); + float cosy = cos(camera.rotations.y); + float cosz = cos(camera.rotations.z); + float sinx = sin(camera.rotations.x); + float siny = sin(camera.rotations.y); + float sinz = sin(camera.rotations.z); + + // Declare a buffer vector we will use to apply multiple changes at once + vec3 tmp = vec3(0); + + // Rotations for base_x: + tmp = camera.base_x; + // X axis: + tmp.y = camera.base_x.y * cosx - camera.base_x.z * sinx; + tmp.z = camera.base_x.y * sinx + camera.base_x.z * cosx; + camera.base_x = tmp; + // Y axis: + tmp.x = camera.base_x.x * cosy + camera.base_x.z * siny; + tmp.z = -camera.base_x.x * siny + camera.base_x.z * cosy; + camera.base_x = tmp; + // Z axis: + tmp.x = camera.base_x.x * cosz - camera.base_x.y * sinz; + tmp.y = camera.base_x.x * sinz + camera.base_x.y * cosz; + camera.base_x = tmp; + + // Rotations for base_y: + tmp = camera.base_y; + // X axis: + tmp.y = camera.base_y.y * cosx - camera.base_y.z * sinx; + tmp.z = camera.base_y.y * sinx + camera.base_y.z * cosx; + camera.base_y = tmp; + // Y axis: + tmp.x = camera.base_y.x * cosy + camera.base_y.z * siny; + tmp.z = -camera.base_y.x * siny + camera.base_y.z * cosy; + camera.base_y = tmp; + // Z axis: + tmp.x = camera.base_y.x * cosz - camera.base_y.y * sinz; + tmp.y = camera.base_y.x * sinz + camera.base_y.y * cosz; + camera.base_y = tmp; + + // Rotations for base_z: + tmp = camera.base_z; + // X axis: + tmp.y = camera.base_z.y * cosx - camera.base_z.z * sinx; + tmp.z = camera.base_z.y * sinx + camera.base_z.z * cosx; + camera.base_z = tmp; + // Y axis: + tmp.x = camera.base_z.x * cosy + camera.base_z.z * siny; + tmp.z = -camera.base_z.x * siny + camera.base_z.z * cosy; + camera.base_z = tmp; + // Z axis: + tmp.x = camera.base_z.x * cosz - camera.base_z.y * sinz; + tmp.y = camera.base_z.x * sinz + camera.base_z.y * cosz; + camera.base_z = tmp; + + // Now that we have our transformed 3d orthonormal base + // we can calculate our focal point + camera.focal_point = camera.center_point + camera.base_z * camera.focal_offset; + + // Return our set up camera + return camera; +} + +// Gets a pixel from the end of a ray projected to an axis +vec4 get_pixel_from_projection(float t, int face, pinhole_camera camera, vec3 focal_vector) +{ + // If the point we end up in is behind our camera, don't "render" it + if (t < 1) + { + return vec4(0); + } + + // Then we multiply our focal vector by t and add our focal point to it + // to end up in a point inside the window plane + vec3 intersection = focal_vector * t + camera.focal_point; + + + // Save a the necessary coordinates and add back offset + vec2 cam_coords; + switch (face) + { + case 0: + cam_coords = intersection.xy + window_center; + break; + case 1: + cam_coords = intersection.zy + window_center; + break; + } + + // If pixel is outside of our window region + // return a completely transparent color + if (cam_coords.x >=window_size.x-1 || + cam_coords.y >=window_size.y-1 || + cam_coords.x <=0 || cam_coords.y <=0) + { + return vec4(0); + } + + // Fetch the pixel + vec4 pixel = texelFetch(tex, ivec2(cam_coords), 0); + return pixel; +} + +// Combines colors using alpha +// Got this from https://stackoverflow.com/questions/64701745/how-to-blend-colours-with-transparency +// Not sure how it works honestly lol +vec4 alpha_composite(vec4 color1, vec4 color2) +{ + + float ar = color1.w + color2.w - (color1.w * color2.w); + float asr = color2.w / ar; + float a1 = 1 - asr; + float a2 = asr * (1 - color1.w); + float ab = asr * color1.w; + vec4 outcolor; + outcolor.xyz = color1.xyz * a1 + color2.xyz * a2 + color2.xyz * ab; + outcolor.w = ar; + return outcolor; + +} + +// Gets a pixel through the camera using coords as coordinates in +// the camera plane +vec4 get_pixel_through_camera(vec2 coords, pinhole_camera camera) +{ + // Offset coords + coords -= window_center; + + // Find the pixel 3d position using the camera vector basis + vec3 pixel_3dposition = camera.center_point + + coords.x * camera.base_x + + coords.y * camera.base_y; + + // Get the vector going from the focal point to the pixel in 3d sapace + vec3 focal_vector = pixel_3dposition - camera.focal_point; + + // We need 2 planes, one for each axis of the cross, they all follow the plane EQ + // ax + by + cz + d + float a[] = {0,1}; + float b[] = {0,0}; + float c[] = {1,0}; + float d[] = {0,0}; + // Then there's a line going from our focal point to each of the planes + // which we can describe as: + // x(t) = focal_point.x + focal_vector.x * t + // y(t) = focal_point.y + focal_vector.y * t + // z(t) = focal_point.z + focal_vector.z * t + // We substitute x, y and z with x(t), y(t) and z(t) in the plane EQ + // Solving for t we get: + vec2 t[2]; // we use a vec2 to also store the plane that was hit + for (int i = 0; i < 2; i++) + { + t[i].x = (d[i] + - a[i]*camera.focal_point.x + - b[i]*camera.focal_point.y + - c[i]*camera.focal_point.z) + / (a[i]*focal_vector.x + + b[i]*focal_vector.y + + c[i]*focal_vector.z); + t[i].y = i; + } + + // Bubble sort to know which intersections happen first + for (int i = 0; i < t.length(); i++) + { + for (int j = 0; j < t.length(); j++) + { + if (t [j].x > t[j+1].x) + { + vec2 tmp = t[j]; + t[j] = t[j+1]; + t[j+1] = tmp; + } + } + } + + // Then we go through each one of the intersections in order + // and mix pixels together using alpha + vec4 blended_pixels = vec4(0); + for (int i = 0; i < 2; i++) + { + // We get the pixel through projection + vec4 projection_pixel = get_pixel_from_projection(t[i].x, + int(t[i].y), + camera, + focal_vector); + // Blend the pixel using alpha + blended_pixels = alpha_composite(projection_pixel, blended_pixels); + } + return blended_pixels; +} + +// Main function +vec4 window_shader() { + pinhole_camera transformed_cam = setup_camera(window_cam); + return(get_pixel_through_camera(texcoord, transformed_cam)); +} diff --git a/config/picom/shaders/cube.glsl b/config/picom/shaders/cube.glsl new file mode 100644 index 0000000..8988a7d --- /dev/null +++ b/config/picom/shaders/cube.glsl @@ -0,0 +1,373 @@ +#version 430 +#define PI 3.14159265 + +// These shaders work by using a pinhole camera and raycasting +// The window 3d objects will always be (somewhat) centered at (0, 0, 0) +struct pinhole_camera +{ + float focal_offset; // Distance along the Z axis between the camera + // center and the focal point. Use negative values + // so the image doesn't flip + // This kinda works like FOV in games + + // Transformations + // Use these to modify the coordinate system of the camera plane + vec3 rotations; // Rotations in radians around each axis + // The camera plane rotates around + // its center point, not the origin + + vec3 translations; // Translations in pixels along each axis + + vec3 deformations; // Deforms the camera. Higher values on each axis + // means the window will be squashed in that axis + + // ---------------------------------------------------------------// + + // "Aftervalues" + // These will be set later with setup_camera(), leave them as 0 + vec3 base_x; + vec3 base_y; + vec3 base_z; + vec3 center_point; + vec3 focal_point; +}; + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + + +uniform float time; // Time in miliseconds. + +float time_cyclic = mod(time/10000,2); // Like time, but in seconds and resets to + // 0 when it hits 2. Useful for using it in + // periodic functions like cos and sine + +// Time variables can be used to change transformations over time + + +ivec2 window_size = textureSize(tex, 0); // Size of the window + +float window_diagonal = length(window_size); // Diagonal of the window + +int wss = min(window_size.x, window_size.y); // Window smallest side, useful when squaring windows +// Try to keep focal offset and translations proportional to window_size components +// or window_diagonal as you see fit + +pinhole_camera camera = +pinhole_camera(-window_size.y/2, // Focal offset + vec3(0,0,0), // Rotations + vec3(0,0,0), // Translations + vec3(1,1,1), // Deformations + // Leave the rest as 0 + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Here are some presets you can use + +// Moves the camera up and down +pinhole_camera bobbing = +pinhole_camera(-window_size.y/2, + vec3(0,0,0), + vec3(0,cos(time_cyclic*PI)*window_size.y/16,-window_size.y/4), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Rotates camera around the origin +// Makes the window rotate around the Y axis from the camera's POV +// (if the window is centered) +pinhole_camera rotate_around_origin = +pinhole_camera(-wss, + vec3(PI/6*sin(2*time_cyclic*PI),-time_cyclic*PI-PI/2,0), + vec3(cos(time_cyclic*PI)*wss, + wss/2*sin(2*time_cyclic*PI), + sin(time_cyclic*PI)*wss), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Rotate camera around its center +pinhole_camera rotate_around_itself = +pinhole_camera(-wss, + vec3(0,-time_cyclic*PI-PI/2,0), + vec3(0,0,-wss), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Here you can select the preset to use +pinhole_camera window_cam = rotate_around_origin; + + + +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// Sets up a camera by applying transformations and +// calculating xyz vector basis +pinhole_camera setup_camera(pinhole_camera camera) +{ + // Apply translations + camera.center_point += camera.translations; + + // Apply rotations + // We initialize our vector basis as normalized vectors + // in each axis * our deformations vector + camera.base_x = vec3(camera.deformations.x, 0, 0); + camera.base_y = vec3(0, camera.deformations.y, 0); + camera.base_z = vec3(0, 0, camera.deformations.z); + + + // Then we rotate them around following our rotations vector: + // First save these values to avoid redundancy + float cosx = cos(camera.rotations.x); + float cosy = cos(camera.rotations.y); + float cosz = cos(camera.rotations.z); + float sinx = sin(camera.rotations.x); + float siny = sin(camera.rotations.y); + float sinz = sin(camera.rotations.z); + + // Declare a buffer vector we will use to apply multiple changes at once + vec3 tmp = vec3(0); + + // Rotations for base_x: + tmp = camera.base_x; + // X axis: + tmp.y = camera.base_x.y * cosx - camera.base_x.z * sinx; + tmp.z = camera.base_x.y * sinx + camera.base_x.z * cosx; + camera.base_x = tmp; + // Y axis: + tmp.x = camera.base_x.x * cosy + camera.base_x.z * siny; + tmp.z = -camera.base_x.x * siny + camera.base_x.z * cosy; + camera.base_x = tmp; + // Z axis: + tmp.x = camera.base_x.x * cosz - camera.base_x.y * sinz; + tmp.y = camera.base_x.x * sinz + camera.base_x.y * cosz; + camera.base_x = tmp; + + // Rotations for base_y: + tmp = camera.base_y; + // X axis: + tmp.y = camera.base_y.y * cosx - camera.base_y.z * sinx; + tmp.z = camera.base_y.y * sinx + camera.base_y.z * cosx; + camera.base_y = tmp; + // Y axis: + tmp.x = camera.base_y.x * cosy + camera.base_y.z * siny; + tmp.z = -camera.base_y.x * siny + camera.base_y.z * cosy; + camera.base_y = tmp; + // Z axis: + tmp.x = camera.base_y.x * cosz - camera.base_y.y * sinz; + tmp.y = camera.base_y.x * sinz + camera.base_y.y * cosz; + camera.base_y = tmp; + + // Rotations for base_z: + tmp = camera.base_z; + // X axis: + tmp.y = camera.base_z.y * cosx - camera.base_z.z * sinx; + tmp.z = camera.base_z.y * sinx + camera.base_z.z * cosx; + camera.base_z = tmp; + // Y axis: + tmp.x = camera.base_z.x * cosy + camera.base_z.z * siny; + tmp.z = -camera.base_z.x * siny + camera.base_z.z * cosy; + camera.base_z = tmp; + // Z axis: + tmp.x = camera.base_z.x * cosz - camera.base_z.y * sinz; + tmp.y = camera.base_z.x * sinz + camera.base_z.y * cosz; + camera.base_z = tmp; + + // Now that we have our transformed 3d orthonormal base + // we can calculate our focal point + camera.focal_point = camera.center_point + camera.base_z * camera.focal_offset; + + // Return our set up camera + return camera; +} + +// Gets a pixel from the end of a ray projected to an axis +vec4 get_pixel_from_projection(float t, int face, pinhole_camera camera, vec3 focal_vector) +{ + // If the point we end up in is behind our camera, don't "render" it + if (t < 1) + { + return vec4(0); + } + + // Then we multiply our focal vector by t and add our focal point to it + // to end up in a point inside the window plane + vec3 intersection = focal_vector * t + camera.focal_point; + + + // Save necessary coordinates + // (different cube faces need different coords) + vec2 cam_coords; + switch (face) + { + case 0: + cam_coords = intersection.xy; + break; + case 1: + cam_coords = intersection.xy; + break; + case 2: + cam_coords = intersection.zy; + break; + case 3: + cam_coords = intersection.zy; + break; + case 4: + cam_coords = intersection.zx; + break; + case 5: + cam_coords = intersection.zx; + break; + } + + if (window_size.x > window_size.y) + { + cam_coords.x /= window_size.y/float(window_size.x); + cam_coords.xy += window_center.xy; + } + else if (window_size.x < window_size.y) + { + cam_coords.y /= window_size.x/float(window_size.y); + cam_coords.xy += window_center.xy; + } + // If pixel is outside of our window region + // return a completely transparent color + if (cam_coords.x >=window_size.x-1 || + cam_coords.y >=window_size.y-1 || + cam_coords.x <=0 || cam_coords.y <=0) + { + return vec4(0); + } + + // Fetch the pixel + vec4 pixel = texelFetch(tex, ivec2(cam_coords), 0); + + return pixel; +} + +// Combines colors using alpha +// Got this from https://stackoverflow.com/questions/64701745/how-to-blend-colours-with-transparency +// Not sure how it works honestly lol +vec4 alpha_composite(vec4 color1, vec4 color2) +{ + float ar = color1.w + color2.w - (color1.w * color2.w); + float asr = color2.w / ar; + float a1 = 1 - asr; + float a2 = asr * (1 - color1.w); + float ab = asr * color1.w; + vec4 outcolor; + outcolor.xyz = color1.xyz * a1 + color2.xyz * a2 + color2.xyz * ab; + outcolor.w = ar; + return outcolor; +} + +// Gets a pixel through the camera using coords as coordinates in +// the camera plane +vec4 get_pixel_through_camera(vec2 coords, pinhole_camera camera) +{ + // Offset coords + coords -= window_center; + + // Find the pixel 3d position using the camera vector basis + vec3 pixel_3dposition = camera.center_point + + coords.x * camera.base_x + + coords.y * camera.base_y; + + // Get the vector going from the focal point to the pixel in 3d sapace + vec3 focal_vector = pixel_3dposition - camera.focal_point; + + // We need 6 planes, one for each face of the cube, they all follow the plane EQ + // ax + by + cz + d + float a[] = {0,0, + 1,1, + 0,0}; + float b[] = {0,0, + 0,0, + 1,1}; + float c[] = {1,1, + 0,0, + 0,0}; + float d[] = {-wss/2.0,wss/2.0, + -wss/2.0,wss/2.0, + -wss/2.0,wss/2.0}; + + // Then there's a line going from our focal point to each of the planes + // which we can describe as: + // x(t) = focal_point.x + focal_vector.x * t + // y(t) = focal_point.y + focal_vector.y * t + // z(t) = focal_point.z + focal_vector.z * t + // We substitute x, y and z with x(t), y(t) and z(t) in the plane EQ + // Solving for t we get: + vec2 t[6]; // we use a vec2 to also store the plane that was hit + for (int i = 0; i < t.length(); i++) + { + t[i].x = (d[i] + - a[i]*camera.focal_point.x + - b[i]*camera.focal_point.y + - c[i]*camera.focal_point.z) + / (a[i]*focal_vector.x + + b[i]*focal_vector.y + + c[i]*focal_vector.z); + t[i].y = i; + } + + // Bubble sort to know which intersections happen first + for (int i = 0; i < t.length(); i++) + { + for (int j = 0; j < t.length(); j++) + { + if (t [j].x > t[j+1].x) + { + vec2 tmp = t[j]; + t[j] = t[j+1]; + t[j+1] = tmp; + } + } + } + + // Then we go through each one of the intersections in order + // and mix pixels together using alpha + vec4 blended_pixels = vec4(0); + for (int i = 0; i < t.length(); i++) + { + // We get the pixel through projection + vec4 projection_pixel = get_pixel_from_projection(t[i].x, + int(t[i].y), + camera, + focal_vector); + // Only blend non fully transparent pixels + if (projection_pixel.w > 0.0) + { + // Blend the pixel using alpha + blended_pixels = alpha_composite(projection_pixel, blended_pixels); + } + } + return blended_pixels; +} + +// Main function +vec4 window_shader() { + pinhole_camera transformed_cam = setup_camera(window_cam); + return(get_pixel_through_camera(texcoord, transformed_cam)); +} diff --git a/config/picom/shaders/default_anim.glsl b/config/picom/shaders/default_anim.glsl new file mode 100644 index 0000000..e4f43ed --- /dev/null +++ b/config/picom/shaders/default_anim.glsl @@ -0,0 +1,70 @@ +#version 330 + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + + +ivec2 window_size = textureSize(tex, 0); // Size of the window +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +/* +These shaders use a sorta hacky way to use the changing +window opacity you might set on picom.conf animation rules +to perform animations. + +Basically, when a window get's mapped, we make it's alpha +go from 0 to 1, so, using the default_post_processing to get that alpha +we can get a variable going from 0 (start of mapping animation) +to 1 (end of mapping animation) + +You can also set up your alpha value to go from 1 to 0 in picom when +a window is closed, effectively reversing the animations described here +*/ + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// If you have semitransparent windows (like a terminal) +// You can use the below function to add an opacity threshold where the +// animation won't apply. For example, if you had your terminal +// configured to have 0.8 opacity, you'd set the below variable to 0.8 +float max_opacity = 1; +float opacity_threshold(float opacity) +{ + // if statement jic? + if (opacity >= max_opacity) + { + return 1.0; + } + else + { + return min(1, opacity/max_opacity); + } + +} + +vec4 anim(float time) { + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + return c; +} + +// Default window shader: +// 1) fetch the specified pixel +// 2) apply default post-processing +vec4 window_shader() { + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + c = default_post_processing(c); + float opacity = opacity_threshold(c.w); + if (opacity == 0.0) + { + return c; + } + vec4 anim_c = anim(opacity); + return default_post_processing(anim_c); +} + diff --git a/config/picom/shaders/dither.glsl b/config/picom/shaders/dither.glsl new file mode 100644 index 0000000..6a2a285 --- /dev/null +++ b/config/picom/shaders/dither.glsl @@ -0,0 +1,127 @@ +#version 430 + +bool monochrome = false; // Whether to apply a black & white filter to the window + +// You can modify the list of patterns to whatever you like, the code will +// adapt to it as long as it is a list of equally sized 2D arrays +// This example shows a dither pattern list that uses numbers other than +// 0 and 1 for more color variation +// Dither patterns +float dither [][][] = { {{0 , 0 }, + {0 , 0 }}, + + {{0.5, 0 }, + {0 , 0 }}, + + {{0.5, 0 }, + {0 , 0.5}}, + + {{0.5, 0.5}, + {0 , 0.5}}, + + {{0.5, 0.5}, + {0.5, 0.5}}, + + {{1 , 0.5}, + {0.5,0.5}}, + + {{1 , 0.5}, + {0.5, 1 }}, + + {{1 , 1 }, + {0.5, 1 }}, + + {{1 , 1 }, + {1 , 1 }} }; + +// Some more props that depend on the dither patterns +float bit_depth = dither.length() - 1.0; +int block_size = dither[0].length(); + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// Returns a monochromatic pixel +vec4 to_monochrome (vec4 pixel) +{ + float brightness = (pixel.x + pixel.y + pixel.z)/3; + return vec4(vec3(brightness), pixel.w); +} + +vec4 window_shader() { + // Alpha for the current pixel + float alpha; + + // Relative block position + ivec2 block_pos; + block_pos.x = int(texcoord.x) % block_size; + block_pos.y = int(texcoord.y) % block_size; + + // Current block total color + vec3 block_color = vec3(0,0,0); + + // We will iterate over all the pixels in the block + // and save it to this variable + vec4 pixel; + for (int y = 0; y < block_size; y += 1) + { + for (int x = 0; x < block_size; x += 1) + { + // Apply default post processing picom things and + // add color values after. + pixel = texelFetch(tex, ivec2(texcoord.x+x-block_pos.x,texcoord.y+y-block_pos.y), 0); + pixel = default_post_processing(pixel); + if (monochrome) + { + pixel = to_monochrome(pixel); + block_color.x += pixel.x; + } + else + { + block_color.x += pixel.x; + block_color.y += pixel.y; + block_color.z += pixel.z; + } + + // If we are on the current pixel, save the alpha value + if (x == 0 && y == 0) + { + alpha = pixel.w; + } + } + } + // Normalize block colors and quantify them + block_color.x = block_color.x/float(block_size*block_size); + block_color.x = round(block_color.x*bit_depth); + + // Get the pixel colors using our dither pattern + block_color.x = dither[int(block_color.x)][block_pos.y][block_pos.x]; + + if (monochrome) + { + block_color.yz = block_color.xx; + } + else + { + block_color.y = block_color.y/float(block_size*block_size); + block_color.y = round(block_color.y*bit_depth); + + block_color.z = block_color.z/float(block_size*block_size); + block_color.z = round(block_color.z*bit_depth); + + block_color.y = dither[int(block_color.y)][block_pos.y][block_pos.x]; + block_color.z = dither[int(block_color.z)][block_pos.y][block_pos.x]; + } + + // Set the final value for our pixel + pixel = vec4(block_color.x, block_color.y, block_color.z, alpha); + return pixel; +} diff --git a/config/picom/shaders/glass.glsl b/config/picom/shaders/glass.glsl new file mode 100644 index 0000000..a37972e --- /dev/null +++ b/config/picom/shaders/glass.glsl @@ -0,0 +1,165 @@ +#version 330 + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + + +ivec2 window_size = textureSize(tex, 0); // Size of the window +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +/* +These shaders use a sorta hacky way to use the changing +window opacity you might set on picom.conf animation rules +to perform animations. + +Basically, when a window get's mapped, we make it's alpha +go from 0 to 1, so, using the default_post_processing to get that alpha +we can get a variable going from 0 (start of mapping animation) +to 1 (end of mapping animation) + +You can also set up your alpha value to go from 1 to 0 in picom when +a window is closed, effectively reversing the animations described here +*/ + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// If you have semitransparent windows (like a terminal) +// You can use the below function to add an opacity threshold where the +// animation won't apply. For example, if you had your terminal +// configured to have 0.8 opacity, you'd set the below variable to 0.8 +float max_opacity = 0.8; +float opacity_threshold(float opacity) +{ + // if statement jic? + if (opacity >= max_opacity) + { + return 1.0; + } + else + { + return min(1, opacity/max_opacity); + } + +} + +// Pseudo-random function (from original shader) +float random(vec2 st) { + return fract(sin(dot(st.xy, vec2(12.9898,78.233))) * 43758.5453123); +} + +float PI = 3.1415926535; +float TWO_PI = 2.0 * PI; + +// NEW anim function: Glass-Shard Shatter +vec4 anim(float animation_progress) { + vec4 out_color = vec4(0.0); // Default to transparent + + // --- Shard Parameters --- + float num_shards = 20.0; // Number of angular shards + vec2 impact_point = window_center; + + // --- Fragment's Relation to Impact Point & Shard ID --- + vec2 vec_frag_to_impact = texcoord - impact_point; + float dist_frag_to_impact = length(vec_frag_to_impact); + float angle_frag = atan(vec_frag_to_impact.y, vec_frag_to_impact.x); // Range: -PI to PI + if (angle_frag < 0.0) { + angle_frag += TWO_PI; // Normalize to 0 to 2*PI + } + float shard_id = floor(angle_frag / (TWO_PI / num_shards)); + + // --- Staggered Animation Timing for each Shard --- + // Use random for a less ordered shatter + float shard_delay_normalized = random(vec2(shard_id, shard_id * 0.31)); + // float shard_delay_normalized = shard_id / num_shards; // For a sweep + + float individual_shard_anim_duration = 0.7; // How long each shard takes to animate + float ripple_spread_factor = 1.0 - individual_shard_anim_duration; + + float stagger_start_progress = shard_delay_normalized * ripple_spread_factor; + float stagger_end_progress = stagger_start_progress + individual_shard_anim_duration; + + // shard_anim_progress: 0.0 (shard starts moving in) -> 1.0 (shard is in place) + float shard_anim_progress = smoothstep(stagger_start_progress, stagger_end_progress, animation_progress); + + if (shard_anim_progress < 0.001) { // Shard is not yet visible or fully shattered away + return vec4(0.0); // Fully transparent + } + + // --- Shard Transformation Parameters --- + // current_displacement_factor: 1.0 (max shatter) -> 0.0 (assembled) + float current_displacement_factor = 1.0 - shard_anim_progress; + + // Max translation (e.g., 30% of half window width) + float max_translation_dist = length(vec2(window_size) * 0.5) * 0.3; + // Max rotation (e.g., 25 degrees) + float max_rotation_angle_rad = (PI / 180.0) * 25.0 * random(vec2(shard_id * 0.7, shard_id)); // Add some randomness to rotation + + // Direction for this shard (center angle of the shard sector) + float shard_center_angle = (shard_id + 0.5) * (TWO_PI / num_shards); + vec2 shard_radial_dir = vec2(cos(shard_center_angle), sin(shard_center_angle)); + + vec2 translation_offset = shard_radial_dir * max_translation_dist * current_displacement_factor; + float current_rotation = max_rotation_angle_rad * current_displacement_factor; + + // --- Inverse Transformation for Sampling --- + // We are at `texcoord` on screen. Find where this point came from on the original texture. + // 1. Undo translation + vec2 p1_translated_back = texcoord - translation_offset; + + // 2. Undo rotation around impact_point + vec2 p1_rel_to_impact = p1_translated_back - impact_point; + float cos_rot = cos(current_rotation); // Rotate by +angle to undo shatter rotation by -angle + float sin_rot = sin(current_rotation); // (or vice-versa, depends on convention) + // Let's assume shatter rotates by -current_rotation + // So to undo, rotate by +current_rotation + mat2 rot_matrix = mat2(cos_rot, -sin_rot, sin_rot, cos_rot); + vec2 p2_rotated_back = rot_matrix * p1_rel_to_impact; + vec2 sample_coord = p2_rotated_back + impact_point; + + // --- Boundary Check & Texture Fetch --- + if (sample_coord.x >= 0.0 && sample_coord.x < float(window_size.x) && + sample_coord.y >= 0.0 && sample_coord.y < float(window_size.y)) { + + // --- Chromatic Aberration --- + float ca_strength = 0.008 * current_displacement_factor; // Stronger when more shattered + vec2 ca_offset_dir = shard_radial_dir; // Radial aberration + // vec2 ca_offset_dir = vec2(-shard_radial_dir.y, shard_radial_dir.x); // Tangential + + vec2 r_sample = sample_coord + ca_offset_dir * ca_strength * float(window_size.x); + vec2 b_sample = sample_coord - ca_offset_dir * ca_strength * float(window_size.x); + + out_color.r = texelFetch(tex, ivec2(r_sample), 0).r; + out_color.g = texelFetch(tex, ivec2(sample_coord), 0).g; // Green channel from center + out_color.b = texelFetch(tex, ivec2(b_sample), 0).b; + out_color.a = texelFetch(tex, ivec2(sample_coord), 0).a; // Base alpha from original texture + + } else { + out_color.a = 0.0; // Sampled point is outside original texture + } + + // Modulate final alpha by shard's animation progress + out_color.a *= shard_anim_progress; + return out_color; +} + + +// Default window shader: +// 1) fetch the specified pixel +// 2) apply default post-processing +vec4 window_shader() { + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + c = default_post_processing(c); + float opacity = opacity_threshold(c.w); + if (opacity == 0.0) + { + return c; + } + vec4 anim_c = anim(opacity); + return default_post_processing(anim_c); +} diff --git a/config/picom/shaders/glitch.glsl b/config/picom/shaders/glitch.glsl new file mode 100644 index 0000000..aa27fe6 --- /dev/null +++ b/config/picom/shaders/glitch.glsl @@ -0,0 +1,85 @@ +#version 330 + +int delta = 20; +float barh = 0.05; +float barw = 0.6; +int nbar = 8; + +float maxoff = 32; +float minoff = 2; + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window +ivec2 window_size = textureSize(tex, 0); +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +uniform float time; // Time in miliseconds. + +float alpha = round(time/delta); // Like time, but in seconds and resets to + +// Pseudo-random function (from original shader) +float random(float n) { + return fract(sin(n) * 43758.5453f); +} + +float get_box() { + float n = random(alpha)*(nbar); + + for(int i=0;i<n;i++){ + float y = random(mod(alpha, 2048)+i) * window_size.y; + float x = random(mod(alpha+128, 2048)+i) * window_size.x; + float w = random(mod(alpha+64, 2048)+i) * barw*window_size.x; + float h = random(mod(alpha+32, 2048)+i) * barh*window_size.y; + if (texcoord.y > y && texcoord.y < y + h + && texcoord.x > x && texcoord.x < x + w) { + return i*w*h*y*x*n; + } + } + return -1.0f; +} + +float rand_offset(float b) { + return (random(b*64) - 0.5) * (maxoff*2); +} + +vec4 window_shader() { + float b = get_box(); + + if (b == -1.0) { + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + return default_post_processing(c); + } + //b = random(mod(alpha, 2000)); + + // Offsets in pixels for each color + vec2 uvr = vec2(rand_offset(b*1), rand_offset(b*6)); + vec2 uvg = vec2(rand_offset(b*2),rand_offset(b*7)); + vec2 uvb = vec2(rand_offset(b*3),rand_offset(b*8)); + + // Calculate offset coords + uvr += texcoord; + uvg += texcoord; + uvb += texcoord; + + // Fetch colors using offset coords + vec3 offset_color; + offset_color.x = texelFetch(tex, ivec2(uvr), 0).x; + offset_color.y = texelFetch(tex, ivec2(uvg), 0).y; + offset_color.z = texelFetch(tex, ivec2(uvb), 0).z; + + // Set the new color + vec4 c; + c.w = texelFetch(tex, ivec2(uvr), 0).w; + c.xyz = offset_color; + + return default_post_processing(c); +} + diff --git a/config/picom/shaders/glitch_animation.glsl b/config/picom/shaders/glitch_animation.glsl new file mode 100644 index 0000000..801fc93 --- /dev/null +++ b/config/picom/shaders/glitch_animation.glsl @@ -0,0 +1,126 @@ +#version 330 + +float maxoff = 10; +float minoff = 0; +float hue = 0.3; + +float block_max = 500; +float block_min = 200; + +float pixelate_size = 3; + +in vec2 texcoord; // texture coordinate of the fragment +uniform sampler2D tex; // texture of the window + +vec4 default_post_processing(vec4 c); + +uniform float time; // Time in miliseconds. + +float max_opacity = 0.9; +float opacity_threshold(float opacity) +{ + // if statement jic? + if (opacity >= max_opacity) { + return 1.0; + } else { + return min(1, opacity/max_opacity); + } + +} + +// Pseudo-random function (from original shader) +float random(float n) { + return fract(sin(n) * 43758.5453f); +} + +float rand_offset(float b, float off) { + return (random(b*64) - 0.5) * (off*2); +} + +vec4 alpha_effect(vec4 pix, vec2 coord) { + if (random(coord.x * random(coord.y / 100)) < pix.w) { + pix.w = 1; + return pix; + } + return vec4(0, 0, 0, 0); + +} + +vec3 hueShift( vec3 color, float hueAdjust ){ + + const vec3 kRGBToYPrime = vec3 (0.299, 0.587, 0.114); + const vec3 kRGBToI = vec3 (0.596, -0.275, -0.321); + const vec3 kRGBToQ = vec3 (0.212, -0.523, 0.311); + + const vec3 kYIQToR = vec3 (1.0, 0.956, 0.621); + const vec3 kYIQToG = vec3 (1.0, -0.272, -0.647); + const vec3 kYIQToB = vec3 (1.0, -1.107, 1.704); + + float YPrime = dot (color, kRGBToYPrime); + float I = dot (color, kRGBToI); + float Q = dot (color, kRGBToQ); + float hue = atan (Q, I); + float chroma = sqrt (I * I + Q * Q); + + hue += hueAdjust; + + Q = chroma * sin (hue); + I = chroma * cos (hue); + + vec3 yIQ = vec3 (YPrime, I, Q); + + return vec3( dot (yIQ, kYIQToR), dot (yIQ, kYIQToG), dot (yIQ, kYIQToB) ); + +} + +vec4 anim(float alpha) { + float block = mix(block_max, block_min, alpha); + vec2 bs = floor(texcoord / block) * block + block/2; + + float b = random(bs.y) * random(mod(time/10000,2)); + + float off = mix(maxoff, minoff, alpha); + if (b > alpha) { + off = 0; + } + + // Offsets in pixels for each color + vec2 uvr = vec2(rand_offset(b*1, off), rand_offset(b*6, off)); + vec2 uvg = vec2(rand_offset(b*2, off), rand_offset(b*7, off)); + vec2 uvb = vec2(rand_offset(b*3, off), rand_offset(b*8, off)); + + // Calculate offset coords + uvr += texcoord; + uvg += texcoord; + uvb += texcoord; + + // Fetch colors using offset coords + vec3 offset_color; + offset_color.x = texelFetch(tex, ivec2(uvr), 0).x; + offset_color.y = texelFetch(tex, ivec2(uvg), 0).y; + + offset_color.x = hueShift(texelFetch(tex, ivec2(uvr), 0).xyz, hue).x; + offset_color.y = hueShift(texelFetch(tex, ivec2(uvg), 0).xyz, hue).y; + offset_color.z = hueShift(texelFetch(tex, ivec2(uvb), 0).xyz, hue).z; + + offset_color.xyz = hueShift(offset_color.xyz, -hue); + + // Set the new color + vec4 c; + + c.xyz = offset_color; + + return c; +} + +vec4 window_shader() { + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + c = default_post_processing(c); + float opacity = opacity_threshold(c.w); + c = anim(opacity); + c.w = opacity; + c = alpha_effect(c, ceil(texcoord / pixelate_size) * pixelate_size); + //c = default_post_processing(c); + return c; +} + diff --git a/config/picom/shaders/matrix_dissolve.glsl b/config/picom/shaders/matrix_dissolve.glsl new file mode 100644 index 0000000..aaa6c4b --- /dev/null +++ b/config/picom/shaders/matrix_dissolve.glsl @@ -0,0 +1,78 @@ +#version 330 + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + + +ivec2 window_size = textureSize(tex, 0); // Size of the window +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +/* +These shaders use a sorta hacky way to use the changing +window opacity you might set on picom.conf animation rules +to perform animations. + +Basically, when a window get's mapped, we make it's alpha +go from 0 to 1, so, using the default_post_processing to get that alpha +we can get a variable going from 0 (start of mapping animation) +to 1 (end of mapping animation) + +You can also set up your alpha value to go from 1 to 0 in picom when +a window is closed, effectively reversing the animations described here +*/ + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); +// Pseudo-random function +float random(vec2 st) { + return fract(sin(dot(st.xy, vec2(12.9898,78.233))) * 43758.5453123); +} + +// Creates vertical scanlines +float scanline(vec2 uv, float time) { + return sin(uv.y * 200.0 + time * 10.0) * 0.5 + 0.5; +} + +vec4 anim(float time) { + vec2 uv = texcoord / vec2(window_size); + + // Adjust square size (smaller number = more squares) + float square_size = 4.0; + + // Calculate grid position + vec2 square_pos = floor(texcoord / square_size); + + // Generate random value for this square + float index = random(square_pos); + + // Get original color + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + + // Create threshold for dissolve + float threshold = (1.0 - time) * 1.2; // The 1.2 creates a slight overlap + + // If the random index is greater than our threshold, make pixel transparent + if (index > threshold) { + c.a = 0.0; + } + + return c; +} + +// Default window shader: +// 1) fetch the specified pixel +// 2) apply default post-processing +vec4 window_shader() { + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + c = default_post_processing(c); + if (c.w != 1.0) + { + c = anim(1.0-c.w); + } + return default_post_processing(c); +} diff --git a/config/picom/shaders/pixelize.glsl b/config/picom/shaders/pixelize.glsl new file mode 100644 index 0000000..8a9c72e --- /dev/null +++ b/config/picom/shaders/pixelize.glsl @@ -0,0 +1,72 @@ +#version 330 + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + + +ivec2 window_size = textureSize(tex, 0); // Size of the window +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +/* +These shaders use a sorta hacky way to use the changing +window opacity you might set on picom.conf animation rules +to perform animations. + +Basically, when a window get's mapped, we make it's alpha +go from 0 to 1, so, using the default_post_processing to get that alpha +we can get a variable going from 0 (start of mapping animation) +to 1 (end of mapping animation) + +You can also set up your alpha value to go from 1 to 0 in picom when +a window is closed, effectively reversing the animations described here +*/ + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// If you have semitransparent windows (like a terminal) +// You can use the below function to add an opacity threshold where the +// animation won't apply. For example, if you had your terminal +// configured to have 0.8 opacity, you'd set the below variable to 0.8 +float max_opacity = 0.9; +float opacity_threshold(float opacity) +{ + // if statement jic? + if (opacity >= max_opacity) + { + return 1.0; + } + else + { + return min(1, opacity/max_opacity); + } + +} + +vec4 anim(float time) { +// block size shrinks from 40→1 + float block = mix(40.0, 1.0, time); + vec2 uvb = floor(texcoord / block) * block + block/2; + vec4 c = texelFetch(tex, ivec2(uvb), 0); + return c; +} + +// Default window shader: +// 1) fetch the specified pixel +// 2) apply default post-processing +vec4 window_shader() { + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + c = default_post_processing(c); + float opacity = opacity_threshold(c.w); + if (opacity != 1.0) + { + c = anim(opacity); + } + return default_post_processing(c); +} + diff --git a/config/picom/shaders/pixelize_median.glsl b/config/picom/shaders/pixelize_median.glsl new file mode 100755 index 0000000..9d695aa --- /dev/null +++ b/config/picom/shaders/pixelize_median.glsl @@ -0,0 +1,85 @@ +#version 330 + +#define vec vec3 +#define toVec(x) x.rgb + +#define s2(a, b) temp = a; a = min(a, b); b = max(temp, b); +#define mn3(a, b, c) s2(a, b); s2(a, c); +#define mx3(a, b, c) s2(b, c); s2(a, c); + +#define mnmx3(a, b, c) mx3(a, b, c); s2(a, b); // 3 exchanges +#define mnmx4(a, b, c, d) s2(a, b); s2(c, d); s2(a, c); s2(b, d); // 4 exchanges +#define mnmx5(a, b, c, d, e) s2(a, b); s2(c, d); mn3(a, c, e); mx3(b, d, e); // 6 exchanges +#define mnmx6(a, b, c, d, e, f) s2(a, d); s2(b, e); s2(c, f); mn3(a, b, c); mx3(d, e, f); // 7 exchanges + + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + + +ivec2 window_size = textureSize(tex, 0); // Size of the window +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +/* +These shaders use a sorta hacky way to use the changing +window opacity you might set on picom.conf animation rules +to perform animations. + +Basically, when a window get's mapped, we make it's alpha +go from 0 to 1, so, using the default_post_processing to get that alpha +we can get a variable going from 0 (start of mapping animation) +to 1 (end of mapping animation) + +You can also set up your alpha value to go from 1 to 0 in picom when +a window is closed, effectively reversing the animations described here +*/ + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// If you have semitransparent windows (like a terminal) +// You can use the below function to add an opacity threshold where the +// animation won't apply. For example, if you had your terminal +// configured to have 0.8 opacity, you'd set the below variable to 0.8 +float max_opacity = 0.9; +float opacity_threshold(float opacity) +{ + // if statement jic? + if (opacity >= max_opacity) + { + return 1.0; + } + else + { + return min(1, opacity/max_opacity); + } + +} + +vec4 anim(float time) { +// block size shrinks from 40→1 + float block = mix(40.0, 1.0, time); + vec2 uvb = floor(texcoord / block) * block + block/2; + vec4 c = texelFetch(tex, ivec2(uvb), 0); + return c; +} + +// Default window shader: +// 1) fetch the specified pixel +// 2) apply default post-processing +vec4 window_shader() { + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + c = default_post_processing(c); + float opacity = opacity_threshold(c.w); + if (opacity != 1.0) + { + c = anim(opacity); + } + return default_post_processing(c); +} + diff --git a/config/picom/shaders/plane.glsl b/config/picom/shaders/plane.glsl new file mode 100644 index 0000000..b1c6885 --- /dev/null +++ b/config/picom/shaders/plane.glsl @@ -0,0 +1,266 @@ +#version 330 +#define PI 3.14159265 + +// These shaders work by using a pinhole camera and raycasting +// The window 3d objects will always be (somewhat) centered at (0, 0, 0) +struct pinhole_camera +{ + float focal_offset; // Distance along the Z axis between the camera + // center and the focal point. Use negative values + // so the image doesn't flip + // This kinda works like FOV in games + + // Transformations + // Use these to modify the coordinate system of the camera plane + vec3 rotations; // Rotations in radians around each axis + // The camera plane rotates around + // its center point, not the origin + + vec3 translations; // Translations in pixels along each axis + + vec3 deformations; // Deforms the camera. Higher values on each axis + // means the window will be squashed in that axis + + // ---------------------------------------------------------------// + + // "Aftervalues" + // These will be set later with setup_camera(), leave them as 0 + vec3 base_x; + vec3 base_y; + vec3 base_z; + vec3 center_point; + vec3 focal_point; +}; + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + + +uniform float time; // Time in miliseconds. + +float time_cyclic = mod(time/10000,2); // Like time, but in seconds and resets to + // 0 when it hits 2. Useful for using it in + // periodic functions like cos and sine +// Time variables can be used to change transformations over time + + +ivec2 window_size = textureSize(tex, 0); // Size of the window + +float window_diagonal = length(window_size); // Diagonal of the window +// Try to keep focal offset and translations proportional to window_size components +// or window_diagonal as you see fit + +pinhole_camera camera = +pinhole_camera(-window_size.y/2, // Focal offset + vec3(0,0,0), // Rotations + vec3(0), // Translations + vec3(1,1,1), // Deformations + // Leave the rest as 0 + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Here are some presets you can use + +// Moves the camera up and down +pinhole_camera bobbing = +pinhole_camera(-window_size.y/2, + vec3(0,0,0), + vec3(0,cos(time_cyclic*PI)*window_size.y/16,-window_size.y/4), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Rotates camera around the origin +// Makes the window rotate around the Y axis from the camera's POV +// (if the window is centered) +pinhole_camera rotate_around_origin = +pinhole_camera(-window_diagonal, + vec3(0,-time_cyclic*PI-PI/2,0), + vec3(cos(time_cyclic*PI)*window_diagonal, + 0, + sin(time_cyclic*PI)*window_diagonal), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Rotate camera around its center +pinhole_camera rotate_around_itself = +pinhole_camera(-window_diagonal, + vec3(0,-time_cyclic*PI-PI/2,0), + vec3(0,0,-window_diagonal), + vec3(1,1,1), + vec3(0), + vec3(0), + vec3(0), + vec3(0), + vec3(0)); + +// Here you can select the preset to use +pinhole_camera window_cam = rotate_around_origin; + + + +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// Sets up a camera by applying transformations and +// calculating xyz vector basis +pinhole_camera setup_camera(pinhole_camera camera) +{ + // Apply translations + camera.center_point += camera.translations; + + // Apply rotations + // We initialize our vector basis as normalized vectors + // in each axis * our deformations vector + camera.base_x = vec3(camera.deformations.x, 0, 0); + camera.base_y = vec3(0, camera.deformations.y, 0); + camera.base_z = vec3(0, 0, camera.deformations.z); + + + // Then we rotate them around following our rotations vector: + // First save these values to avoid redundancy + float cosx = cos(camera.rotations.x); + float cosy = cos(camera.rotations.y); + float cosz = cos(camera.rotations.z); + float sinx = sin(camera.rotations.x); + float siny = sin(camera.rotations.y); + float sinz = sin(camera.rotations.z); + + // Declare a buffer vector we will use to apply multiple changes at once + vec3 tmp = vec3(0); + + // Rotations for base_x: + tmp = camera.base_x; + // X axis: + tmp.y = camera.base_x.y * cosx - camera.base_x.z * sinx; + tmp.z = camera.base_x.y * sinx + camera.base_x.z * cosx; + camera.base_x = tmp; + // Y axis: + tmp.x = camera.base_x.x * cosy + camera.base_x.z * siny; + tmp.z = -camera.base_x.x * siny + camera.base_x.z * cosy; + camera.base_x = tmp; + // Z axis: + tmp.x = camera.base_x.x * cosz - camera.base_x.y * sinz; + tmp.y = camera.base_x.x * sinz + camera.base_x.y * cosz; + camera.base_x = tmp; + + // Rotations for base_y: + tmp = camera.base_y; + // X axis: + tmp.y = camera.base_y.y * cosx - camera.base_y.z * sinx; + tmp.z = camera.base_y.y * sinx + camera.base_y.z * cosx; + camera.base_y = tmp; + // Y axis: + tmp.x = camera.base_y.x * cosy + camera.base_y.z * siny; + tmp.z = -camera.base_y.x * siny + camera.base_y.z * cosy; + camera.base_y = tmp; + // Z axis: + tmp.x = camera.base_y.x * cosz - camera.base_y.y * sinz; + tmp.y = camera.base_y.x * sinz + camera.base_y.y * cosz; + camera.base_y = tmp; + + // Rotations for base_z: + tmp = camera.base_z; + // X axis: + tmp.y = camera.base_z.y * cosx - camera.base_z.z * sinx; + tmp.z = camera.base_z.y * sinx + camera.base_z.z * cosx; + camera.base_z = tmp; + // Y axis: + tmp.x = camera.base_z.x * cosy + camera.base_z.z * siny; + tmp.z = -camera.base_z.x * siny + camera.base_z.z * cosy; + camera.base_z = tmp; + // Z axis: + tmp.x = camera.base_z.x * cosz - camera.base_z.y * sinz; + tmp.y = camera.base_z.x * sinz + camera.base_z.y * cosz; + camera.base_z = tmp; + + // Now that we have our transformed 3d orthonormal base + // we can calculate our focal point + camera.focal_point = camera.center_point + camera.base_z * camera.focal_offset; + + // Return our set up camera + return camera; +} + +vec4 get_pixel_through_camera(vec2 coords, pinhole_camera camera) +{ + // Offset coords + coords -= window_center; + + // Find the pixel 3d position using the camera vector basis + vec3 pixel_3dposition = camera.center_point + + coords.x * camera.base_x + + coords.y * camera.base_y; + + // Get the vector going from the focal point to the pixel in 3d sapace + vec3 focal_vector = pixel_3dposition - camera.focal_point; + + // Let's say we have a plane for our window following the plane equation + // ax + by + cz = d + float a = 0; + float b = 0; + float c = 1; + float d = 0; + // Then there's a line going from our focal point to the plane + // which we can describe as: + // x(t) = focal_point.x + focal_vector.x * t + // y(t) = focal_point.y + focal_vector.y * t + // z(t) = focal_point.z + focal_vector.z * t + // We substitute x, y and z with x(t), y(t) and z(t) in our plane EQ + // Solving for t we get: + float t = (d + - a*camera.focal_point.x + - b*camera.focal_point.y + - c*camera.focal_point.z) + / (a*focal_vector.x + + b*focal_vector.y + + c*focal_vector.z); + + // If the point we end up in is behind our camera, don't "render" it + if (t < 1) + { + return vec4(0); + } + + // Then we multiply our focal vector by t and add our focal point to it + // to end up in a point inside the window plane + vec3 intersection = focal_vector * t + camera.focal_point; + + // Save x and y coordinates and add back our initial offset + vec2 cam_coords = intersection.xy + window_center; + + // If pixel is outside of our window region + // return a completely transparent color + if (cam_coords.x >=window_size.x-1 || + cam_coords.y >=window_size.y-1 || + cam_coords.x <=0 || cam_coords.y <=0) + { + return vec4(0); + } + + // Fetch the pixel + vec4 pixel = texelFetch(tex, ivec2(cam_coords), 0); + return pixel; +} + +vec4 window_shader() { + pinhole_camera transformed_cam = setup_camera(window_cam); + return(get_pixel_through_camera(texcoord, transformed_cam)); +} diff --git a/config/picom/shaders/sdf_mask.glsl b/config/picom/shaders/sdf_mask.glsl new file mode 100644 index 0000000..3e73770 --- /dev/null +++ b/config/picom/shaders/sdf_mask.glsl @@ -0,0 +1,131 @@ +#version 330 + +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + + +ivec2 window_size = textureSize(tex, 0); // Size of the window +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); + +/* +These shaders use a sorta hacky way to use the changing +window opacity you might set on picom.conf animation rules +to perform animations. + +Basically, when a window get's mapped, we make it's alpha +go from 0 to 1, so, using the default_post_processing to get that alpha +we can get a variable going from 0 (start of mapping animation) +to 1 (end of mapping animation) + +You can also set up your alpha value to go from 1 to 0 in picom when +a window is closed, effectively reversing the animations described here +*/ + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// If you have semitransparent windows (like a terminal) +// You can use the below function to add an opacity threshold where the +// animation won't apply. For example, if you had your terminal +// configured to have 0.8 opacity, you'd set the below variable to 0.8 +float max_opacity = 0.8; +float opacity_threshold(float opacity) +{ + // if statement jic? + if (opacity >= max_opacity) + { + return 1.0; + } + else + { + return min(1, opacity/max_opacity); + } + +} + +// NEW anim function: Morphing Distance-Field Mask (Wobbly Circle) +vec4 anim(float progress) { + + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + + // Early exit for fully transparent or fully opaque states + if (progress <= 0.001) { // Beginning of reveal / End of conceal + c.a = 0.0; + return c; + } + if (progress >= 0.999) { // End of reveal / Beginning of conceal + return c; // Original alpha, effect is complete + } + + vec2 p_centered = texcoord - vec2(window_center); // Pixel coords relative to center + + // --- SDF Parameters --- + // Max radius needed to cover the window from the center to a corner + float max_coverage_radius = length(vec2(window_size) * 0.5) * 1.05; // 5% margin + + // Easing for progress (e.g., ease-in: starts slow, speeds up) + float eased_progress = progress * progress; + // float eased_progress = sqrt(progress); // Alternative: ease-out + // float eased_progress = progress; // Alternative: linear + + float base_radius = eased_progress * max_coverage_radius; + + // --- Wobble Parameters --- + float angle = atan(p_centered.y, p_centered.x); // Angle of pixel from center + + float spatial_freq = 7.0; // Number of wobbles around circumference + float wobble_anim_speed = 10.0; // How fast wobbles change with progress + // Wobble amplitude (as a factor of base_radius), decreases as reveal completes + float wobble_amplitude_factor = 0.15 * (1.0 - eased_progress * 0.7); + + // Wobble animation phase based on progress + float wobble_phase = progress * wobble_anim_speed; + + float radius_offset = sin(angle * spatial_freq + wobble_phase) * + base_radius * wobble_amplitude_factor; + + float effective_radius = base_radius + radius_offset; + + // --- SDF Calculation (Circle) --- + // Distance from current pixel to the center of the coordinate system (p_centered) + float dist_from_center = length(p_centered); + // SDF value: negative inside the shape, positive outside + float sdf_value = dist_from_center - effective_radius; + + // --- Alpha Masking --- + float edge_softness = 15.0; // Softness of the mask edge in pixels + + // Create mask: 1.0 inside (visible), 0.0 outside (transparent) + // smoothstep transitions from 0 to 1 as sdf_value goes from 0 to edge_softness + // So, for sdf_value < 0 (inside), mask is 1.0. + // For sdf_value > edge_softness (far outside), mask is 0.0. + float mask = 1.0 - smoothstep(0.0, edge_softness, sdf_value); + + c.a *= mask; // Apply the mask to the original alpha + + return c; +} + +// Default window shader: +// 1) fetch the specified pixel +// 2) apply default post-processing +vec4 window_shader() { + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + c = default_post_processing(c); + float opacity = opacity_threshold(c.w); + if (opacity == 0.0) + { + return c; + } + vec4 anim_c = anim(opacity); + if (anim_c.w < max_opacity) + { + return vec4(0); + } + return default_post_processing(anim_c); +} diff --git a/config/picom/shaders/shiny.glsl b/config/picom/shaders/shiny.glsl new file mode 100644 index 0000000..16636ac --- /dev/null +++ b/config/picom/shaders/shiny.glsl @@ -0,0 +1,33 @@ +#version 430 + +// Source: https://github.com/yshui/picom/issues/295#issuecomment-592077997 + +in vec2 texcoord; + +uniform float opacity; +uniform bool invert_color; +uniform sampler2D tex; +uniform float time; + +ivec2 window_size = textureSize(tex, 0); + +float amt = 10000.0; + +vec4 default_post_processing(vec4 c); + +vec4 window_shader() { + float pct = mod(time, amt) / amt * 1000; + float factor = float(max(window_size.x, window_size.y)); + pct *= factor / 150.0; + vec2 pos = texcoord; + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + + if (pos.x + pos.y < pct * 4.0 && pos.x + pos.y > pct * 4.0 - .5 * pct + || pos.x + pos.y < pct * 4.0 - .8 * pct && pos.x + pos.y > pct * 3.0) + c *= vec4(2, 2, 2, 1); + if (invert_color) + c = vec4(vec3(c.a, c.a, c.a) - vec3(c), c.a); + + c *= opacity; + return default_post_processing(c); +} diff --git a/config/picom/shaders/terminal_vignette.glsl b/config/picom/shaders/terminal_vignette.glsl new file mode 100644 index 0000000..4e5aa21 --- /dev/null +++ b/config/picom/shaders/terminal_vignette.glsl @@ -0,0 +1,58 @@ +#version 330 +in vec2 texcoord; // texture coordinate of the fragment + +uniform sampler2D tex; // texture of the window + +ivec2 window_size = textureSize(tex, 0); // Size of the window +ivec2 window_center = ivec2(window_size.x/2, window_size.y/2); +uniform float shadow_cutoff = 1; // How "early" the shadow starts affecting + // pixels close to the edges + // I'd keep this value very close to 1 +uniform int shadow_intensity = 3; // Intensity level of the shadow effect (from 1 to 5) + + +// Default window post-processing: +// 1) invert color +// 2) opacity / transparency +// 3) max-brightness clamping +// 4) rounded corners +vec4 default_post_processing(vec4 c); + +// Darkens a pixels near the edges +vec4 calc_opacity(vec4 color, vec2 coords) +{ + // If shadow intensity is 0, change nothing + if (shadow_intensity == 0) + { + return color; + } + + // Get how far the coords are from the center + vec2 distances_from_center = abs(window_center - coords); + + // Darken pixels close to the edges of the screen in a polynomial fashion + float opacity = 1; + opacity *= -pow((distances_from_center.y/window_center.y)*shadow_cutoff, + (5/shadow_intensity)*2)+1; + opacity *= -pow((distances_from_center.x/window_center.x)*shadow_cutoff, + (5/shadow_intensity)*2)+1; + color.w *= opacity; + color.w = max(1 - color.w, 0.8); + + return color; +} + + +// Default window shader: +// 1) fetch the specified pixel +// 2) apply default post-processing +vec4 window_shader() { + vec4 c = texelFetch(tex, ivec2(texcoord), 0); + if (c.x +c.y + c.z < 0.6) + { + c.w = 1; + c = calc_opacity(c,texcoord); + } + + return default_post_processing(c); +} diff --git a/config/polybar/launch.sh b/config/polybar/launch.sh index f9ece03..71d5923 100755 --- a/config/polybar/launch.sh +++ b/config/polybar/launch.sh @@ -13,13 +13,26 @@ while pgrep -u $UID -x polybar >/dev/null; do sleep 0.1; done polybar -m | while read -r mon; do export MONITOR=$(echo $mon | cut -d: -f1) + width="$(echo $mon | cut -d' ' -f2 | cut -dx -f1)" + w=1920 + case "$width" in + 1920) w=1920 + ;; + 1080) w=1080 + ;; + 2560) w=2560 + ;; + *) w=1920 + esac + echo $mon | grep -q "(primary)" && { polybar ws & - polybar time2560 & - polybar right2560 & - polybar mpd2560 & + + polybar time$w & + polybar right$w & + polybar mpd$w & } || { polybar ws & - polybar time1080 & + polybar time$w & } done diff --git a/config/rofi/colors-rofi-dark.rasi b/config/rofi/colors.rasi index 3f3912c..3cd64c6 100644 --- a/config/rofi/colors-rofi-dark.rasi +++ b/config/rofi/colors.rasi @@ -13,11 +13,11 @@ alternate-urgent-background: @background2; alternate-urgent-foreground: @foreground; - selected-active-background: @foreground2; + selected-active-background: @foreground3; selected-active-foreground: @background; - selected-normal-background: @foreground2; + selected-normal-background: @foreground3; selected-normal-foreground: @background; - selected-urgent-background: @foreground2; + selected-urgent-background: @foreground3; selected-urgent-foreground: @background; text-color: @foreground; @@ -26,11 +26,13 @@ background-color: #00000000; background: #191919; background2: #191919; + background3: #282a2e; foreground: #fefefe; foreground2: #c5c8c6; - spacing: 2; + foreground3: #373b41; + spacing: 4; - font: "mononoki 12"; + font: "FiraMono Nerd Font 12"; } #window { @@ -61,7 +63,7 @@ #textbox-prompt-colon { expand: false; - str: ":"; + str: ""; margin: 0px 0.3em 0em 0em; text-color: @normal-foreground; } @@ -75,9 +77,14 @@ padding: 2px 0px 0px; } +element-text, element-icon { + background-color: inherit; + text-color: inherit; +} + #element { border: 0; - padding: 1px; + padding: 6px; } #element.normal.normal { diff --git a/config/rofi/config.rasi b/config/rofi/config.rasi index 315524e..a241986 100644 --- a/config/rofi/config.rasi +++ b/config/rofi/config.rasi @@ -149,5 +149,5 @@ configuration { /* me-accept-entry: "MouseDPrimary";*/ /* me-accept-custom: "Control+MouseDPrimary";*/ } -@theme "colors-rofi-dark" +@theme "colors" diff --git a/config/rofi/launcher.rasi b/config/rofi/launcher.rasi new file mode 100644 index 0000000..9dd7cd9 --- /dev/null +++ b/config/rofi/launcher.rasi @@ -0,0 +1,174 @@ +/** + * + * Author : Aditya Shakya (adi1090x) + * Github : @adi1090x + * + * Rofi Theme File + * Rofi Version: 1.7.3 + **/ + +/*****----- Configuration -----*****/ +configuration { + modi: "drun"; + show-icons: true; + display-drun: ""; + drun-display-format: "{name}"; +} + +/*****----- Global Properties -----*****/ +@import "colors.rasi" + +/*****----- Main Window -----*****/ +window { + transparency: "real"; + location: center; + anchor: center; + fullscreen: false; + width: 1000px; + x-offset: 0px; + y-offset: 0px; + + enabled: true; + margin: 0px; + padding: 0px; + border: 0px solid; + border-radius: 0px; + border-color: @selected; + background-color: @background; + cursor: "default"; +} + +/*****----- Main Box -----*****/ +mainbox { + enabled: true; + spacing: 20px; + margin: 0px; + padding: 40px; + border: 0px solid; + border-radius: 0px 0px 0px 0px; + border-color: @selected; + background-color: transparent; + children: [ "inputbar", "listview" ]; +} + +/*****----- Inputbar -----*****/ +inputbar { + enabled: true; + spacing: 10px; + margin: 0px 500px 0px 0px; + padding: 12px; + border: 0px 0px 0px 4px; + border-radius: 0px 100% 100% 0px; + border-color: @selected; + background-color: @background-alt; + text-color: @foreground; + children: [ "prompt", "entry" ]; +} + +prompt { + enabled: true; + background-color: inherit; + text-color: inherit; +} +textbox-prompt-colon { + enabled: true; + expand: false; + str: "::"; + background-color: inherit; + text-color: inherit; +} +entry { + enabled: true; + background-color: inherit; + text-color: inherit; + cursor: text; + placeholder: "Search"; + placeholder-color: inherit; +} + +/*****----- Listview -----*****/ +listview { + enabled: true; + columns: 7; + lines: 3; + cycle: true; + dynamic: true; + scrollbar: false; + layout: vertical; + reverse: false; + fixed-height: true; + fixed-columns: true; + + spacing: 10px; + margin: 0px; + padding: 0px; + border: 0px solid; + border-radius: 0px; + border-color: @selected; + background-color: transparent; + text-color: @foreground; + cursor: "default"; +} +scrollbar { + handle-width: 5px ; + handle-color: @selected; + border-radius: 0px; + background-color: @background-alt; +} + +/*****----- Elements -----*****/ +element { + enabled: true; + spacing: 10px; + margin: 0px; + padding: 15px 10px; + border: 0px solid; + border-radius: 0px; + border-color: @selected; + background-color: transparent; + text-color: @foreground; + orientation: vertical; + cursor: pointer; +} +element normal.normal { + background-color: transparent; + text-color: @foreground; +} +element selected.normal { + border: 0px 0px 0px 4px; + border-radius: 0px; + border-color: @selected; + background-color: @background-alt; + text-color: @foreground; +} +element-icon { + background-color: transparent; + text-color: inherit; + size: 64px; + cursor: inherit; +} +element-text { + background-color: transparent; + text-color: inherit; + highlight: inherit; + cursor: inherit; + vertical-align: 0.5; + horizontal-align: 0.5; +} + +/*****----- Message -----*****/ +error-message { + padding: 40px; + border: 0px solid; + border-radius: 0px; + border-color: @selected; + background-color: black / 10%; + text-color: @foreground; +} +textbox { + background-color: transparent; + text-color: @foreground; + vertical-align: 0.5; + horizontal-align: 0.0; + highlight: none; +} diff --git a/config/sxhkd/sxhkdrc b/config/sxhkd/sxhkdrc index f9ef280..6c41e61 100644 --- a/config/sxhkd/sxhkdrc +++ b/config/sxhkd/sxhkdrc @@ -11,11 +11,14 @@ super + ctrl + alt + f #Volume Control {XF86AudioLowerVolume,super + Next} - amixer -D pulse sset Master 5%- + pactl set-sink-volume @DEFAULT_SINK@ -5% {XF86AudioRaiseVolume,super + Prior} - amixer -D pulse sset Master 5%+ + pactl set-sink-volume @DEFAULT_SINK@ +5% {XF86AudioMute} - amixer -D pulse set Master 1+ toggle + pactl set-sink-mute @DEFAULT_SINK@ toggle + +super + alt + ctrl + button{4,5} + pactl set-sink-volume @DEFAULT_SINK@ {+,-}1% {_, super} + XF86MonBrightnessDown light -U {10,1} @@ -25,12 +28,12 @@ super + ctrl + alt + f super + r - rofi -show drun -show-icons + $HOME/.scripts/launcher super + shift + r rofi -show ssh -show-icons -super + ctrl + Tab +super + alt + Tab rofi -show window super + g @@ -75,6 +78,10 @@ super + i super + semicolon bspc rule -a \* -o state=floating && $TERMINAL -e pulsemixer +# xrandr switcher +super + apostrophe + $HOME/.scripts/xrandr.sh + # xkill ctrl + alt + Escape xkill @@ -109,15 +116,16 @@ super + ctrl + c # stuff super + ctrl + m - dmenu -p "i am stuff" | xargs /usr/bin/stuff + dmenu -p "i am stuff" | xargs /usr/local/bin/stuff super + ctrl + n - dmenu -p "i am big chungus" | xargs /usr/bin/chungus + dmenu -p "i am big chungus" | xargs /usr/local/bin/chungus + +super + ctrl + b + dmenu -p "eminem says" | xargs /usr/bin/local/eminem super + ctrl + t dmenu -p "toilet" | toilet --font mono12 | sed 's/ /_ _ /g' | xclip -selection clipboard -super + ctrl + b - dmenu -p "eminem says" | xargs /usr/bin/eminem # iocane super + shift + Return diff --git a/config/vim/vimrc b/config/vim/vimrc index b348907..f8258d1 100644 --- a/config/vim/vimrc +++ b/config/vim/vimrc @@ -1,4 +1,4 @@ -set viminfo+=n~/.config/vim/viminfo +"set viminfo+=~/.config/vim/viminfo set runtimepath+=~/.config/vim,~/.config/vim/after set autoindent set wrap @@ -111,11 +111,22 @@ endfunction autocmd FileType python let b:coc_root_patterns = ['.git', '.env', '.'] +Plug 'junegunn/fzf', { 'dir': '~/.fzf', 'do': './install --all' } Plug 'junegunn/fzf.vim' + +let g:fzf_cache_dir = '$HOME/.cache' + +Plug 'yuki-yano/fzf-preview.vim' +Plug 'BurntSushi/ripgrep' + nnoremap <F6> :Files<CR> nnoremap <F7> :Rg<CR> +nnoremap <F8> :Tags<CR> + +nnoremap g] :call fzf#vim#tags(expand('<cword>'))<CR> +nnoremap <silent> <Leader>ag :Ag <C-R><C-W><CR> Plug 'heavenshell/vim-pydocstring', { 'do': 'make install', 'for': 'python' } @@ -123,9 +134,9 @@ Plug 'tpope/vim-fugitive' Plug 'yggdroot/indentline' -Plug 'yuttie/comfortable-motion.vim' -noremap <silent> <ScrollWheelDown> :call comfortable_motion#flick(40)<CR> -noremap <silent> <ScrollWheelUp> :call comfortable_motion#flick(-40)<CR> +"Plug 'yuttie/comfortable-motion.vim' +"noremap <silent> <ScrollWheelDown> :call comfortable_motion#flick(40)<CR> +"noremap <silent> <ScrollWheelUp> :call comfortable_motion#flick(-40)<CR> let g:comfortable_motion_interval = 2000.0/60 let g:comfortable_motion_friction = 80.0 @@ -141,3 +152,97 @@ highlight Pmenu ctermbg=black guibg=black ctermfg=white hi TrailingWhitespace ctermbg=red guibg=red call matchadd("TrailingWhitespace", '\v\s+$') + +" ex command for toggling hex mode - define mapping if desired +command -bar Hexmode call ToggleHex() + +" helper function to toggle hex mode +function ToggleHex() + " hex mode should be considered a read-only operation + " save values for modified and read-only for restoration later, + " and clear the read-only flag for now + let l:modified=&mod + let l:oldreadonly=&readonly + let &readonly=0 + let l:oldmodifiable=&modifiable + let &modifiable=1 + if !exists("b:editHex") || !b:editHex + " save old options + let b:oldft=&ft + let b:oldbin=&bin + " set new options + setlocal binary " make sure it overrides any textwidth, etc. + silent :e " this will reload the file without trickeries + "(DOS line endings will be shown entirely ) + let &ft="xxd" + " set status + let b:editHex=1 + " switch to hex editor + %!xxd + else + " restore old options + let &ft=b:oldft + if !b:oldbin + setlocal nobinary + endif + " set status + let b:editHex=0 + " return to normal editing + %!xxd -r + endif + " restore values for modified and read only state + let &mod=l:modified + let &readonly=l:oldreadonly + let &modifiable=l:oldmodifiable +endfunction + +" autocmds to automatically enter hex mode and handle file writes properly +if has("autocmd") + " vim -b : edit binary using xxd-format! + augroup Binary + au! + + " set binary option for all binary files before reading them + au BufReadPre *.bin,*.hex setlocal binary + + " if on a fresh read the buffer variable is already set, it's wrong + au BufReadPost * + \ if exists('b:editHex') && b:editHex | + \ let b:editHex = 0 | + \ endif + + " convert to hex on startup for binary files automatically + au BufReadPost * + \ if &binary | Hexmode | endif + + " When the text is freed, the next time the buffer is made active it will + " re-read the text and thus not match the correct mode, we will need to + " convert it again if the buffer is again loaded. + au BufUnload * + \ if getbufvar(expand("<afile>"), 'editHex') == 1 | + \ call setbufvar(expand("<afile>"), 'editHex', 0) | + \ endif + + " before writing a file when editing in hex mode, convert back to non-hex + au BufWritePre * + \ if exists("b:editHex") && b:editHex && &binary | + \ let oldro=&ro | let &ro=0 | + \ let oldma=&ma | let &ma=1 | + \ silent exe "%!xxd -r" | + \ let &ma=oldma | let &ro=oldro | + \ unlet oldma | unlet oldro | + \ endif + + " after writing a binary file, if we're in hex mode, restore hex mode + au BufWritePost * + \ if exists("b:editHex") && b:editHex && &binary | + \ let oldro=&ro | let &ro=0 | + \ let oldma=&ma | let &ma=1 | + \ silent exe "%!xxd" | + \ exe "set nomod" | + \ let &ma=oldma | let &ro=oldro | + \ unlet oldma | unlet oldro | + \ endif + augroup END +endif + @@ -1,6 +1,6 @@ #!/bin/sh -configurations="iocane bg bg.gif bspwm cava neofetch mpd mpv ncmpcpp vim sxhkd polybar compfy rofi user-dirs.dirs gtk-3.0 zathura sx mimeapps.list" +configurations="iocane bg bg.gif bspwm cava neofetch mpd mpv ncmpcpp vim sxhkd polybar compfy rofi user-dirs.dirs gtk-3.0 zathura sx mimeapps.list picom" save () { @@ -1,6 +1,6 @@ gtk-theme-name="vimix-vski" gtk-icon-theme-name="Vimix-dark" -gtk-font-name="mononoki 10" +gtk-font-name="FiraMono Nerd Font 10" gtk-cursor-theme-name="pixelfun3" gtk-cursor-theme-size=24 gtk-toolbar-style=GTK_TOOLBAR_ICONS @@ -7,7 +7,7 @@ esac export VIMINIT="source ~/.config/vim/vimrc" export NVIMINIT="source ~/.config/vim/vimrc" -HISTFILE="$HOME/.mksh_history" +HISTFILE="/tmp/.mksh_history$$" HISTSIZE=5000 if [ -x /usr/bin/dircolors ]; then @@ -55,4 +55,4 @@ parse_git_dirty() { bind '^L=clear-screen' -export PS1="[0;97m\${PWD/#\$HOME/\~}[0;37m\`parse_git_branch\` > [0;0m" +export PS1="[0;97m\${PWD/#\$HOME/\~}[0;37m\`parse_git_branch\` > [3 q[0;0m" @@ -11,7 +11,7 @@ alias editor=vim export TERMINAL="st" export BROWSER="/usr/bin/firefox" export FILE_MANAGER="/usr/bin/thunar" -export EMAIL_CLIENT="/usr/bin/claws-mail" +export EMAIL_CLIENT="/usr/bin/thunderbird" export EDITOR="/usr/bin/vim" export JAVA_HOME=/usr/lib/jvm/java-19-openjdk/ diff --git a/scripts/launcher b/scripts/launcher new file mode 100755 index 0000000..85b679d --- /dev/null +++ b/scripts/launcher @@ -0,0 +1,8 @@ +#!/bin/sh + +rasi="$HOME/.config/rofi/launcher.rasi" + +## Run +rofi \ + -show drun \ + -theme $rasi diff --git a/scripts/mpc_picker b/scripts/mpc_picker index 3758b0a..0477d46 100755 --- a/scripts/mpc_picker +++ b/scripts/mpc_picker @@ -1,6 +1,29 @@ -#!/bin/sh -selected=$(mpc -f "%title%[\t\t%artist%][\t\t%album%]\t\t%file%" listall | dmenu -i -p mpd) -[ "$selected" == "" ] && exit -file=$(printf "%s\n" "$selected" | rev | cut -f1 -d' ' | rev) -echo "$file" -mpc insert "$file" +#!/usr/bin/dash +format="<b>%title%</b>\t%artist%\t%album%\t%file%" + +columns="$(mpc -f "$format" listall \ + | column -t -s' ' \ + -C title,width=10,trunc \ + -C artist,width=10,trunc \ + -C album,width=10,trunc \ + -C file \ + | sed 's/&/&/g' +)" + +np=$(printf "%s" "$columns" | grep "$(mpc -f '%title%' current)" | head -1) +echo "$np" +selected=$( + printf "%s" "$columns" | rofi -dmenu -i \ + -multi-select \ + -markup-rows \ + -p " " \ + -ballot-selected-str " " \ + -ballot-unselected-str " " \ + -select "$np" + ) +[ -z "$selected" ] && exit +echo "$selected" | while read -r option; do + file=$(printf "%s\n" "$option" | awk -F' ' '{print $NF}' | sed 's/^\s*//g') + echo ${file} + mpc insert "$file" +done diff --git a/scripts/toggle-mic.sh b/scripts/toggle-mic.sh new file mode 100755 index 0000000..d3e3244 --- /dev/null +++ b/scripts/toggle-mic.sh @@ -0,0 +1,4 @@ +#!/bin/sh +SOURCE=1 +pactl list sources | grep -qi 'Mute: yes' && pactl set-source-mute $SOURCE false || pactl set-source-mute $SOURCE true + diff --git a/scripts/xrandr.sh b/scripts/xrandr.sh new file mode 100755 index 0000000..1827cd7 --- /dev/null +++ b/scripts/xrandr.sh @@ -0,0 +1,35 @@ +#!/bin/sh +all=$(xrandr | grep "connected" | cut -d' ' -f1 | paste -s -d' ') +available=$(xrandr | grep " connected" | cut -d' ' -f1 | paste -s -d' ') +set -- $available + +printf "connected: " +printf "%s " $available +printf "\n" + +printf "all: " +printf "%s " $all +printf "\n" + +if [ "$1" == "eDP1" ]; then + # this is a laptop so awesome! + + if [ "$#" != "1" ]; then + # ensure the main one is turned on yeah + xrandr --output eDP1 --mode 1920x1080 --pos 0x0 --rotate normal + + # put the non main one to the left (assume its +1920 because im lazy) + xrandr --output "$2" --primary --mode 2560x1440 --pos 1920x0 --rotate normal + else + # ensure the main one is turned on yeah + xrandr --output eDP1 --primary --mode 1920x1080 --pos 0x0 --rotate normal + fi + #disconnect all the rest i think + for x in $all; do + echo disconnecting $x + case $available in + *"$x"*) ;; + *) xrandr --output "$x" --off + esac + done +fi diff --git a/st/davidovski.patch b/st/davidovski.patch index f991439..a847eb1 100644 --- a/st/davidovski.patch +++ b/st/davidovski.patch @@ -32,428 +32,8 @@ index 15db421..bc75c1d 100644 + rm -f $(DESTDIR)$(PREFIX)/share/applications/st.desktop .PHONY: all clean dist install uninstall -diff --git a/boxdraw.c b/boxdraw.c -new file mode 100644 -index 0000000..28a92d0 ---- /dev/null -+++ b/boxdraw.c -@@ -0,0 +1,194 @@ -+/* -+ * Copyright 2018 Avi Halachmi (:avih) avihpit@yahoo.com https://github.com/avih -+ * MIT/X Consortium License -+ */ -+ -+#include <X11/Xft/Xft.h> -+#include "st.h" -+#include "boxdraw_data.h" -+ -+/* Rounded non-negative integers division of n / d */ -+#define DIV(n, d) (((n) + (d) / 2) / (d)) -+ -+static Display *xdpy; -+static Colormap xcmap; -+static XftDraw *xd; -+static Visual *xvis; -+ -+static void drawbox(int, int, int, int, XftColor *, XftColor *, ushort); -+static void drawboxlines(int, int, int, int, XftColor *, ushort); -+ -+/* public API */ -+ -+void -+boxdraw_xinit(Display *dpy, Colormap cmap, XftDraw *draw, Visual *vis) -+{ -+ xdpy = dpy; xcmap = cmap; xd = draw, xvis = vis; -+} -+ -+int -+isboxdraw(Rune u) -+{ -+ Rune block = u & ~0xff; -+ return (boxdraw && block == 0x2500 && boxdata[(uint8_t)u]) || -+ (boxdraw_braille && block == 0x2800); -+} -+ -+/* the "index" is actually the entire shape data encoded as ushort */ -+ushort -+boxdrawindex(const Glyph *g) -+{ -+ if (boxdraw_braille && (g->u & ~0xff) == 0x2800) -+ return BRL | (uint8_t)g->u; -+ if (boxdraw_bold && (g->mode & ATTR_BOLD)) -+ return BDB | boxdata[(uint8_t)g->u]; -+ return boxdata[(uint8_t)g->u]; -+} -+ -+void -+drawboxes(int x, int y, int cw, int ch, XftColor *fg, XftColor *bg, -+ const XftGlyphFontSpec *specs, int len) -+{ -+ for ( ; len-- > 0; x += cw, specs++) -+ drawbox(x, y, cw, ch, fg, bg, (ushort)specs->glyph); -+} -+ -+/* implementation */ -+ -+void -+drawbox(int x, int y, int w, int h, XftColor *fg, XftColor *bg, ushort bd) -+{ -+ ushort cat = bd & ~(BDB | 0xff); /* mask out bold and data */ -+ if (bd & (BDL | BDA)) { -+ /* lines (light/double/heavy/arcs) */ -+ drawboxlines(x, y, w, h, fg, bd); -+ -+ } else if (cat == BBD) { -+ /* lower (8-X)/8 block */ -+ int d = DIV((uint8_t)bd * h, 8); -+ XftDrawRect(xd, fg, x, y + d, w, h - d); -+ -+ } else if (cat == BBU) { -+ /* upper X/8 block */ -+ XftDrawRect(xd, fg, x, y, w, DIV((uint8_t)bd * h, 8)); -+ -+ } else if (cat == BBL) { -+ /* left X/8 block */ -+ XftDrawRect(xd, fg, x, y, DIV((uint8_t)bd * w, 8), h); -+ -+ } else if (cat == BBR) { -+ /* right (8-X)/8 block */ -+ int d = DIV((uint8_t)bd * w, 8); -+ XftDrawRect(xd, fg, x + d, y, w - d, h); -+ -+ } else if (cat == BBQ) { -+ /* Quadrants */ -+ int w2 = DIV(w, 2), h2 = DIV(h, 2); -+ if (bd & TL) -+ XftDrawRect(xd, fg, x, y, w2, h2); -+ if (bd & TR) -+ XftDrawRect(xd, fg, x + w2, y, w - w2, h2); -+ if (bd & BL) -+ XftDrawRect(xd, fg, x, y + h2, w2, h - h2); -+ if (bd & BR) -+ XftDrawRect(xd, fg, x + w2, y + h2, w - w2, h - h2); -+ -+ } else if (bd & BBS) { -+ /* Shades - data is 1/2/3 for 25%/50%/75% alpha, respectively */ -+ int d = (uint8_t)bd; -+ XftColor xfc; -+ XRenderColor xrc = { .alpha = 0xffff }; -+ -+ xrc.red = DIV(fg->color.red * d + bg->color.red * (4 - d), 4); -+ xrc.green = DIV(fg->color.green * d + bg->color.green * (4 - d), 4); -+ xrc.blue = DIV(fg->color.blue * d + bg->color.blue * (4 - d), 4); -+ -+ XftColorAllocValue(xdpy, xvis, xcmap, &xrc, &xfc); -+ XftDrawRect(xd, &xfc, x, y, w, h); -+ XftColorFree(xdpy, xvis, xcmap, &xfc); -+ -+ } else if (cat == BRL) { -+ /* braille, each data bit corresponds to one dot at 2x4 grid */ -+ int w1 = DIV(w, 2); -+ int h1 = DIV(h, 4), h2 = DIV(h, 2), h3 = DIV(3 * h, 4); -+ -+ if (bd & 1) XftDrawRect(xd, fg, x, y, w1, h1); -+ if (bd & 2) XftDrawRect(xd, fg, x, y + h1, w1, h2 - h1); -+ if (bd & 4) XftDrawRect(xd, fg, x, y + h2, w1, h3 - h2); -+ if (bd & 8) XftDrawRect(xd, fg, x + w1, y, w - w1, h1); -+ if (bd & 16) XftDrawRect(xd, fg, x + w1, y + h1, w - w1, h2 - h1); -+ if (bd & 32) XftDrawRect(xd, fg, x + w1, y + h2, w - w1, h3 - h2); -+ if (bd & 64) XftDrawRect(xd, fg, x, y + h3, w1, h - h3); -+ if (bd & 128) XftDrawRect(xd, fg, x + w1, y + h3, w - w1, h - h3); -+ -+ } -+} -+ -+void -+drawboxlines(int x, int y, int w, int h, XftColor *fg, ushort bd) -+{ -+ /* s: stem thickness. width/8 roughly matches underscore thickness. */ -+ /* We draw bold as 1.5 * normal-stem and at least 1px thicker. */ -+ /* doubles draw at least 3px, even when w or h < 3. bold needs 6px. */ -+ int mwh = MIN(w, h); -+ int base_s = MAX(1, DIV(mwh, 8)); -+ int bold = (bd & BDB) && mwh >= 6; /* possibly ignore boldness */ -+ int s = bold ? MAX(base_s + 1, DIV(3 * base_s, 2)) : base_s; -+ int w2 = DIV(w - s, 2), h2 = DIV(h - s, 2); -+ /* the s-by-s square (x + w2, y + h2, s, s) is the center texel. */ -+ /* The base length (per direction till edge) includes this square. */ -+ -+ int light = bd & (LL | LU | LR | LD); -+ int double_ = bd & (DL | DU | DR | DD); -+ -+ if (light) { -+ /* d: additional (negative) length to not-draw the center */ -+ /* texel - at arcs and avoid drawing inside (some) doubles */ -+ int arc = bd & BDA; -+ int multi_light = light & (light - 1); -+ int multi_double = double_ & (double_ - 1); -+ /* light crosses double only at DH+LV, DV+LH (ref. shapes) */ -+ int d = arc || (multi_double && !multi_light) ? -s : 0; -+ -+ if (bd & LL) -+ XftDrawRect(xd, fg, x, y + h2, w2 + s + d, s); -+ if (bd & LU) -+ XftDrawRect(xd, fg, x + w2, y, s, h2 + s + d); -+ if (bd & LR) -+ XftDrawRect(xd, fg, x + w2 - d, y + h2, w - w2 + d, s); -+ if (bd & LD) -+ XftDrawRect(xd, fg, x + w2, y + h2 - d, s, h - h2 + d); -+ } -+ -+ /* double lines - also align with light to form heavy when combined */ -+ if (double_) { -+ /* -+ * going clockwise, for each double-ray: p is additional length -+ * to the single-ray nearer to the previous direction, and n to -+ * the next. p and n adjust from the base length to lengths -+ * which consider other doubles - shorter to avoid intersections -+ * (p, n), or longer to draw the far-corner texel (n). -+ */ -+ int dl = bd & DL, du = bd & DU, dr = bd & DR, dd = bd & DD; -+ if (dl) { -+ int p = dd ? -s : 0, n = du ? -s : dd ? s : 0; -+ XftDrawRect(xd, fg, x, y + h2 + s, w2 + s + p, s); -+ XftDrawRect(xd, fg, x, y + h2 - s, w2 + s + n, s); -+ } -+ if (du) { -+ int p = dl ? -s : 0, n = dr ? -s : dl ? s : 0; -+ XftDrawRect(xd, fg, x + w2 - s, y, s, h2 + s + p); -+ XftDrawRect(xd, fg, x + w2 + s, y, s, h2 + s + n); -+ } -+ if (dr) { -+ int p = du ? -s : 0, n = dd ? -s : du ? s : 0; -+ XftDrawRect(xd, fg, x + w2 - p, y + h2 - s, w - w2 + p, s); -+ XftDrawRect(xd, fg, x + w2 - n, y + h2 + s, w - w2 + n, s); -+ } -+ if (dd) { -+ int p = dr ? -s : 0, n = dl ? -s : dr ? s : 0; -+ XftDrawRect(xd, fg, x + w2 + s, y + h2 - p, s, h - h2 + p); -+ XftDrawRect(xd, fg, x + w2 - s, y + h2 - n, s, h - h2 + n); -+ } -+ } -+} -diff --git a/boxdraw_data.h b/boxdraw_data.h -new file mode 100644 -index 0000000..7890500 ---- /dev/null -+++ b/boxdraw_data.h -@@ -0,0 +1,214 @@ -+/* -+ * Copyright 2018 Avi Halachmi (:avih) avihpit@yahoo.com https://github.com/avih -+ * MIT/X Consortium License -+ */ -+ -+/* -+ * U+25XX codepoints data -+ * -+ * References: -+ * http://www.unicode.org/charts/PDF/U2500.pdf -+ * http://www.unicode.org/charts/PDF/U2580.pdf -+ * -+ * Test page: -+ * https://github.com/GNOME/vte/blob/master/doc/boxes.txt -+ */ -+ -+/* Each shape is encoded as 16-bits. Higher bits are category, lower are data */ -+/* Categories (mutually exclusive except BDB): */ -+/* For convenience, BDL/BDA/BBS/BDB are 1 bit each, the rest are enums */ -+#define BDL (1<<8) /* Box Draw Lines (light/double/heavy) */ -+#define BDA (1<<9) /* Box Draw Arc (light) */ -+ -+#define BBD (1<<10) /* Box Block Down (lower) X/8 */ -+#define BBL (2<<10) /* Box Block Left X/8 */ -+#define BBU (3<<10) /* Box Block Upper X/8 */ -+#define BBR (4<<10) /* Box Block Right X/8 */ -+#define BBQ (5<<10) /* Box Block Quadrants */ -+#define BRL (6<<10) /* Box Braille (data is lower byte of U28XX) */ -+ -+#define BBS (1<<14) /* Box Block Shades */ -+#define BDB (1<<15) /* Box Draw is Bold */ -+ -+/* (BDL/BDA) Light/Double/Heavy x Left/Up/Right/Down/Horizontal/Vertical */ -+/* Heavy is light+double (literally drawing light+double align to form heavy) */ -+#define LL (1<<0) -+#define LU (1<<1) -+#define LR (1<<2) -+#define LD (1<<3) -+#define LH (LL+LR) -+#define LV (LU+LD) -+ -+#define DL (1<<4) -+#define DU (1<<5) -+#define DR (1<<6) -+#define DD (1<<7) -+#define DH (DL+DR) -+#define DV (DU+DD) -+ -+#define HL (LL+DL) -+#define HU (LU+DU) -+#define HR (LR+DR) -+#define HD (LD+DD) -+#define HH (HL+HR) -+#define HV (HU+HD) -+ -+/* (BBQ) Quadrants Top/Bottom x Left/Right */ -+#define TL (1<<0) -+#define TR (1<<1) -+#define BL (1<<2) -+#define BR (1<<3) -+ -+/* Data for U+2500 - U+259F except dashes/diagonals */ -+static const unsigned short boxdata[256] = { -+ /* light lines */ -+ [0x00] = BDL + LH, /* light horizontal */ -+ [0x02] = BDL + LV, /* light vertical */ -+ [0x0c] = BDL + LD + LR, /* light down and right */ -+ [0x10] = BDL + LD + LL, /* light down and left */ -+ [0x14] = BDL + LU + LR, /* light up and right */ -+ [0x18] = BDL + LU + LL, /* light up and left */ -+ [0x1c] = BDL + LV + LR, /* light vertical and right */ -+ [0x24] = BDL + LV + LL, /* light vertical and left */ -+ [0x2c] = BDL + LH + LD, /* light horizontal and down */ -+ [0x34] = BDL + LH + LU, /* light horizontal and up */ -+ [0x3c] = BDL + LV + LH, /* light vertical and horizontal */ -+ [0x74] = BDL + LL, /* light left */ -+ [0x75] = BDL + LU, /* light up */ -+ [0x76] = BDL + LR, /* light right */ -+ [0x77] = BDL + LD, /* light down */ -+ -+ /* heavy [+light] lines */ -+ [0x01] = BDL + HH, -+ [0x03] = BDL + HV, -+ [0x0d] = BDL + HR + LD, -+ [0x0e] = BDL + HD + LR, -+ [0x0f] = BDL + HD + HR, -+ [0x11] = BDL + HL + LD, -+ [0x12] = BDL + HD + LL, -+ [0x13] = BDL + HD + HL, -+ [0x15] = BDL + HR + LU, -+ [0x16] = BDL + HU + LR, -+ [0x17] = BDL + HU + HR, -+ [0x19] = BDL + HL + LU, -+ [0x1a] = BDL + HU + LL, -+ [0x1b] = BDL + HU + HL, -+ [0x1d] = BDL + HR + LV, -+ [0x1e] = BDL + HU + LD + LR, -+ [0x1f] = BDL + HD + LR + LU, -+ [0x20] = BDL + HV + LR, -+ [0x21] = BDL + HU + HR + LD, -+ [0x22] = BDL + HD + HR + LU, -+ [0x23] = BDL + HV + HR, -+ [0x25] = BDL + HL + LV, -+ [0x26] = BDL + HU + LD + LL, -+ [0x27] = BDL + HD + LU + LL, -+ [0x28] = BDL + HV + LL, -+ [0x29] = BDL + HU + HL + LD, -+ [0x2a] = BDL + HD + HL + LU, -+ [0x2b] = BDL + HV + HL, -+ [0x2d] = BDL + HL + LD + LR, -+ [0x2e] = BDL + HR + LL + LD, -+ [0x2f] = BDL + HH + LD, -+ [0x30] = BDL + HD + LH, -+ [0x31] = BDL + HD + HL + LR, -+ [0x32] = BDL + HR + HD + LL, -+ [0x33] = BDL + HH + HD, -+ [0x35] = BDL + HL + LU + LR, -+ [0x36] = BDL + HR + LU + LL, -+ [0x37] = BDL + HH + LU, -+ [0x38] = BDL + HU + LH, -+ [0x39] = BDL + HU + HL + LR, -+ [0x3a] = BDL + HU + HR + LL, -+ [0x3b] = BDL + HH + HU, -+ [0x3d] = BDL + HL + LV + LR, -+ [0x3e] = BDL + HR + LV + LL, -+ [0x3f] = BDL + HH + LV, -+ [0x40] = BDL + HU + LH + LD, -+ [0x41] = BDL + HD + LH + LU, -+ [0x42] = BDL + HV + LH, -+ [0x43] = BDL + HU + HL + LD + LR, -+ [0x44] = BDL + HU + HR + LD + LL, -+ [0x45] = BDL + HD + HL + LU + LR, -+ [0x46] = BDL + HD + HR + LU + LL, -+ [0x47] = BDL + HH + HU + LD, -+ [0x48] = BDL + HH + HD + LU, -+ [0x49] = BDL + HV + HL + LR, -+ [0x4a] = BDL + HV + HR + LL, -+ [0x4b] = BDL + HV + HH, -+ [0x78] = BDL + HL, -+ [0x79] = BDL + HU, -+ [0x7a] = BDL + HR, -+ [0x7b] = BDL + HD, -+ [0x7c] = BDL + HR + LL, -+ [0x7d] = BDL + HD + LU, -+ [0x7e] = BDL + HL + LR, -+ [0x7f] = BDL + HU + LD, -+ -+ /* double [+light] lines */ -+ [0x50] = BDL + DH, -+ [0x51] = BDL + DV, -+ [0x52] = BDL + DR + LD, -+ [0x53] = BDL + DD + LR, -+ [0x54] = BDL + DR + DD, -+ [0x55] = BDL + DL + LD, -+ [0x56] = BDL + DD + LL, -+ [0x57] = BDL + DL + DD, -+ [0x58] = BDL + DR + LU, -+ [0x59] = BDL + DU + LR, -+ [0x5a] = BDL + DU + DR, -+ [0x5b] = BDL + DL + LU, -+ [0x5c] = BDL + DU + LL, -+ [0x5d] = BDL + DL + DU, -+ [0x5e] = BDL + DR + LV, -+ [0x5f] = BDL + DV + LR, -+ [0x60] = BDL + DV + DR, -+ [0x61] = BDL + DL + LV, -+ [0x62] = BDL + DV + LL, -+ [0x63] = BDL + DV + DL, -+ [0x64] = BDL + DH + LD, -+ [0x65] = BDL + DD + LH, -+ [0x66] = BDL + DD + DH, -+ [0x67] = BDL + DH + LU, -+ [0x68] = BDL + DU + LH, -+ [0x69] = BDL + DH + DU, -+ [0x6a] = BDL + DH + LV, -+ [0x6b] = BDL + DV + LH, -+ [0x6c] = BDL + DH + DV, -+ -+ /* (light) arcs */ -+ [0x6d] = BDA + LD + LR, -+ [0x6e] = BDA + LD + LL, -+ [0x6f] = BDA + LU + LL, -+ [0x70] = BDA + LU + LR, -+ -+ /* Lower (Down) X/8 block (data is 8 - X) */ -+ [0x81] = BBD + 7, [0x82] = BBD + 6, [0x83] = BBD + 5, [0x84] = BBD + 4, -+ [0x85] = BBD + 3, [0x86] = BBD + 2, [0x87] = BBD + 1, [0x88] = BBD + 0, -+ -+ /* Left X/8 block (data is X) */ -+ [0x89] = BBL + 7, [0x8a] = BBL + 6, [0x8b] = BBL + 5, [0x8c] = BBL + 4, -+ [0x8d] = BBL + 3, [0x8e] = BBL + 2, [0x8f] = BBL + 1, -+ -+ /* upper 1/2 (4/8), 1/8 block (X), right 1/2, 1/8 block (8-X) */ -+ [0x80] = BBU + 4, [0x94] = BBU + 1, -+ [0x90] = BBR + 4, [0x95] = BBR + 7, -+ -+ /* Quadrants */ -+ [0x96] = BBQ + BL, -+ [0x97] = BBQ + BR, -+ [0x98] = BBQ + TL, -+ [0x99] = BBQ + TL + BL + BR, -+ [0x9a] = BBQ + TL + BR, -+ [0x9b] = BBQ + TL + TR + BL, -+ [0x9c] = BBQ + TL + TR + BR, -+ [0x9d] = BBQ + TR, -+ [0x9e] = BBQ + BL + TR, -+ [0x9f] = BBQ + BL + TR + BR, -+ -+ /* Shades, data is an alpha value in 25% units (1/4, 1/2, 3/4) */ -+ [0x91] = BBS + 1, [0x92] = BBS + 2, [0x93] = BBS + 3, -+ -+ /* U+2504 - U+250B, U+254C - U+254F: unsupported (dashes) */ -+ /* U+2571 - U+2573: unsupported (diagonals) */ -+}; diff --git a/config.def.h b/config.def.h -index 91ab8ca..805e09d 100644 +index 91ab8ca..5904cb6 100644 --- a/config.def.h +++ b/config.def.h @@ -5,7 +5,13 @@ @@ -500,7 +80,34 @@ index 91ab8ca..805e09d 100644 /* Terminal colors (16 first used in escape sequence) */ static const char *colorname[] = { /* 8 normal colors */ -@@ -170,12 +191,50 @@ static unsigned int defaultattr = 11; +@@ -135,13 +156,20 @@ unsigned int defaultcs = 256; + static unsigned int defaultrcs = 257; + + /* +- * Default shape of cursor +- * 2: Block ("█") +- * 4: Underline ("_") +- * 6: Bar ("|") +- * 7: Snowman ("☃") ++ * https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h4-Functions-using-CSI-_-ordered-by-the-final-character-lparen-s-rparen:CSI-Ps-SP-q.1D81 ++ * Default style of cursor ++ * 0: blinking block ++ * 1: blinking block (default) ++ * 2: steady block ("█") ++ * 3: blinking underline ++ * 4: steady underline ("_") ++ * 5: blinking bar ++ * 6: steady bar ("|") ++ * 7: blinking st cursor ++ * 8: steady st cursor + */ +-static unsigned int cursorshape = 2; ++static unsigned int cursorstyle = 1; ++static Rune stcursor = 0x2603; /* snowman ("☃") */ + + /* + * Default columns and rows numbers +@@ -170,12 +198,50 @@ static unsigned int defaultattr = 11; */ static uint forcemousemod = ShiftMask; @@ -551,7 +158,7 @@ index 91ab8ca..805e09d 100644 { XK_ANY_MOD, Button2, selpaste, {.i = 0}, 1 }, { ShiftMask, Button4, ttysend, {.s = "\033[5;2~"} }, { XK_ANY_MOD, Button4, ttysend, {.s = "\031"} }, -@@ -201,6 +260,8 @@ static Shortcut shortcuts[] = { +@@ -201,6 +267,8 @@ static Shortcut shortcuts[] = { { TERMMOD, XK_Y, selpaste, {.i = 0} }, { ShiftMask, XK_Insert, selpaste, {.i = 0} }, { TERMMOD, XK_Num_Lock, numlock, {.i = 0} }, @@ -560,548 +167,6 @@ index 91ab8ca..805e09d 100644 }; /* -diff --git a/config.h b/config.h -new file mode 100644 -index 0000000..206c72d ---- /dev/null -+++ b/config.h -@@ -0,0 +1,536 @@ -+/* See LICENSE file for copyright and license details. */ -+ -+/* -+ * appearance -+ * -+ * font: see http://freedesktop.org/software/fontconfig/fontconfig-user.html -+ */ -+static char *font = "Liberation Mono:pixelsize=10:antialias=true:autohint=true"; -+/* Spare fonts */ -+static char *font2[] = { -+/* "Inconsolata for Powerline:pixelsize=12:antialias=true:autohint=true", */ -+/* "Hack Nerd Font Mono:pixelsize=11:antialias=true:autohint=true", */ -+}; -+ -+static int borderpx = 2; -+ -+/* -+ * What program is execed by st depends of these precedence rules: -+ * 1: program passed with -e -+ * 2: scroll and/or utmp -+ * 3: SHELL environment variable -+ * 4: value of shell in /etc/passwd -+ * 5: value of shell in config.h -+ */ -+static char *shell = "/bin/sh"; -+char *utmp = NULL; -+/* scroll program: to enable use a string like "scroll" */ -+char *scroll = NULL; -+char *stty_args = "stty raw pass8 nl -echo -iexten -cstopb 38400"; -+ -+/* identification sequence returned in DA and DECID */ -+char *vtiden = "\033[?6c"; -+ -+/* Kerning / character bounding-box multipliers */ -+static float cwscale = 1.0; -+static float chscale = 1.0; -+ -+/* -+ * word delimiter string -+ * -+ * More advanced example: L" `'\"()[]{}" -+ */ -+wchar_t *worddelimiters = L" "; -+ -+/* selection timeouts (in milliseconds) */ -+static unsigned int doubleclicktimeout = 300; -+static unsigned int tripleclicktimeout = 600; -+ -+/* alt screens */ -+int allowaltscreen = 1; -+ -+/* allow certain non-interactive (insecure) window operations such as: -+ setting the clipboard text */ -+int allowwindowops = 0; -+ -+/* -+ * draw latency range in ms - from new content/keypress/etc until drawing. -+ * within this range, st draws when content stops arriving (idle). mostly it's -+ * near minlatency, but it waits longer for slow updates to avoid partial draw. -+ * low minlatency will tear/flicker more, as it can "detect" idle too early. -+ */ -+static double minlatency = 8; -+static double maxlatency = 33; -+ -+/* -+ * blinking timeout (set to 0 to disable blinking) for the terminal blinking -+ * attribute. -+ */ -+static unsigned int blinktimeout = 800; -+ -+/* -+ * thickness of underline and bar cursors -+ */ -+static unsigned int cursorthickness = 2; -+ -+/* -+ * 1: render most of the lines/blocks characters without using the font for -+ * perfect alignment between cells (U2500 - U259F except dashes/diagonals). -+ * Bold affects lines thickness if boxdraw_bold is not 0. Italic is ignored. -+ * 0: disable (render all U25XX glyphs normally from the font). -+ */ -+const int boxdraw = 0; -+const int boxdraw_bold = 0; -+ -+/* braille (U28XX): 1: render as adjacent "pixels", 0: use font */ -+const int boxdraw_braille = 0; -+ -+/* -+ * bell volume. It must be a value between -100 and 100. Use 0 for disabling -+ * it -+ */ -+static int bellvolume = 0; -+ -+/* default TERM value */ -+char *termname = "st-256color"; -+ -+/* -+ * spaces per tab -+ * -+ * When you are changing this value, don't forget to adapt the »it« value in -+ * the st.info and appropriately install the st.info in the environment where -+ * you use this st version. -+ * -+ * it#$tabspaces, -+ * -+ * Secondly make sure your kernel is not expanding tabs. When running `stty -+ * -a` »tab0« should appear. You can tell the terminal to not expand tabs by -+ * running following command: -+ * -+ * stty tabs -+ */ -+unsigned int tabspaces = 8; -+ -+/* Terminal colors (16 first used in escape sequence) */ -+static const char *colorname[] = { -+ /* 8 normal colors */ -+ "black", -+ "red3", -+ "green3", -+ "yellow3", -+ "blue2", -+ "magenta3", -+ "cyan3", -+ "gray90", -+ -+ /* 8 bright colors */ -+ "gray50", -+ "red", -+ "green", -+ "yellow", -+ "#5c5cff", -+ "magenta", -+ "cyan", -+ "white", -+ -+ [255] = 0, -+ -+ /* more colors can be added after 255 to use with DefaultXX */ -+ "#cccccc", -+ "#555555", -+ "gray90", /* default foreground colour */ -+ "black", /* default background colour */ -+}; -+ -+ -+/* -+ * Default colors (colorname index) -+ * foreground, background, cursor, reverse cursor -+ */ -+unsigned int defaultfg = 258; -+unsigned int defaultbg = 259; -+unsigned int defaultcs = 256; -+static unsigned int defaultrcs = 257; -+ -+/* -+ * Default alpha -+ */ -+float alpha = 0.75; -+/* -+ * Default shape of cursor -+ * 2: Block ("█") -+ * 4: Underline ("_") -+ * 6: Bar ("|") -+ * 7: Snowman ("☃") -+ */ -+static unsigned int cursorshape = 2; -+ -+/* -+ * Default columns and rows numbers -+ */ -+ -+static unsigned int cols = 80; -+static unsigned int rows = 24; -+ -+/* -+ * Default colour and shape of the mouse cursor -+ */ -+static unsigned int mouseshape = XC_xterm; -+static unsigned int mousefg = 7; -+static unsigned int mousebg = 0; -+ -+/* -+ * Color used to display font attributes when fontconfig selected a font which -+ * doesn't match the ones requested. -+ */ -+static unsigned int defaultattr = 11; -+ -+/* -+ * Force mouse select/shortcuts while mask is active (when MODE_MOUSE is set). -+ * Note that if you want to use ShiftMask with selmasks, set this to an other -+ * modifier, set to 0 to not use it. -+ */ -+static uint forcemousemod = ShiftMask; -+ -+/* -+ * Xresources preferences to load at startup -+ */ -+ResourcePref resources[] = { -+ { "font", STRING, &font }, -+ { "color0", STRING, &colorname[0] }, -+ { "color1", STRING, &colorname[1] }, -+ { "color2", STRING, &colorname[2] }, -+ { "color3", STRING, &colorname[3] }, -+ { "color4", STRING, &colorname[4] }, -+ { "color5", STRING, &colorname[5] }, -+ { "color6", STRING, &colorname[6] }, -+ { "color7", STRING, &colorname[7] }, -+ { "color8", STRING, &colorname[8] }, -+ { "color9", STRING, &colorname[9] }, -+ { "color10", STRING, &colorname[10] }, -+ { "color11", STRING, &colorname[11] }, -+ { "color12", STRING, &colorname[12] }, -+ { "color13", STRING, &colorname[13] }, -+ { "color14", STRING, &colorname[14] }, -+ { "color15", STRING, &colorname[15] }, -+ { "background", STRING, &colorname[259] }, -+ { "foreground", STRING, &colorname[258] }, -+ { "cursorColor", STRING, &colorname[256] }, -+ { "termname", STRING, &termname }, -+ { "shell", STRING, &shell }, -+ { "minlatency", INTEGER, &minlatency }, -+ { "maxlatency", INTEGER, &maxlatency }, -+ { "blinktimeout", INTEGER, &blinktimeout }, -+ { "bellvolume", INTEGER, &bellvolume }, -+ { "tabspaces", INTEGER, &tabspaces }, -+ { "borderpx", INTEGER, &borderpx }, -+ { "cwscale", FLOAT, &cwscale }, -+ { "chscale", FLOAT, &chscale }, -+}; -+ -+/* -+ * Internal mouse shortcuts. -+ * Beware that overloading Button1 will disable the selection. -+ */ -+static MouseShortcut mshortcuts[] = { -+ /* mask button function argument release */ -+ { XK_ANY_MOD, Button4, kscrollup, {.i = 5} }, -+ { XK_ANY_MOD, Button5, kscrolldown, {.i = 5} }, -+ { XK_ANY_MOD, Button2, selpaste, {.i = 0}, 1 }, -+ { ShiftMask, Button4, ttysend, {.s = "\033[5;2~"} }, -+ { XK_ANY_MOD, Button4, ttysend, {.s = "\031"} }, -+ { ShiftMask, Button5, ttysend, {.s = "\033[6;2~"} }, -+ { XK_ANY_MOD, Button5, ttysend, {.s = "\005"} }, -+}; -+ -+/* Internal keyboard shortcuts. */ -+#define MODKEY Mod1Mask -+#define TERMMOD (ControlMask|ShiftMask) -+ -+static Shortcut shortcuts[] = { -+ /* mask keysym function argument */ -+ { XK_ANY_MOD, XK_Break, sendbreak, {.i = 0} }, -+ { ControlMask, XK_Print, toggleprinter, {.i = 0} }, -+ { ShiftMask, XK_Print, printscreen, {.i = 0} }, -+ { XK_ANY_MOD, XK_Print, printsel, {.i = 0} }, -+ { TERMMOD, XK_Prior, zoom, {.f = +1} }, -+ { TERMMOD, XK_Next, zoom, {.f = -1} }, -+ { TERMMOD, XK_Home, zoomreset, {.f = 0} }, -+ { TERMMOD, XK_C, clipcopy, {.i = 0} }, -+ { TERMMOD, XK_V, clippaste, {.i = 0} }, -+ { TERMMOD, XK_Y, selpaste, {.i = 0} }, -+ { ShiftMask, XK_Insert, selpaste, {.i = 0} }, -+ { TERMMOD, XK_Num_Lock, numlock, {.i = 0} }, -+ { ShiftMask, XK_Page_Up, kscrollup, {.i = -1} }, -+ { ShiftMask, XK_Page_Down, kscrolldown, {.i = -1} }, -+}; -+ -+/* -+ * Special keys (change & recompile st.info accordingly) -+ * -+ * Mask value: -+ * * Use XK_ANY_MOD to match the key no matter modifiers state -+ * * Use XK_NO_MOD to match the key alone (no modifiers) -+ * appkey value: -+ * * 0: no value -+ * * > 0: keypad application mode enabled -+ * * = 2: term.numlock = 1 -+ * * < 0: keypad application mode disabled -+ * appcursor value: -+ * * 0: no value -+ * * > 0: cursor application mode enabled -+ * * < 0: cursor application mode disabled -+ * -+ * Be careful with the order of the definitions because st searches in -+ * this table sequentially, so any XK_ANY_MOD must be in the last -+ * position for a key. -+ */ -+ -+/* -+ * If you want keys other than the X11 function keys (0xFD00 - 0xFFFF) -+ * to be mapped below, add them to this array. -+ */ -+static KeySym mappedkeys[] = { -1 }; -+ -+/* -+ * State bits to ignore when matching key or button events. By default, -+ * numlock (Mod2Mask) and keyboard layout (XK_SWITCH_MOD) are ignored. -+ */ -+static uint ignoremod = Mod2Mask|XK_SWITCH_MOD; -+ -+/* -+ * This is the huge key array which defines all compatibility to the Linux -+ * world. Please decide about changes wisely. -+ */ -+static Key key[] = { -+ /* keysym mask string appkey appcursor */ -+ { XK_KP_Home, ShiftMask, "\033[2J", 0, -1}, -+ { XK_KP_Home, ShiftMask, "\033[1;2H", 0, +1}, -+ { XK_KP_Home, XK_ANY_MOD, "\033[H", 0, -1}, -+ { XK_KP_Home, XK_ANY_MOD, "\033[1~", 0, +1}, -+ { XK_KP_Up, XK_ANY_MOD, "\033Ox", +1, 0}, -+ { XK_KP_Up, XK_ANY_MOD, "\033[A", 0, -1}, -+ { XK_KP_Up, XK_ANY_MOD, "\033OA", 0, +1}, -+ { XK_KP_Down, XK_ANY_MOD, "\033Or", +1, 0}, -+ { XK_KP_Down, XK_ANY_MOD, "\033[B", 0, -1}, -+ { XK_KP_Down, XK_ANY_MOD, "\033OB", 0, +1}, -+ { XK_KP_Left, XK_ANY_MOD, "\033Ot", +1, 0}, -+ { XK_KP_Left, XK_ANY_MOD, "\033[D", 0, -1}, -+ { XK_KP_Left, XK_ANY_MOD, "\033OD", 0, +1}, -+ { XK_KP_Right, XK_ANY_MOD, "\033Ov", +1, 0}, -+ { XK_KP_Right, XK_ANY_MOD, "\033[C", 0, -1}, -+ { XK_KP_Right, XK_ANY_MOD, "\033OC", 0, +1}, -+ { XK_KP_Prior, ShiftMask, "\033[5;2~", 0, 0}, -+ { XK_KP_Prior, XK_ANY_MOD, "\033[5~", 0, 0}, -+ { XK_KP_Begin, XK_ANY_MOD, "\033[E", 0, 0}, -+ { XK_KP_End, ControlMask, "\033[J", -1, 0}, -+ { XK_KP_End, ControlMask, "\033[1;5F", +1, 0}, -+ { XK_KP_End, ShiftMask, "\033[K", -1, 0}, -+ { XK_KP_End, ShiftMask, "\033[1;2F", +1, 0}, -+ { XK_KP_End, XK_ANY_MOD, "\033[4~", 0, 0}, -+ { XK_KP_Next, ShiftMask, "\033[6;2~", 0, 0}, -+ { XK_KP_Next, XK_ANY_MOD, "\033[6~", 0, 0}, -+ { XK_KP_Insert, ShiftMask, "\033[2;2~", +1, 0}, -+ { XK_KP_Insert, ShiftMask, "\033[4l", -1, 0}, -+ { XK_KP_Insert, ControlMask, "\033[L", -1, 0}, -+ { XK_KP_Insert, ControlMask, "\033[2;5~", +1, 0}, -+ { XK_KP_Insert, XK_ANY_MOD, "\033[4h", -1, 0}, -+ { XK_KP_Insert, XK_ANY_MOD, "\033[2~", +1, 0}, -+ { XK_KP_Delete, ControlMask, "\033[M", -1, 0}, -+ { XK_KP_Delete, ControlMask, "\033[3;5~", +1, 0}, -+ { XK_KP_Delete, ShiftMask, "\033[2K", -1, 0}, -+ { XK_KP_Delete, ShiftMask, "\033[3;2~", +1, 0}, -+ { XK_KP_Delete, XK_ANY_MOD, "\033[P", -1, 0}, -+ { XK_KP_Delete, XK_ANY_MOD, "\033[3~", +1, 0}, -+ { XK_KP_Multiply, XK_ANY_MOD, "\033Oj", +2, 0}, -+ { XK_KP_Add, XK_ANY_MOD, "\033Ok", +2, 0}, -+ { XK_KP_Enter, XK_ANY_MOD, "\033OM", +2, 0}, -+ { XK_KP_Enter, XK_ANY_MOD, "\r", -1, 0}, -+ { XK_KP_Subtract, XK_ANY_MOD, "\033Om", +2, 0}, -+ { XK_KP_Decimal, XK_ANY_MOD, "\033On", +2, 0}, -+ { XK_KP_Divide, XK_ANY_MOD, "\033Oo", +2, 0}, -+ { XK_KP_0, XK_ANY_MOD, "\033Op", +2, 0}, -+ { XK_KP_1, XK_ANY_MOD, "\033Oq", +2, 0}, -+ { XK_KP_2, XK_ANY_MOD, "\033Or", +2, 0}, -+ { XK_KP_3, XK_ANY_MOD, "\033Os", +2, 0}, -+ { XK_KP_4, XK_ANY_MOD, "\033Ot", +2, 0}, -+ { XK_KP_5, XK_ANY_MOD, "\033Ou", +2, 0}, -+ { XK_KP_6, XK_ANY_MOD, "\033Ov", +2, 0}, -+ { XK_KP_7, XK_ANY_MOD, "\033Ow", +2, 0}, -+ { XK_KP_8, XK_ANY_MOD, "\033Ox", +2, 0}, -+ { XK_KP_9, XK_ANY_MOD, "\033Oy", +2, 0}, -+ { XK_Up, ShiftMask, "\033[1;2A", 0, 0}, -+ { XK_Up, Mod1Mask, "\033[1;3A", 0, 0}, -+ { XK_Up, ShiftMask|Mod1Mask,"\033[1;4A", 0, 0}, -+ { XK_Up, ControlMask, "\033[1;5A", 0, 0}, -+ { XK_Up, ShiftMask|ControlMask,"\033[1;6A", 0, 0}, -+ { XK_Up, ControlMask|Mod1Mask,"\033[1;7A", 0, 0}, -+ { XK_Up,ShiftMask|ControlMask|Mod1Mask,"\033[1;8A", 0, 0}, -+ { XK_Up, XK_ANY_MOD, "\033[A", 0, -1}, -+ { XK_Up, XK_ANY_MOD, "\033OA", 0, +1}, -+ { XK_Down, ShiftMask, "\033[1;2B", 0, 0}, -+ { XK_Down, Mod1Mask, "\033[1;3B", 0, 0}, -+ { XK_Down, ShiftMask|Mod1Mask,"\033[1;4B", 0, 0}, -+ { XK_Down, ControlMask, "\033[1;5B", 0, 0}, -+ { XK_Down, ShiftMask|ControlMask,"\033[1;6B", 0, 0}, -+ { XK_Down, ControlMask|Mod1Mask,"\033[1;7B", 0, 0}, -+ { XK_Down,ShiftMask|ControlMask|Mod1Mask,"\033[1;8B",0, 0}, -+ { XK_Down, XK_ANY_MOD, "\033[B", 0, -1}, -+ { XK_Down, XK_ANY_MOD, "\033OB", 0, +1}, -+ { XK_Left, ShiftMask, "\033[1;2D", 0, 0}, -+ { XK_Left, Mod1Mask, "\033[1;3D", 0, 0}, -+ { XK_Left, ShiftMask|Mod1Mask,"\033[1;4D", 0, 0}, -+ { XK_Left, ControlMask, "\033[1;5D", 0, 0}, -+ { XK_Left, ShiftMask|ControlMask,"\033[1;6D", 0, 0}, -+ { XK_Left, ControlMask|Mod1Mask,"\033[1;7D", 0, 0}, -+ { XK_Left,ShiftMask|ControlMask|Mod1Mask,"\033[1;8D",0, 0}, -+ { XK_Left, XK_ANY_MOD, "\033[D", 0, -1}, -+ { XK_Left, XK_ANY_MOD, "\033OD", 0, +1}, -+ { XK_Right, ShiftMask, "\033[1;2C", 0, 0}, -+ { XK_Right, Mod1Mask, "\033[1;3C", 0, 0}, -+ { XK_Right, ShiftMask|Mod1Mask,"\033[1;4C", 0, 0}, -+ { XK_Right, ControlMask, "\033[1;5C", 0, 0}, -+ { XK_Right, ShiftMask|ControlMask,"\033[1;6C", 0, 0}, -+ { XK_Right, ControlMask|Mod1Mask,"\033[1;7C", 0, 0}, -+ { XK_Right,ShiftMask|ControlMask|Mod1Mask,"\033[1;8C",0, 0}, -+ { XK_Right, XK_ANY_MOD, "\033[C", 0, -1}, -+ { XK_Right, XK_ANY_MOD, "\033OC", 0, +1}, -+ { XK_ISO_Left_Tab, ShiftMask, "\033[Z", 0, 0}, -+ { XK_Return, Mod1Mask, "\033\r", 0, 0}, -+ { XK_Return, XK_ANY_MOD, "\r", 0, 0}, -+ { XK_Insert, ShiftMask, "\033[4l", -1, 0}, -+ { XK_Insert, ShiftMask, "\033[2;2~", +1, 0}, -+ { XK_Insert, ControlMask, "\033[L", -1, 0}, -+ { XK_Insert, ControlMask, "\033[2;5~", +1, 0}, -+ { XK_Insert, XK_ANY_MOD, "\033[4h", -1, 0}, -+ { XK_Insert, XK_ANY_MOD, "\033[2~", +1, 0}, -+ { XK_Delete, ControlMask, "\033[M", -1, 0}, -+ { XK_Delete, ControlMask, "\033[3;5~", +1, 0}, -+ { XK_Delete, ShiftMask, "\033[2K", -1, 0}, -+ { XK_Delete, ShiftMask, "\033[3;2~", +1, 0}, -+ { XK_Delete, XK_ANY_MOD, "\033[P", -1, 0}, -+ { XK_Delete, XK_ANY_MOD, "\033[3~", +1, 0}, -+ { XK_BackSpace, XK_NO_MOD, "\177", 0, 0}, -+ { XK_BackSpace, Mod1Mask, "\033\177", 0, 0}, -+ { XK_Home, ShiftMask, "\033[2J", 0, -1}, -+ { XK_Home, ShiftMask, "\033[1;2H", 0, +1}, -+ { XK_Home, XK_ANY_MOD, "\033[H", 0, -1}, -+ { XK_Home, XK_ANY_MOD, "\033[1~", 0, +1}, -+ { XK_End, ControlMask, "\033[J", -1, 0}, -+ { XK_End, ControlMask, "\033[1;5F", +1, 0}, -+ { XK_End, ShiftMask, "\033[K", -1, 0}, -+ { XK_End, ShiftMask, "\033[1;2F", +1, 0}, -+ { XK_End, XK_ANY_MOD, "\033[4~", 0, 0}, -+ { XK_Prior, ControlMask, "\033[5;5~", 0, 0}, -+ { XK_Prior, ShiftMask, "\033[5;2~", 0, 0}, -+ { XK_Prior, XK_ANY_MOD, "\033[5~", 0, 0}, -+ { XK_Next, ControlMask, "\033[6;5~", 0, 0}, -+ { XK_Next, ShiftMask, "\033[6;2~", 0, 0}, -+ { XK_Next, XK_ANY_MOD, "\033[6~", 0, 0}, -+ { XK_F1, XK_NO_MOD, "\033OP" , 0, 0}, -+ { XK_F1, /* F13 */ ShiftMask, "\033[1;2P", 0, 0}, -+ { XK_F1, /* F25 */ ControlMask, "\033[1;5P", 0, 0}, -+ { XK_F1, /* F37 */ Mod4Mask, "\033[1;6P", 0, 0}, -+ { XK_F1, /* F49 */ Mod1Mask, "\033[1;3P", 0, 0}, -+ { XK_F1, /* F61 */ Mod3Mask, "\033[1;4P", 0, 0}, -+ { XK_F2, XK_NO_MOD, "\033OQ" , 0, 0}, -+ { XK_F2, /* F14 */ ShiftMask, "\033[1;2Q", 0, 0}, -+ { XK_F2, /* F26 */ ControlMask, "\033[1;5Q", 0, 0}, -+ { XK_F2, /* F38 */ Mod4Mask, "\033[1;6Q", 0, 0}, -+ { XK_F2, /* F50 */ Mod1Mask, "\033[1;3Q", 0, 0}, -+ { XK_F2, /* F62 */ Mod3Mask, "\033[1;4Q", 0, 0}, -+ { XK_F3, XK_NO_MOD, "\033OR" , 0, 0}, -+ { XK_F3, /* F15 */ ShiftMask, "\033[1;2R", 0, 0}, -+ { XK_F3, /* F27 */ ControlMask, "\033[1;5R", 0, 0}, -+ { XK_F3, /* F39 */ Mod4Mask, "\033[1;6R", 0, 0}, -+ { XK_F3, /* F51 */ Mod1Mask, "\033[1;3R", 0, 0}, -+ { XK_F3, /* F63 */ Mod3Mask, "\033[1;4R", 0, 0}, -+ { XK_F4, XK_NO_MOD, "\033OS" , 0, 0}, -+ { XK_F4, /* F16 */ ShiftMask, "\033[1;2S", 0, 0}, -+ { XK_F4, /* F28 */ ControlMask, "\033[1;5S", 0, 0}, -+ { XK_F4, /* F40 */ Mod4Mask, "\033[1;6S", 0, 0}, -+ { XK_F4, /* F52 */ Mod1Mask, "\033[1;3S", 0, 0}, -+ { XK_F5, XK_NO_MOD, "\033[15~", 0, 0}, -+ { XK_F5, /* F17 */ ShiftMask, "\033[15;2~", 0, 0}, -+ { XK_F5, /* F29 */ ControlMask, "\033[15;5~", 0, 0}, -+ { XK_F5, /* F41 */ Mod4Mask, "\033[15;6~", 0, 0}, -+ { XK_F5, /* F53 */ Mod1Mask, "\033[15;3~", 0, 0}, -+ { XK_F6, XK_NO_MOD, "\033[17~", 0, 0}, -+ { XK_F6, /* F18 */ ShiftMask, "\033[17;2~", 0, 0}, -+ { XK_F6, /* F30 */ ControlMask, "\033[17;5~", 0, 0}, -+ { XK_F6, /* F42 */ Mod4Mask, "\033[17;6~", 0, 0}, -+ { XK_F6, /* F54 */ Mod1Mask, "\033[17;3~", 0, 0}, -+ { XK_F7, XK_NO_MOD, "\033[18~", 0, 0}, -+ { XK_F7, /* F19 */ ShiftMask, "\033[18;2~", 0, 0}, -+ { XK_F7, /* F31 */ ControlMask, "\033[18;5~", 0, 0}, -+ { XK_F7, /* F43 */ Mod4Mask, "\033[18;6~", 0, 0}, -+ { XK_F7, /* F55 */ Mod1Mask, "\033[18;3~", 0, 0}, -+ { XK_F8, XK_NO_MOD, "\033[19~", 0, 0}, -+ { XK_F8, /* F20 */ ShiftMask, "\033[19;2~", 0, 0}, -+ { XK_F8, /* F32 */ ControlMask, "\033[19;5~", 0, 0}, -+ { XK_F8, /* F44 */ Mod4Mask, "\033[19;6~", 0, 0}, -+ { XK_F8, /* F56 */ Mod1Mask, "\033[19;3~", 0, 0}, -+ { XK_F9, XK_NO_MOD, "\033[20~", 0, 0}, -+ { XK_F9, /* F21 */ ShiftMask, "\033[20;2~", 0, 0}, -+ { XK_F9, /* F33 */ ControlMask, "\033[20;5~", 0, 0}, -+ { XK_F9, /* F45 */ Mod4Mask, "\033[20;6~", 0, 0}, -+ { XK_F9, /* F57 */ Mod1Mask, "\033[20;3~", 0, 0}, -+ { XK_F10, XK_NO_MOD, "\033[21~", 0, 0}, -+ { XK_F10, /* F22 */ ShiftMask, "\033[21;2~", 0, 0}, -+ { XK_F10, /* F34 */ ControlMask, "\033[21;5~", 0, 0}, -+ { XK_F10, /* F46 */ Mod4Mask, "\033[21;6~", 0, 0}, -+ { XK_F10, /* F58 */ Mod1Mask, "\033[21;3~", 0, 0}, -+ { XK_F11, XK_NO_MOD, "\033[23~", 0, 0}, -+ { XK_F11, /* F23 */ ShiftMask, "\033[23;2~", 0, 0}, -+ { XK_F11, /* F35 */ ControlMask, "\033[23;5~", 0, 0}, -+ { XK_F11, /* F47 */ Mod4Mask, "\033[23;6~", 0, 0}, -+ { XK_F11, /* F59 */ Mod1Mask, "\033[23;3~", 0, 0}, -+ { XK_F12, XK_NO_MOD, "\033[24~", 0, 0}, -+ { XK_F12, /* F24 */ ShiftMask, "\033[24;2~", 0, 0}, -+ { XK_F12, /* F36 */ ControlMask, "\033[24;5~", 0, 0}, -+ { XK_F12, /* F48 */ Mod4Mask, "\033[24;6~", 0, 0}, -+ { XK_F12, /* F60 */ Mod1Mask, "\033[24;3~", 0, 0}, -+ { XK_F13, XK_NO_MOD, "\033[1;2P", 0, 0}, -+ { XK_F14, XK_NO_MOD, "\033[1;2Q", 0, 0}, -+ { XK_F15, XK_NO_MOD, "\033[1;2R", 0, 0}, -+ { XK_F16, XK_NO_MOD, "\033[1;2S", 0, 0}, -+ { XK_F17, XK_NO_MOD, "\033[15;2~", 0, 0}, -+ { XK_F18, XK_NO_MOD, "\033[17;2~", 0, 0}, -+ { XK_F19, XK_NO_MOD, "\033[18;2~", 0, 0}, -+ { XK_F20, XK_NO_MOD, "\033[19;2~", 0, 0}, -+ { XK_F21, XK_NO_MOD, "\033[20;2~", 0, 0}, -+ { XK_F22, XK_NO_MOD, "\033[21;2~", 0, 0}, -+ { XK_F23, XK_NO_MOD, "\033[23;2~", 0, 0}, -+ { XK_F24, XK_NO_MOD, "\033[24;2~", 0, 0}, -+ { XK_F25, XK_NO_MOD, "\033[1;5P", 0, 0}, -+ { XK_F26, XK_NO_MOD, "\033[1;5Q", 0, 0}, -+ { XK_F27, XK_NO_MOD, "\033[1;5R", 0, 0}, -+ { XK_F28, XK_NO_MOD, "\033[1;5S", 0, 0}, -+ { XK_F29, XK_NO_MOD, "\033[15;5~", 0, 0}, -+ { XK_F30, XK_NO_MOD, "\033[17;5~", 0, 0}, -+ { XK_F31, XK_NO_MOD, "\033[18;5~", 0, 0}, -+ { XK_F32, XK_NO_MOD, "\033[19;5~", 0, 0}, -+ { XK_F33, XK_NO_MOD, "\033[20;5~", 0, 0}, -+ { XK_F34, XK_NO_MOD, "\033[21;5~", 0, 0}, -+ { XK_F35, XK_NO_MOD, "\033[23;5~", 0, 0}, -+}; -+ -+/* -+ * Selection types' masks. -+ * Use the same masks as usual. -+ * Button1Mask is always unset, to make masks match between ButtonPress. -+ * ButtonRelease and MotionNotify. -+ * If no match is found, regular selection is used. -+ */ -+static uint selmasks[] = { -+ [SEL_RECTANGULAR] = Mod1Mask, -+}; -+ -+/* -+ * Printable characters in ASCII, used to estimate the advance width -+ * of single wide characters. -+ */ -+static char ascii_printable[] = -+ " !\"#$%&'()*+,-./0123456789:;<=>?" -+ "@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_" -+ "`abcdefghijklmnopqrstuvwxyz{|}~"; diff --git a/config.mk b/config.mk index 1e306f8..47c615e 100644 --- a/config.mk @@ -1116,7 +181,7 @@ index 1e306f8..47c615e 100644 `$(PKG_CONFIG) --libs freetype2` diff --git a/st.c b/st.c -index 77c3e8a..df6d4c9 100644 +index d6478f5..1fd732e 100644 --- a/st.c +++ b/st.c @@ -35,6 +35,7 @@ @@ -1373,9 +438,9 @@ index 77c3e8a..df6d4c9 100644 } int32_t -@@ -1730,11 +1795,11 @@ csihandle(void) +@@ -1729,11 +1794,11 @@ csihandle(void) + break; case 'S': /* SU -- Scroll <n> line up */ - if (csiescseq.priv) break; DEFAULT(csiescseq.arg[0], 1); - tscrollup(term.top, csiescseq.arg[0]); + tscrollup(term.top, csiescseq.arg[0], 0); @@ -1387,7 +452,7 @@ index 77c3e8a..df6d4c9 100644 break; case 'L': /* IL -- Insert <n> blank lines */ DEFAULT(csiescseq.arg[0], 1); -@@ -1810,6 +1875,33 @@ csihandle(void) +@@ -1809,6 +1874,33 @@ csihandle(void) goto unknown; } break; @@ -1421,7 +486,7 @@ index 77c3e8a..df6d4c9 100644 } } -@@ -1888,7 +1980,7 @@ strhandle(void) +@@ -1887,7 +1979,7 @@ strhandle(void) switch (par) { case 0: if (narg > 1) { @@ -1430,7 +495,7 @@ index 77c3e8a..df6d4c9 100644 xseticontitle(strescseq.args[1]); } return; -@@ -1898,7 +1990,7 @@ strhandle(void) +@@ -1897,7 +1989,7 @@ strhandle(void) return; case 2: if (narg > 1) @@ -1439,7 +504,7 @@ index 77c3e8a..df6d4c9 100644 return; case 52: if (narg > 2 && allowwindowops) { -@@ -1957,7 +2049,7 @@ strhandle(void) +@@ -1956,7 +2048,7 @@ strhandle(void) } break; case 'k': /* old title set compatibility */ @@ -1448,7 +513,7 @@ index 77c3e8a..df6d4c9 100644 return; case 'P': /* DCS -- Device Control String */ case '_': /* APC -- Application Program Command */ -@@ -2310,7 +2402,7 @@ eschandle(uchar ascii) +@@ -2305,7 +2397,7 @@ eschandle(uchar ascii) return 0; case 'D': /* IND -- Linefeed */ if (term.c.y == term.bot) { @@ -1457,7 +522,7 @@ index 77c3e8a..df6d4c9 100644 } else { tmoveto(term.c.x, term.c.y+1); } -@@ -2323,7 +2415,7 @@ eschandle(uchar ascii) +@@ -2318,7 +2410,7 @@ eschandle(uchar ascii) break; case 'M': /* RI -- Reverse index */ if (term.c.y == term.top) { @@ -1466,7 +531,7 @@ index 77c3e8a..df6d4c9 100644 } else { tmoveto(term.c.x, term.c.y-1); } -@@ -2333,6 +2425,7 @@ eschandle(uchar ascii) +@@ -2328,6 +2420,7 @@ eschandle(uchar ascii) break; case 'c': /* RIS -- Reset to initial state */ treset(); @@ -1474,7 +539,7 @@ index 77c3e8a..df6d4c9 100644 resettitle(); xloadcols(); xsetmode(0, MODE_HIDE); -@@ -2546,7 +2639,7 @@ twrite(const char *buf, int buflen, int show_ctrl) +@@ -2541,7 +2634,7 @@ twrite(const char *buf, int buflen, int show_ctrl) void tresize(int col, int row) { @@ -1483,7 +548,7 @@ index 77c3e8a..df6d4c9 100644 int minrow = MIN(row, term.row); int mincol = MIN(col, term.col); int *bp; -@@ -2583,6 +2676,14 @@ tresize(int col, int row) +@@ -2578,6 +2671,14 @@ tresize(int col, int row) term.dirty = xrealloc(term.dirty, row * sizeof(*term.dirty)); term.tabs = xrealloc(term.tabs, col * sizeof(*term.tabs)); @@ -1498,7 +563,7 @@ index 77c3e8a..df6d4c9 100644 /* resize each row to new width, zero-pad if needed */ for (i = 0; i < minrow; i++) { term.line[i] = xrealloc(term.line[i], col * sizeof(Glyph)); -@@ -2628,7 +2729,7 @@ tresize(int col, int row) +@@ -2623,7 +2724,7 @@ tresize(int col, int row) void resettitle(void) { @@ -1507,7 +572,7 @@ index 77c3e8a..df6d4c9 100644 } void -@@ -2641,7 +2742,7 @@ drawregion(int x1, int y1, int x2, int y2) +@@ -2636,7 +2737,7 @@ drawregion(int x1, int y1, int x2, int y2) continue; term.dirty[y] = 0; @@ -1516,7 +581,7 @@ index 77c3e8a..df6d4c9 100644 } } -@@ -2662,8 +2763,9 @@ draw(void) +@@ -2657,8 +2758,9 @@ draw(void) cx--; drawregion(0, 0, term.col, term.row); @@ -1528,20 +593,6 @@ index 77c3e8a..df6d4c9 100644 term.ocx = cx; term.ocy = term.c.y; xfinishdraw(); -diff --git a/st.desktop b/st.desktop -new file mode 100644 -index 0000000..49029d8 ---- /dev/null -+++ b/st.desktop -@@ -0,0 +1,8 @@ -+[Desktop Entry] -+Name=st -+Comment=st is a simple terminal implementation for X -+Exec=st -+Icon=utilities-terminal -+Terminal=false -+Type=Application -+Categories=System;TerminalEmulator; diff --git a/st.h b/st.h index fd3b0d8..c248ec6 100644 --- a/st.h @@ -1622,7 +673,7 @@ index 6de960d..2a40aa0 100644 void xsetmode(int, unsigned int); void xsetpointermotion(int); diff --git a/x.c b/x.c -index b36fb8c..458e4af 100644 +index b36fb8c..0b2641f 100644 --- a/x.c +++ b/x.c @@ -14,6 +14,7 @@ @@ -1697,7 +748,15 @@ index b36fb8c..458e4af 100644 static char *opt_class = NULL; static char **opt_cmd = NULL; static char *opt_embed = NULL; -@@ -306,6 +329,7 @@ zoomabs(const Arg *arg) +@@ -253,6 +276,7 @@ static char *opt_name = NULL; + static char *opt_title = NULL; + + static uint buttons; /* bit field of pressed buttons */ ++static int cursorblinks = 0; + + void + clipcopy(const Arg *dummy) +@@ -306,6 +330,7 @@ zoomabs(const Arg *arg) { xunloadfonts(); xloadfonts(usedfont, arg->f); @@ -1705,7 +764,7 @@ index b36fb8c..458e4af 100644 cresize(0, 0); redraw(); xhints(); -@@ -686,6 +710,8 @@ setsel(char *str, Time t) +@@ -686,6 +711,8 @@ setsel(char *str, Time t) XSetSelectionOwner(xw.dpy, XA_PRIMARY, xw.win, t); if (XGetSelectionOwner(xw.dpy, XA_PRIMARY) != xw.win) selclear(); @@ -1714,7 +773,7 @@ index b36fb8c..458e4af 100644 } void -@@ -752,7 +778,7 @@ xresize(int col, int row) +@@ -752,7 +779,7 @@ xresize(int col, int row) XFreePixmap(xw.dpy, xw.buf); xw.buf = XCreatePixmap(xw.dpy, xw.win, win.w, win.h, @@ -1723,7 +782,7 @@ index b36fb8c..458e4af 100644 XftDrawChange(xw.draw, xw.buf); xclear(0, 0, win.w, win.h); -@@ -812,6 +838,13 @@ xloadcols(void) +@@ -812,6 +839,13 @@ xloadcols(void) else die("could not allocate color %d\n", i); } @@ -1737,7 +796,7 @@ index b36fb8c..458e4af 100644 loaded = 1; } -@@ -859,8 +892,8 @@ xclear(int x1, int y1, int x2, int y2) +@@ -859,8 +893,8 @@ xclear(int x1, int y1, int x2, int y2) void xhints(void) { @@ -1748,7 +807,7 @@ index b36fb8c..458e4af 100644 XWMHints wm = {.flags = InputHint, .input = 1}; XSizeHints *sizeh; -@@ -1050,6 +1083,101 @@ xloadfonts(const char *fontstr, double fontsize) +@@ -1050,6 +1084,101 @@ xloadfonts(const char *fontstr, double fontsize) FcPatternDestroy(pattern); } @@ -1850,7 +909,7 @@ index b36fb8c..458e4af 100644 void xunloadfont(Font *f) { -@@ -1134,11 +1262,22 @@ xinit(int cols, int rows) +@@ -1134,11 +1263,22 @@ xinit(int cols, int rows) Window parent; pid_t thispid = getpid(); XColor xmousefg, xmousebg; @@ -1876,7 +935,7 @@ index b36fb8c..458e4af 100644 /* font */ if (!FcInit()) -@@ -1147,8 +1286,11 @@ xinit(int cols, int rows) +@@ -1147,8 +1287,11 @@ xinit(int cols, int rows) usedfont = (opt_font == NULL)? font : opt_font; xloadfonts(usedfont, 0); @@ -1889,7 +948,7 @@ index b36fb8c..458e4af 100644 xloadcols(); /* adjust fixed window geometry */ -@@ -1168,19 +1310,15 @@ xinit(int cols, int rows) +@@ -1168,19 +1311,15 @@ xinit(int cols, int rows) | ButtonMotionMask | ButtonPressMask | ButtonReleaseMask; xw.attrs.colormap = xw.cmap; @@ -1912,7 +971,7 @@ index b36fb8c..458e4af 100644 XSetForeground(xw.dpy, dc.gc, dc.col[defaultbg].pixel); XFillRectangle(xw.dpy, xw.buf, dc.gc, 0, 0, win.w, win.h); -@@ -1237,6 +1375,8 @@ xinit(int cols, int rows) +@@ -1237,6 +1376,8 @@ xinit(int cols, int rows) xsel.xtarget = XInternAtom(xw.dpy, "UTF8_STRING", 0); if (xsel.xtarget == None) xsel.xtarget = XA_STRING; @@ -1921,7 +980,7 @@ index b36fb8c..458e4af 100644 } int -@@ -1283,8 +1423,13 @@ xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x +@@ -1283,8 +1424,13 @@ xmakeglyphfontspecs(XftGlyphFontSpec *specs, const Glyph *glyphs, int len, int x yp = winy + font->ascent; } @@ -1937,7 +996,7 @@ index b36fb8c..458e4af 100644 if (glyphidx) { specs[numspecs].font = font->match; specs[numspecs].glyph = glyphidx; -@@ -1488,8 +1633,12 @@ xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, i +@@ -1488,8 +1634,12 @@ xdrawglyphfontspecs(const XftGlyphFontSpec *specs, Glyph base, int len, int x, i r.width = width; XftDrawSetClipRectangles(xw.draw, winx, winy, &r, 1); @@ -1952,7 +1011,7 @@ index b36fb8c..458e4af 100644 /* Render underline and strikethrough. */ if (base.mode & ATTR_UNDERLINE) { -@@ -1532,7 +1681,7 @@ xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og) +@@ -1532,7 +1682,7 @@ xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og) /* * Select the right color for the right mode. */ @@ -1961,7 +1020,61 @@ index b36fb8c..458e4af 100644 if (IS_SET(MODE_REVERSE)) { g.mode |= ATTR_REVERSE; -@@ -1626,10 +1775,30 @@ xseticontitle(char *p) +@@ -1558,29 +1708,44 @@ xdrawcursor(int cx, int cy, Glyph g, int ox, int oy, Glyph og) + /* draw the new one */ + if (IS_SET(MODE_FOCUSED)) { + switch (win.cursor) { +- case 7: /* st extension */ +- g.u = 0x2603; /* snowman (U+2603) */ ++ default: ++ case 0: /* blinking block */ ++ case 1: /* blinking block (default) */ ++ if (IS_SET(MODE_BLINK)) ++ break; + /* FALLTHROUGH */ +- case 0: /* Blinking Block */ +- case 1: /* Blinking Block (Default) */ +- case 2: /* Steady Block */ ++ case 2: /* steady block */ + xdrawglyph(g, cx, cy); + break; +- case 3: /* Blinking Underline */ +- case 4: /* Steady Underline */ ++ case 3: /* blinking underline */ ++ if (IS_SET(MODE_BLINK)) ++ break; ++ /* FALLTHROUGH */ ++ case 4: /* steady underline */ + XftDrawRect(xw.draw, &drawcol, + borderpx + cx * win.cw, + borderpx + (cy + 1) * win.ch - \ + cursorthickness, + win.cw, cursorthickness); + break; +- case 5: /* Blinking bar */ +- case 6: /* Steady bar */ ++ case 5: /* blinking bar */ ++ if (IS_SET(MODE_BLINK)) ++ break; ++ /* FALLTHROUGH */ ++ case 6: /* steady bar */ + XftDrawRect(xw.draw, &drawcol, + borderpx + cx * win.cw, + borderpx + cy * win.ch, + cursorthickness, win.ch); + break; ++ case 7: /* blinking st cursor */ ++ if (IS_SET(MODE_BLINK)) ++ break; ++ /* FALLTHROUGH */ ++ case 8: /* steady st cursor */ ++ g.u = stcursor; ++ xdrawglyph(g, cx, cy); ++ break; + } + } else { + XftDrawRect(xw.draw, &drawcol, +@@ -1626,10 +1791,30 @@ xseticontitle(char *p) } void @@ -1995,7 +1108,7 @@ index b36fb8c..458e4af 100644 if (Xutf8TextListToTextProperty(xw.dpy, &p, 1, XUTF8StringStyle, &prop) != Success) -@@ -1639,6 +1808,16 @@ xsettitle(char *p) +@@ -1639,6 +1824,16 @@ xsettitle(char *p) XFree(prop.value); } @@ -2012,7 +1125,41 @@ index b36fb8c..458e4af 100644 int xstartdraw(void) { -@@ -2014,6 +2193,59 @@ run(void) +@@ -1737,9 +1932,12 @@ xsetmode(int set, unsigned int flags) + int + xsetcursor(int cursor) + { +- if (!BETWEEN(cursor, 0, 7)) /* 7: st extension */ ++ if (!BETWEEN(cursor, 0, 8)) /* 7-8: st extensions */ + return 1; + win.cursor = cursor; ++ cursorblinks = win.cursor == 0 || win.cursor == 1 || ++ win.cursor == 3 || win.cursor == 5 || ++ win.cursor == 7; + return 0; + } + +@@ -1986,6 +2184,10 @@ run(void) + if (FD_ISSET(ttyfd, &rfd) || xev) { + if (!drawing) { + trigger = now; ++ if (IS_SET(MODE_BLINK)) { ++ win.mode ^= MODE_BLINK; ++ } ++ lastblink = now; + drawing = 1; + } + timeout = (maxlatency - TIMEDIFF(now, trigger)) \ +@@ -1996,7 +2198,7 @@ run(void) + + /* idle detected or maxlatency exhausted -> draw */ + timeout = -1; +- if (blinktimeout && tattrset(ATTR_BLINK)) { ++ if (blinktimeout && (cursorblinks || tattrset(ATTR_BLINK))) { + timeout = blinktimeout - TIMEDIFF(now, lastblink); + if (timeout <= 0) { + if (-timeout > blinktimeout) /* start visible */ +@@ -2014,6 +2216,59 @@ run(void) } } @@ -2072,7 +1219,14 @@ index b36fb8c..458e4af 100644 void usage(void) { -@@ -2038,6 +2270,9 @@ main(int argc, char *argv[]) +@@ -2032,12 +2287,15 @@ main(int argc, char *argv[]) + { + xw.l = xw.t = 0; + xw.isfixed = False; +- xsetcursor(cursorshape); ++ xsetcursor(cursorstyle); + + ARGBEGIN { case 'a': allowaltscreen = 0; break; @@ -2082,7 +1236,7 @@ index b36fb8c..458e4af 100644 case 'c': opt_class = EARGF(usage()); break; -@@ -2087,6 +2322,11 @@ run: +@@ -2087,6 +2345,11 @@ run: setlocale(LC_CTYPE, ""); XSetLocaleModifiers(""); |