pax_global_header00006660000000000000000000000064150722472000014511gustar00rootroot0000000000000052 comment=1733e0025b194c9bc083f4cd8782c5f151858a58 hyprpaper-0.7.6/000077500000000000000000000000001507224720000135355ustar00rootroot00000000000000hyprpaper-0.7.6/.clang-format000066400000000000000000000034161507224720000161140ustar00rootroot00000000000000--- Language: Cpp BasedOnStyle: LLVM AccessModifierOffset: -2 AlignAfterOpenBracket: Align AlignConsecutiveMacros: true AlignConsecutiveAssignments: true AlignEscapedNewlines: Right AlignOperands: false AlignTrailingComments: true AllowAllArgumentsOnNextLine: true AllowAllConstructorInitializersOnNextLine: true AllowAllParametersOfDeclarationOnNextLine: true AllowShortBlocksOnASingleLine: true AllowShortCaseLabelsOnASingleLine: true AllowShortFunctionsOnASingleLine: Empty AllowShortIfStatementsOnASingleLine: Never AllowShortLambdasOnASingleLine: All AllowShortLoopsOnASingleLine: false AlwaysBreakAfterDefinitionReturnType: None AlwaysBreakAfterReturnType: None AlwaysBreakBeforeMultilineStrings: false AlwaysBreakTemplateDeclarations: Yes BreakBeforeBraces: Attach BreakBeforeTernaryOperators: false BreakConstructorInitializers: AfterColon ColumnLimit: 180 CompactNamespaces: false ConstructorInitializerAllOnOneLineOrOnePerLine: false ExperimentalAutoDetectBinPacking: false FixNamespaceComments: false IncludeBlocks: Preserve IndentCaseLabels: true IndentWidth: 4 PointerAlignment: Left ReflowComments: false SortIncludes: false SortUsingDeclarations: false SpaceAfterCStyleCast: false SpaceAfterLogicalNot: false SpaceAfterTemplateKeyword: true SpaceBeforeCtorInitializerColon: true SpaceBeforeInheritanceColon: true SpaceBeforeParens: ControlStatements SpaceBeforeRangeBasedForLoopColon: true SpaceInEmptyParentheses: false SpacesBeforeTrailingComments: 1 SpacesInAngles: false SpacesInCStyleCastParentheses: false SpacesInContainerLiterals: false SpacesInParentheses: false SpacesInSquareBrackets: false Standard: Auto TabWidth: 4 UseTab: Never AllowShortEnumsOnASingleLine: false BraceWrapping: AfterEnum: false AlignConsecutiveDeclarations: AcrossEmptyLines NamespaceIndentation: All hyprpaper-0.7.6/.github/000077500000000000000000000000001507224720000150755ustar00rootroot00000000000000hyprpaper-0.7.6/.github/workflows/000077500000000000000000000000001507224720000171325ustar00rootroot00000000000000hyprpaper-0.7.6/.github/workflows/nix-build.yaml000066400000000000000000000032631507224720000217150ustar00rootroot00000000000000name: Build Hyprpaper (Nix) on: [push, pull_request, workflow_dispatch] jobs: nix: name: "Build" runs-on: ubuntu-latest steps: - name: Clone repository uses: actions/checkout@v3 with: submodules: recursive - name: Install Nix uses: nixbuild/nix-quick-install-action@v31 with: nix_conf: | keep-env-derivations = true keep-outputs = true - name: Restore and save Nix store uses: nix-community/cache-nix-action@v6 with: # restore and save a cache using this key primary-key: nix-${{ runner.os }}-${{ hashFiles('**/*.nix', '**/flake.lock') }} # if there's no cache hit, restore a cache by this prefix restore-prefixes-first-match: nix-${{ runner.os }}- # collect garbage until the Nix store size (in bytes) is at most this number # before trying to save a new cache # 1G = 1073741824 gc-max-store-size-linux: 1G # do purge caches purge: true # purge all versions of the cache purge-prefixes: nix-${{ runner.os }}- # created more than this number of seconds ago purge-created: 0 # or, last accessed more than this number of seconds ago # relative to the start of the `Post Restore and save Nix store` phase purge-last-accessed: 0 # except any version with the key that is the same as the `primary-key` purge-primary-key: never - uses: cachix/cachix-action@v12 with: name: hyprland authToken: '${{ secrets.CACHIX_AUTH_TOKEN }}' - name: Build Hyprpaper with default settings run: nix build --print-build-logs --accept-flake-config hyprpaper-0.7.6/.gitignore000066400000000000000000000004731507224720000155310ustar00rootroot00000000000000CMakeLists.txt.user CMakeCache.txt CMakeFiles CMakeScripts Testing cmake_install.cmake install_manifest.txt compile_commands.json CTestTestfile.cmake _deps build/ result /.vscode/ /.idea *.o *-protocol.c *-protocol.h .ccls-cache protocols/*.hpp protocols/*.cpp .cache/ hyprctl/hyprctl gmon.out *.out *.tar.gz hyprpaper-0.7.6/CMakeLists.txt000066400000000000000000000114001507224720000162710ustar00rootroot00000000000000cmake_minimum_required(VERSION 3.12) file(READ "${CMAKE_SOURCE_DIR}/VERSION" VER_RAW) string(STRIP ${VER_RAW} VERSION) project( hyprpaper DESCRIPTION "A blazing fast wayland wallpaper utility" VERSION ${VERSION}) set(CMAKE_MESSAGE_LOG_LEVEL "STATUS") message(STATUS "Configuring hyprpaper!") configure_file(systemd/hyprpaper.service.in systemd/hyprpaper.service @ONLY) # Get git info hash and branch execute_process( COMMAND git rev-parse --abbrev-ref HEAD WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} OUTPUT_VARIABLE GIT_BRANCH OUTPUT_STRIP_TRAILING_WHITESPACE) execute_process( COMMAND git rev-parse HEAD WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} OUTPUT_VARIABLE GIT_COMMIT_HASH OUTPUT_STRIP_TRAILING_WHITESPACE) execute_process( COMMAND bash -c "git show ${GIT_COMMIT_HASH} | head -n 5 | tail -n 1 | sed -s 's/\#//g; s/^[[:space:]]*//'" WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} OUTPUT_VARIABLE GIT_COMMIT_MESSAGE OUTPUT_STRIP_TRAILING_WHITESPACE) execute_process( COMMAND bash -c "git diff-index --quiet HEAD -- || echo \"dirty\"" WORKING_DIRECTORY ${CMAKE_SOURCE_DIR} OUTPUT_VARIABLE GIT_DIRTY OUTPUT_STRIP_TRAILING_WHITESPACE) include_directories(.) set(CMAKE_CXX_STANDARD 23) add_compile_options(-DWLR_USE_UNSTABLE) add_compile_options(-Wall -Wextra -Wno-unused-parameter -Wno-unused-value -Wno-missing-field-initializers -Wno-narrowing) find_package(Threads REQUIRED) find_package(PkgConfig REQUIRED) find_package(hyprwayland-scanner 0.4.0 REQUIRED) pkg_check_modules( deps REQUIRED IMPORTED_TARGET wayland-client wayland-protocols>=1.35 cairo pango pangocairo hyprlang>=0.6.0 hyprutils>=0.2.4 hyprgraphics) file(GLOB_RECURSE SRCFILES "src/*.cpp") add_executable(hyprpaper ${SRCFILES}) pkg_get_variable(WAYLAND_PROTOCOLS_DIR wayland-protocols pkgdatadir) message(STATUS "Found wayland-protocols at ${WAYLAND_PROTOCOLS_DIR}") pkg_get_variable(WAYLAND_SCANNER_PKGDATA_DIR wayland-scanner pkgdatadir) message( STATUS "Found wayland-scanner pkgdatadir at ${WAYLAND_SCANNER_PKGDATA_DIR}") function(protocolnew protoPath protoName external) if(external) set(path ${CMAKE_SOURCE_DIR}/${protoPath}) else() set(path ${WAYLAND_PROTOCOLS_DIR}/${protoPath}) endif() add_custom_command( OUTPUT ${CMAKE_SOURCE_DIR}/protocols/${protoName}.cpp ${CMAKE_SOURCE_DIR}/protocols/${protoName}.hpp COMMAND hyprwayland-scanner --client ${path}/${protoName}.xml ${CMAKE_SOURCE_DIR}/protocols/ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}) target_sources(hyprpaper PRIVATE protocols/${protoName}.cpp protocols/${protoName}.hpp) endfunction() function(protocolWayland) add_custom_command( OUTPUT ${CMAKE_SOURCE_DIR}/protocols/wayland.cpp ${CMAKE_SOURCE_DIR}/protocols/wayland.hpp COMMAND hyprwayland-scanner --wayland-enums --client ${WAYLAND_SCANNER_PKGDATA_DIR}/wayland.xml ${CMAKE_SOURCE_DIR}/protocols/ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}) target_sources(hyprpaper PRIVATE protocols/wayland.cpp protocols/wayland.hpp) endfunction() protocolwayland() protocolnew("protocols" "wlr-layer-shell-unstable-v1" true) protocolnew("stable/linux-dmabuf" "linux-dmabuf-v1" false) protocolnew("staging/fractional-scale" "fractional-scale-v1" false) protocolnew("stable/viewporter" "viewporter" false) protocolnew("stable/xdg-shell" "xdg-shell" false) protocolnew("staging/cursor-shape" "cursor-shape-v1" false) protocolnew("stable/tablet" "tablet-v2" false) string(REPLACE "\"" " " GIT_COMMIT_MESSAGE_ESCAPED "${GIT_COMMIT_MESSAGE}") target_compile_definitions(hyprpaper PRIVATE "-DGIT_COMMIT_HASH=\"${GIT_COMMIT_HASH}\"") target_compile_definitions(hyprpaper PRIVATE "-DGIT_BRANCH=\"${GIT_BRANCH}\"") target_compile_definitions(hyprpaper PRIVATE "-DGIT_COMMIT_MESSAGE=\"${GIT_COMMIT_MESSAGE_ESCAPED}\"") target_compile_definitions(hyprpaper PRIVATE "-DGIT_DIRTY=\"${GIT_DIRTY}\"") target_link_libraries(hyprpaper rt) set(CPACK_PROJECT_NAME ${PROJECT_NAME}) set(CPACK_PROJECT_VERSION ${PROJECT_VERSION}) include(CPack) target_link_libraries(hyprpaper PkgConfig::deps) target_link_libraries( hyprpaper OpenGL GLESv2 pthread magic ${CMAKE_THREAD_LIBS_INIT} wayland-cursor) if(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pg -no-pie -fno-builtin") set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -pg -no-pie -fno-builtin") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -pg -no-pie -fno-builtin") endif(CMAKE_BUILD_TYPE MATCHES Debug OR CMAKE_BUILD_TYPE MATCHES DEBUG) include(GNUInstallDirs) install(TARGETS hyprpaper) install(FILES ${CMAKE_BINARY_DIR}/systemd/hyprpaper.service DESTINATION "lib/systemd/user") hyprpaper-0.7.6/LICENSE000066400000000000000000000027641507224720000145530ustar00rootroot00000000000000BSD 3-Clause License Copyright (c) 2022, Hypr Development All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. hyprpaper-0.7.6/README.md000066400000000000000000000166621507224720000150270ustar00rootroot00000000000000# hyprpaper Hyprpaper is a blazing fast wallpaper utility for Hyprland with the ability to dynamically change wallpapers through sockets. It will work on all wlroots-based compositors, though. # Features - Per-output wallpapers - fill, tile or contain modes - fractional scaling support - IPC for blazing fast wallpaper switches - preloading targets into memory # Installation [Arch Linux](https://archlinux.org/packages/extra/x86_64/hyprpaper/): `pacman -S hyprpaper` [OpenSuse Linux](https://software.opensuse.org/package/hyprpaper): `zypper install hyprpaper` ## Manual: ### Dependencies The development files of these packages need to be installed on the system for `hyprpaper` to build correctly. (Development packages are usually suffixed with `-dev` or `-devel` in most distros' repos). - wayland - wayland-protocols - pango - cairo - file - libglvnd - libglvnd-core - libjpeg-turbo - libwebp - libjxl - hyprlang - hyprutils - hyprwayland-scanner - hyprgraphics To install all of these in Fedora, run this command: ``` sudo dnf install wayland-devel wayland-protocols-devel hyprlang-devel pango-devel cairo-devel file-devel libglvnd-devel libglvnd-core-devel libjpeg-turbo-devel libwebp-devel libjxl-devel gcc-c++ hyprutils-devel hyprwayland-scanner ``` On Arch: ``` sudo pacman -S ninja gcc wayland-protocols libjpeg-turbo libwebp libjxl pango cairo pkgconf cmake libglvnd wayland hyprutils hyprwayland-scanner hyprlang ``` On OpenSUSE: ``` sudo zypper install ninja gcc-c++ wayland-protocols-devel Mesa-libGLESv3-devel file-devel hyprutils-devel hyprwayland-scanner ``` ### Building Building is done via CMake: ```sh cmake --no-warn-unused-cli -DCMAKE_BUILD_TYPE:STRING=Release -DCMAKE_INSTALL_PREFIX:PATH=/usr -S . -B ./build cmake --build ./build --config Release --target hyprpaper -j`nproc 2>/dev/null || getconf _NPROCESSORS_CONF` ``` Install with: ```sh cmake --install ./build ``` # Usage Hyprpaper is controlled by the config, like this: *~/.config/hypr/hyprpaper.conf* ``` preload = /path/to/image.png #if more than one preload is desired then continue to preload other backgrounds preload = /path/to/next_image.png # .. more preloads #set the default wallpaper(s) seen on initial workspace(s) --depending on the number of monitors used wallpaper = monitor1,/path/to/image.png #if more than one monitor in use, can load a 2nd image wallpaper = monitor2,/path/to/next_image.png # .. more monitors #enable splash text rendering over the wallpaper splash = true #fully disable ipc # ipc = off ``` Preload will tell Hyprland to load a particular image (supported formats: png, jpg, jpeg, jpeg xl, webp). Wallpaper will apply the wallpaper to the selected output (`monitor` is the monitor's name, easily can be retrieved with `hyprctl monitors`. You can leave it empty to set all monitors without an active wallpaper. You can also use `desc:` followed by the monitor's description without the (PORT) at the end) You may add `contain:` or `tile:` before the file path in `wallpaper=` to set the mode to either contain or tile, respectively, instead of cover: ``` wallpaper = monitor,contain:/path/to/image.jpg ``` A Wallpaper ***cannot*** be applied without preloading. The config is ***not*** reloaded dynamically. ## Important note to the inner workings Preload does exactly what it says. It loads the entire wallpaper into memory. This can result in around 8 - 20MB of mem usage. It is not recommended to preload every wallpaper you have, as it will be a) taking a couple seconds at the beginning to load and b) take 100s of MBs of disk and RAM usage. Preload is meant only for situations in which you want a wallpaper to switch INSTANTLY when you issue a wallpaper keyword (e.g. wallpaper per workspace) In any and all cases when you don't mind waiting 300ms for the wallpaper to change, consider making a script that: - preloads the new wallpaper - sets the new wallpaper - unloads the old wallpaper (to free memory) # IPC You can use `hyprctl hyprpaper` (if on Hyprland) to issue a keyword, for example Example: If your wallpapers are stored in *~/Pictures*, then make sure you have already preloaded the desired wallpapers in hyprpaper.conf. *~/.config/hypr/hyprpaper.conf* ``` preload = ~/Pictures/myepicpng.png preload = ~/Pictures/myepicpngToo.png preload = ~/Pictures/myepicpngAlso.png #... continue as desired, but be mindful of the impact on memory. ``` In the actual configuration for Hyprland, *hyprland.conf*, variables can be set for ease of reading and to be used as shortcuts in the bind command. The following example uses $w shorthand wallpaper variables: *~/.config/hypr/hyprland.conf* ``` $w1 = hyprctl hyprpaper wallpaper "DP-1,~/Pictures/myepicpng.png" $w2 = hyprctl hyprpaper wallpaper "DP-1,~/Pictures/myepicpngToo.png" $w3 = hyprctl hyprpaper wallpaper "DP-1,~/Pictures/myepicpngAlso.png" #yes use quotes around desired monitor and wallpaper #... continued with desired amount ``` With the variables created we can now "exec" the actions. Remember in Hyprland we can bind more than one action to a key so in the case where we'd like to change the wallpaper when we switch workspace we have to ensure that the actions are bound to the same key such as... *~/.config/hypr/hyprland.conf* ``` bind=SUPER,1,workspace,1 #Superkey + 1 switches to workspace 1 bind=SUPER,1,exec,$w1 #SuperKey + 1 switches to wallpaper $w1 on DP-1 as defined in the variable bind=SUPER,2,workspace,2 #Superkey + 2 switches to workspace 2 bind=SUPER,2,exec,$w2 #SuperKey + 2 switches to wallpaper $w2 on DP-1 as defined in the variable bind=SUPER,3,workspace,3 #Superkey + 3 switches to workspace 3 bind=SUPER,3,exec,$w3 #SuperKey + 3 switches to wallpaper $w3 on DP-1 as defined in the variable #... and so on ``` Because the default behavior in Hyprland is to also switch the workspace whenever movetoworkspace is used to move a window to another workspace you may want to include the following: ``` bind=SUPERSHIFT,1,movetoworkspace,1 #Superkey + Shift + 1 moves windows and switches to workspace 1 bind=SUPERSHIFT,1,exec,$w1 #SuperKey + Shift + 1 switches to wallpaper $w1 on DP-1 as defined in the variable ``` ## Getting information from hyprpaper You can also use `hyprctl hyprpaper` to get information about the state of hyprpaper using the following commands: ``` listloaded - lists the wallpapers that are currently preloaded (useful for dynamically preloading and unloading) listactive - prints the active wallpapers hyprpaper is displaying, along with its accociated monitor ``` # Battery life Since the IPC has to tick every now and then, and poll in the background, battery life might be a tiny bit worse with IPC on. If you want to fully disable it, use ``` ipc = off ``` in the config. # Misc You can set `splash = true` to enable the splash rendering over the wallpaper. The value for `splash_offset` sets, in percentage, the splash rendering offset relative to the bottom of the display. ## Unloading If you use a lot of wallpapers, consider unloading those that you no longer need. This will mean you need to load them again if you wish to use them for a second time, but will free the memory used by the preloaded bitmap. (Usually 8 - 20MB, depending on the resolution) You can issue a `hyprctl hyprpaper unload [PATH]` to do that. You can also issue a `hyprctl hyprpaper unload all` to unload all inactive wallpapers.
For other compositors, the socket works like socket1 of Hyprland, and is located in `/tmp/hypr/.hyprpaper.sock` (this path only when Hyprland is not running!) hyprpaper-0.7.6/VERSION000066400000000000000000000000061507224720000146010ustar00rootroot000000000000000.7.6 hyprpaper-0.7.6/flake.lock000066400000000000000000000066551507224720000155050ustar00rootroot00000000000000{ "nodes": { "hyprgraphics": { "inputs": { "hyprutils": [ "hyprutils" ], "nixpkgs": [ "nixpkgs" ], "systems": [ "systems" ] }, "locked": { "lastModified": 1750621377, "narHash": "sha256-8u6b5oAdX0rCuoR8wFenajBRmI+mzbpNig6hSCuWUzE=", "owner": "hyprwm", "repo": "hyprgraphics", "rev": "b3d628d01693fb9bb0a6690cd4e7b80abda04310", "type": "github" }, "original": { "owner": "hyprwm", "repo": "hyprgraphics", "type": "github" } }, "hyprlang": { "inputs": { "hyprutils": [ "hyprutils" ], "nixpkgs": [ "nixpkgs" ], "systems": [ "systems" ] }, "locked": { "lastModified": 1750371198, "narHash": "sha256-/iuJ1paQOBoSLqHflRNNGyroqfF/yvPNurxzcCT0cAE=", "owner": "hyprwm", "repo": "hyprlang", "rev": "cee01452bca58d6cadb3224e21e370de8bc20f0b", "type": "github" }, "original": { "owner": "hyprwm", "repo": "hyprlang", "type": "github" } }, "hyprutils": { "inputs": { "nixpkgs": [ "nixpkgs" ], "systems": [ "systems" ] }, "locked": { "lastModified": 1750371096, "narHash": "sha256-JB1IeJ41y7kWc/dPGV6RMcCUM0Xj2NEK26A2Ap7EM9c=", "owner": "hyprwm", "repo": "hyprutils", "rev": "38f3a211657ce82a1123bf19402199b67a410f08", "type": "github" }, "original": { "owner": "hyprwm", "repo": "hyprutils", "type": "github" } }, "hyprwayland-scanner": { "inputs": { "nixpkgs": [ "nixpkgs" ], "systems": [ "systems" ] }, "locked": { "lastModified": 1750371869, "narHash": "sha256-lGk4gLjgZQ/rndUkzmPYcgbHr8gKU5u71vyrjnwfpB4=", "owner": "hyprwm", "repo": "hyprwayland-scanner", "rev": "aa38edd6e3e277ae6a97ea83a69261a5c3aab9fd", "type": "github" }, "original": { "owner": "hyprwm", "repo": "hyprwayland-scanner", "type": "github" } }, "nixpkgs": { "locked": { "lastModified": 1750365781, "narHash": "sha256-XE/lFNhz5lsriMm/yjXkvSZz5DfvKJLUjsS6pP8EC50=", "owner": "NixOS", "repo": "nixpkgs", "rev": "08f22084e6085d19bcfb4be30d1ca76ecb96fe54", "type": "github" }, "original": { "owner": "NixOS", "ref": "nixos-unstable", "repo": "nixpkgs", "type": "github" } }, "root": { "inputs": { "hyprgraphics": "hyprgraphics", "hyprlang": "hyprlang", "hyprutils": "hyprutils", "hyprwayland-scanner": "hyprwayland-scanner", "nixpkgs": "nixpkgs", "systems": "systems" } }, "systems": { "locked": { "lastModified": 1689347949, "narHash": "sha256-12tWmuL2zgBgZkdoB6qXZsgJEH9LR3oUgpaQq2RbI80=", "owner": "nix-systems", "repo": "default-linux", "rev": "31732fcf5e8fea42e59c2488ad31a0e651500f68", "type": "github" }, "original": { "owner": "nix-systems", "repo": "default-linux", "type": "github" } } }, "root": "root", "version": 7 } hyprpaper-0.7.6/flake.nix000066400000000000000000000050761507224720000153470ustar00rootroot00000000000000{ description = "Hyprpaper is a blazing fast Wayland wallpaper utility with IPC controls"; inputs = { nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable"; systems.url = "github:nix-systems/default-linux"; hyprgraphics = { url = "github:hyprwm/hyprgraphics"; inputs.nixpkgs.follows = "nixpkgs"; inputs.systems.follows = "systems"; inputs.hyprutils.follows = "hyprutils"; }; hyprutils = { url = "github:hyprwm/hyprutils"; inputs.nixpkgs.follows = "nixpkgs"; inputs.systems.follows = "systems"; }; hyprlang = { url = "github:hyprwm/hyprlang"; inputs.nixpkgs.follows = "nixpkgs"; inputs.systems.follows = "systems"; inputs.hyprutils.follows = "hyprutils"; }; hyprwayland-scanner = { url = "github:hyprwm/hyprwayland-scanner"; inputs.nixpkgs.follows = "nixpkgs"; inputs.systems.follows = "systems"; }; }; outputs = { self, nixpkgs, systems, ... } @ inputs: let inherit (nixpkgs) lib; eachSystem = lib.genAttrs (import systems); pkgsFor = eachSystem (system: import nixpkgs { localSystem.system = system; overlays = with self.overlays; [hyprpaper]; }); mkDate = longDate: (lib.concatStringsSep "-" [ (builtins.substring 0 4 longDate) (builtins.substring 4 2 longDate) (builtins.substring 6 2 longDate) ]); version = lib.removeSuffix "\n" (builtins.readFile ./VERSION); in { overlays = { default = self.overlays.hyprpaper; hyprpaper = lib.composeManyExtensions [ inputs.hyprgraphics.overlays.default inputs.hyprlang.overlays.default inputs.hyprutils.overlays.default inputs.hyprwayland-scanner.overlays.default (final: prev: rec { hyprpaper = final.callPackage ./nix/default.nix { stdenv = final.gcc15Stdenv; version = version + "+date=" + (mkDate (self.lastModifiedDate or "19700101")) + "_" + (self.shortRev or "dirty"); commit = self.rev or ""; }; hyprpaper-debug = hyprpaper.override {debug = true;}; }) ]; }; packages = eachSystem (system: { default = self.packages.${system}.hyprpaper; inherit (pkgsFor.${system}) hyprpaper hyprpaper-debug; }); homeManagerModules = { default = self.homeManagerModules.hyprpaper; hyprpaper = builtins.throw "hyprpaper: the flake HM module has been removed. Use the module from Home Manager upstream."; }; formatter = eachSystem (system: pkgsFor.${system}.alejandra); }; } hyprpaper-0.7.6/nix/000077500000000000000000000000001507224720000143335ustar00rootroot00000000000000hyprpaper-0.7.6/nix/default.nix000066400000000000000000000025361507224720000165050ustar00rootroot00000000000000{ lib, stdenv, pkg-config, cmake, cairo, expat, file, fribidi, hyprgraphics, hyprlang, hyprutils, hyprwayland-scanner, libdatrie, libGL, libjpeg, libjxl, libselinux, libsepol, libthai, libwebp, pango, pcre, pcre2, util-linux, wayland, wayland-protocols, wayland-scanner, xorg, commit, debug ? false, version ? "git", }: stdenv.mkDerivation { pname = "hyprpaper" + lib.optionalString debug "-debug"; inherit version; src = ../.; prePatch = '' substituteInPlace src/main.cpp \ --replace GIT_COMMIT_HASH '"${commit}"' ''; depsBuildBuild = [ pkg-config ]; cmakeBuildType = if debug then "Debug" else "Release"; nativeBuildInputs = [ cmake hyprwayland-scanner pkg-config wayland-scanner ]; buildInputs = [ cairo expat file fribidi hyprgraphics hyprlang hyprutils libdatrie libGL libjpeg libjxl libselinux libsepol libthai libwebp pango pcre pcre2 wayland wayland-protocols xorg.libXdmcp util-linux ]; meta = with lib; { description = "A blazing fast wayland wallpaper utility with IPC controls"; homepage = "https://github.com/hyprwm/hyprpaper"; license = licenses.bsd3; mainProgram = "hyprpaper"; platforms = platforms.linux; }; } hyprpaper-0.7.6/protocols/000077500000000000000000000000001507224720000155615ustar00rootroot00000000000000hyprpaper-0.7.6/protocols/wlr-layer-shell-unstable-v1.xml000066400000000000000000000320741507224720000234730ustar00rootroot00000000000000 Copyright © 2017 Drew DeVault Permission to use, copy, modify, distribute, and sell this software and its documentation for any purpose is hereby granted without fee, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of the copyright holders not be used in advertising or publicity pertaining to distribution of the software without specific, written prior permission. The copyright holders make no representations about the suitability of this software for any purpose. It is provided "as is" without express or implied warranty. THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. Clients can use this interface to assign the surface_layer role to wl_surfaces. Such surfaces are assigned to a "layer" of the output and rendered with a defined z-depth respective to each other. They may also be anchored to the edges and corners of a screen and specify input handling semantics. This interface should be suitable for the implementation of many desktop shell components, and a broad number of other applications that interact with the desktop. Create a layer surface for an existing surface. This assigns the role of layer_surface, or raises a protocol error if another role is already assigned. Creating a layer surface from a wl_surface which has a buffer attached or committed is a client error, and any attempts by a client to attach or manipulate a buffer prior to the first layer_surface.configure call must also be treated as errors. You may pass NULL for output to allow the compositor to decide which output to use. Generally this will be the one that the user most recently interacted with. Clients can specify a namespace that defines the purpose of the layer surface. These values indicate which layers a surface can be rendered in. They are ordered by z depth, bottom-most first. Traditional shell surfaces will typically be rendered between the bottom and top layers. Fullscreen shell surfaces are typically rendered at the top layer. Multiple surfaces can share a single layer, and ordering within a single layer is undefined. An interface that may be implemented by a wl_surface, for surfaces that are designed to be rendered as a layer of a stacked desktop-like environment. Layer surface state (size, anchor, exclusive zone, margin, interactivity) is double-buffered, and will be applied at the time wl_surface.commit of the corresponding wl_surface is called. Sets the size of the surface in surface-local coordinates. The compositor will display the surface centered with respect to its anchors. If you pass 0 for either value, the compositor will assign it and inform you of the assignment in the configure event. You must set your anchor to opposite edges in the dimensions you omit; not doing so is a protocol error. Both values are 0 by default. Size is double-buffered, see wl_surface.commit. Requests that the compositor anchor the surface to the specified edges and corners. If two orthoginal edges are specified (e.g. 'top' and 'left'), then the anchor point will be the intersection of the edges (e.g. the top left corner of the output); otherwise the anchor point will be centered on that edge, or in the center if none is specified. Anchor is double-buffered, see wl_surface.commit. Requests that the compositor avoids occluding an area of the surface with other surfaces. The compositor's use of this information is implementation-dependent - do not assume that this region will not actually be occluded. A positive value is only meaningful if the surface is anchored to an edge, rather than a corner. The zone is the number of surface-local coordinates from the edge that are considered exclusive. Surfaces that do not wish to have an exclusive zone may instead specify how they should interact with surfaces that do. If set to zero, the surface indicates that it would like to be moved to avoid occluding surfaces with a positive excluzive zone. If set to -1, the surface indicates that it would not like to be moved to accommodate for other surfaces, and the compositor should extend it all the way to the edges it is anchored to. For example, a panel might set its exclusive zone to 10, so that maximized shell surfaces are not shown on top of it. A notification might set its exclusive zone to 0, so that it is moved to avoid occluding the panel, but shell surfaces are shown underneath it. A wallpaper or lock screen might set their exclusive zone to -1, so that they stretch below or over the panel. The default value is 0. Exclusive zone is double-buffered, see wl_surface.commit. Requests that the surface be placed some distance away from the anchor point on the output, in surface-local coordinates. Setting this value for edges you are not anchored to has no effect. The exclusive zone includes the margin. Margin is double-buffered, see wl_surface.commit. Set to 1 to request that the seat send keyboard events to this layer surface. For layers below the shell surface layer, the seat will use normal focus semantics. For layers above the shell surface layers, the seat will always give exclusive keyboard focus to the top-most layer which has keyboard interactivity set to true. Layer surfaces receive pointer, touch, and tablet events normally. If you do not want to receive them, set the input region on your surface to an empty region. Events is double-buffered, see wl_surface.commit. This assigns an xdg_popup's parent to this layer_surface. This popup should have been created via xdg_surface::get_popup with the parent set to NULL, and this request must be invoked before committing the popup's initial state. See the documentation of xdg_popup for more details about what an xdg_popup is and how it is used. When a configure event is received, if a client commits the surface in response to the configure event, then the client must make an ack_configure request sometime before the commit request, passing along the serial of the configure event. If the client receives multiple configure events before it can respond to one, it only has to ack the last configure event. A client is not required to commit immediately after sending an ack_configure request - it may even ack_configure several times before its next surface commit. A client may send multiple ack_configure requests before committing, but only the last request sent before a commit indicates which configure event the client really is responding to. This request destroys the layer surface. The configure event asks the client to resize its surface. Clients should arrange their surface for the new states, and then send an ack_configure request with the serial sent in this configure event at some point before committing the new surface. The client is free to dismiss all but the last configure event it received. The width and height arguments specify the size of the window in surface-local coordinates. The size is a hint, in the sense that the client is free to ignore it if it doesn't resize, pick a smaller size (to satisfy aspect ratio or resize in steps of NxM pixels). If the client picks a smaller size and is anchored to two opposite anchors (e.g. 'top' and 'bottom'), the surface will be centered on this axis. If the width or height arguments are zero, it means the client should decide its own window dimension. The closed event is sent by the compositor when the surface will no longer be shown. The output may have been destroyed or the user may have asked for it to be removed. Further changes to the surface will be ignored. The client should destroy the resource after receiving this event, and create a new surface if they so choose. hyprpaper-0.7.6/src/000077500000000000000000000000001507224720000143245ustar00rootroot00000000000000hyprpaper-0.7.6/src/Hyprpaper.cpp000066400000000000000000000577101507224720000170140ustar00rootroot00000000000000#include "Hyprpaper.hpp" #include #include #include #include #include #include static void setMallocThreshold() { #ifdef M_TRIM_THRESHOLD // The default is 128 pages, // which is very large and can lead to a lot of memory used for no reason // because trimming hasn't happened static const int PAGESIZE = sysconf(_SC_PAGESIZE); mallopt(M_TRIM_THRESHOLD, 6 * PAGESIZE); #endif } CHyprpaper::CHyprpaper() { setMallocThreshold(); } static void handleGlobal(CCWlRegistry* registry, uint32_t name, const char* interface, uint32_t version) { if (strcmp(interface, wl_compositor_interface.name) == 0) { g_pHyprpaper->m_pCompositor = makeShared((wl_proxy*)wl_registry_bind((wl_registry*)registry->resource(), name, &wl_compositor_interface, 4)); } else if (strcmp(interface, wl_shm_interface.name) == 0) { g_pHyprpaper->m_pSHM = makeShared((wl_proxy*)wl_registry_bind((wl_registry*)registry->resource(), name, &wl_shm_interface, 1)); } else if (strcmp(interface, wl_output_interface.name) == 0) { g_pHyprpaper->m_mtTickMutex.lock(); const auto PMONITOR = g_pHyprpaper->m_vMonitors.emplace_back(std::make_unique()).get(); PMONITOR->wayland_name = name; PMONITOR->name = ""; PMONITOR->output = makeShared((wl_proxy*)wl_registry_bind((wl_registry*)registry->resource(), name, &wl_output_interface, 4)); PMONITOR->registerListeners(); g_pHyprpaper->m_mtTickMutex.unlock(); } else if (strcmp(interface, wl_seat_interface.name) == 0) { g_pHyprpaper->createSeat(makeShared((wl_proxy*)wl_registry_bind((wl_registry*)registry->resource(), name, &wl_seat_interface, 7))); } else if (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) { g_pHyprpaper->m_pLayerShell = makeShared((wl_proxy*)wl_registry_bind((wl_registry*)registry->resource(), name, &zwlr_layer_shell_v1_interface, 1)); } else if (strcmp(interface, wp_fractional_scale_manager_v1_interface.name) == 0 && !g_pHyprpaper->m_bNoFractionalScale) { g_pHyprpaper->m_pFractionalScale = makeShared((wl_proxy*)wl_registry_bind((wl_registry*)registry->resource(), name, &wp_fractional_scale_manager_v1_interface, 1)); } else if (strcmp(interface, wp_viewporter_interface.name) == 0) { g_pHyprpaper->m_pViewporter = makeShared((wl_proxy*)wl_registry_bind((wl_registry*)registry->resource(), name, &wp_viewporter_interface, 1)); } else if (strcmp(interface, wp_cursor_shape_manager_v1_interface.name) == 0) { g_pHyprpaper->m_pCursorShape = makeShared((wl_proxy*)wl_registry_bind((wl_registry*)registry->resource(), name, &wp_cursor_shape_manager_v1_interface, 1)); } } static void handleGlobalRemove(CCWlRegistry* registry, uint32_t name) { for (auto& m : g_pHyprpaper->m_vMonitors) { if (m->wayland_name == name) { Debug::log(LOG, "Destroying output {}", m->name); g_pHyprpaper->clearWallpaperFromMonitor(m->name); std::erase_if(g_pHyprpaper->m_vMonitors, [&](const auto& other) { return other->wayland_name == name; }); return; } } } void CHyprpaper::init() { if (!lockSingleInstance()) { Debug::log(CRIT, "Cannot launch multiple instances of Hyprpaper at once!"); exit(1); } removeOldHyprpaperImages(); m_sDisplay = (wl_display*)wl_display_connect(nullptr); if (!m_sDisplay) { Debug::log(CRIT, "No wayland compositor running!"); exit(1); } // run auto REGISTRY = makeShared((wl_proxy*)wl_display_get_registry(m_sDisplay)); REGISTRY->setGlobal(::handleGlobal); REGISTRY->setGlobalRemove(::handleGlobalRemove); wl_display_roundtrip(m_sDisplay); while (m_vMonitors.size() < 1 || m_vMonitors[0]->name.empty()) { wl_display_dispatch(m_sDisplay); } g_pConfigManager = std::make_unique(); g_pIPCSocket = std::make_unique(); g_pConfigManager->parse(); preloadAllWallpapersFromConfig(); if (std::any_cast(g_pConfigManager->config->getConfigValue("ipc"))) g_pIPCSocket->initialize(); do { std::lock_guard lg(m_mtTickMutex); tick(true); } while (wl_display_dispatch(m_sDisplay) != -1); unlockSingleInstance(); } void CHyprpaper::tick(bool force) { bool reload = g_pIPCSocket && g_pIPCSocket->mainThreadParseRequest(); if (!reload && !force) return; preloadAllWallpapersFromConfig(); ensurePoolBuffersPresent(); recheckAllMonitors(); } bool CHyprpaper::isPreloaded(const std::string& path) { for (auto& [pt, wt] : m_mWallpaperTargets) { if (pt == path) return true; } return false; } void CHyprpaper::unloadWallpaper(const std::string& path) { bool found = false; for (auto& [ewp, cls] : m_mWallpaperTargets) { if (ewp == path) { // found found = true; break; } } if (!found) { Debug::log(LOG, "Cannot unload a target that was not loaded!"); return; } // clean buffers for (auto it = m_vBuffers.begin(); it != m_vBuffers.end();) { if (it->get()->target != path) { it++; continue; } const auto PRELOADPATH = it->get()->name; Debug::log(LOG, "Unloading target {}, preload path {}", path, PRELOADPATH); std::filesystem::remove(PRELOADPATH); destroyBuffer(it->get()); it = m_vBuffers.erase(it); } m_mWallpaperTargets.erase(path); // will free the cairo surface } void CHyprpaper::preloadAllWallpapersFromConfig() { if (g_pConfigManager->m_dRequestedPreloads.empty()) return; for (auto& wp : g_pConfigManager->m_dRequestedPreloads) { // check if it doesnt exist bool exists = false; for (auto& [ewp, cls] : m_mWallpaperTargets) { if (ewp == wp) { Debug::log(LOG, "Ignoring request to preload {} as it already is preloaded!", ewp); exists = true; break; } } if (exists) continue; m_mWallpaperTargets[wp] = CWallpaperTarget(); if (std::filesystem::is_symlink(wp)) { auto real_wp = std::filesystem::read_symlink(wp); std::filesystem::path absolute_path = std::filesystem::path(wp).parent_path() / real_wp; absolute_path = absolute_path.lexically_normal(); m_mWallpaperTargets[wp].create(absolute_path); } else { m_mWallpaperTargets[wp].create(wp); } } g_pConfigManager->m_dRequestedPreloads.clear(); } void CHyprpaper::recheckAllMonitors() { for (auto& m : m_vMonitors) { recheckMonitor(m.get()); } } void CHyprpaper::createSeat(SP pSeat) { m_pSeat = pSeat; pSeat->setCapabilities([this](CCWlSeat* r, wl_seat_capability caps) { if (caps & WL_SEAT_CAPABILITY_POINTER) { m_pSeatPointer = makeShared(m_pSeat->sendGetPointer()); if (!m_pCursorShape) Debug::log(WARN, "No cursor-shape-v1 support from the compositor: cursor will be blank"); else m_pSeatCursorShapeDevice = makeShared(m_pCursorShape->sendGetPointer(m_pSeatPointer->resource())); m_pSeatPointer->setEnter([this](CCWlPointer* r, uint32_t serial, wl_proxy* surface, wl_fixed_t x, wl_fixed_t y) { if (!m_pCursorShape) { m_pSeatPointer->sendSetCursor(serial, nullptr, 0, 0); return; } m_pSeatCursorShapeDevice->sendSetShape(serial, wpCursorShapeDeviceV1Shape::WP_CURSOR_SHAPE_DEVICE_V1_SHAPE_DEFAULT); }); } else Debug::log(LOG, "No pointer capability from the compositor"); }); } void CHyprpaper::recheckMonitor(SMonitor* pMonitor) { ensureMonitorHasActiveWallpaper(pMonitor); if (pMonitor->wantsACK) { pMonitor->wantsACK = false; pMonitor->pCurrentLayerSurface->pLayerSurface->sendAckConfigure(pMonitor->configureSerial); } if (pMonitor->wantsReload) { pMonitor->wantsReload = false; renderWallpaperForMonitor(pMonitor); } } void CHyprpaper::removeOldHyprpaperImages() { int cleaned = 0; uint64_t memoryFreed = 0; for (const auto& entry : std::filesystem::directory_iterator(std::string(getenv("XDG_RUNTIME_DIR")))) { if (entry.is_directory()) continue; const auto FILENAME = entry.path().filename().string(); if (FILENAME.contains(".hyprpaper_")) { // unlink it memoryFreed += entry.file_size(); if (!std::filesystem::remove(entry.path())) Debug::log(LOG, "Couldn't remove {}", entry.path().string()); cleaned++; } } if (cleaned != 0) Debug::log(LOG, "Cleaned old hyprpaper preloads ({}), removing {:.1f}MB", cleaned, ((float)memoryFreed) / 1000000.f); } SMonitor* CHyprpaper::getMonitorFromName(const std::string& monname) { bool useDesc = false; std::string desc = ""; if (monname.find("desc:") == 0) { useDesc = true; desc = monname.substr(5); } for (auto& m : m_vMonitors) { if (useDesc && m->description.find(desc) == 0) return m.get(); if (m->name == monname) return m.get(); } return nullptr; } void CHyprpaper::ensurePoolBuffersPresent() { bool anyNewBuffers = false; for (auto& [file, wt] : m_mWallpaperTargets) { for (auto& m : m_vMonitors) { if (m->size == Vector2D()) continue; auto it = std::find_if(m_vBuffers.begin(), m_vBuffers.end(), [wt = &wt, &m](const std::unique_ptr& el) { auto scale = std::round((m->pCurrentLayerSurface && m->pCurrentLayerSurface->pFractionalScaleInfo ? m->pCurrentLayerSurface->fScale : m->scale) * 120.0) / 120.0; return el->target == wt->m_szPath && vectorDeltaLessThan(el->pixelSize, m->size * scale, 1); }); if (it == m_vBuffers.end()) { // create const auto PBUFFER = m_vBuffers.emplace_back(std::make_unique()).get(); auto scale = std::round((m->pCurrentLayerSurface && m->pCurrentLayerSurface->pFractionalScaleInfo ? m->pCurrentLayerSurface->fScale : m->scale) * 120.0) / 120.0; createBuffer(PBUFFER, m->size.x * scale, m->size.y * scale, WL_SHM_FORMAT_ARGB8888); PBUFFER->target = wt.m_szPath; Debug::log(LOG, "Buffer created for target {}, Shared Memory usage: {:.1f}MB", wt.m_szPath, PBUFFER->size / 1000000.f); anyNewBuffers = true; } } } if (anyNewBuffers) { uint64_t bytesUsed = 0; for (auto& bf : m_vBuffers) { bytesUsed += bf->size; } Debug::log(LOG, "Total SM usage for all buffers: {:.1f}MB", bytesUsed / 1000000.f); } } void CHyprpaper::clearWallpaperFromMonitor(const std::string& monname) { const auto PMONITOR = getMonitorFromName(monname); if (!PMONITOR) return; auto it = m_mMonitorActiveWallpaperTargets.find(PMONITOR); if (it != m_mMonitorActiveWallpaperTargets.end()) m_mMonitorActiveWallpaperTargets.erase(it); PMONITOR->hasATarget = true; if (PMONITOR->pCurrentLayerSurface) { PMONITOR->pCurrentLayerSurface = nullptr; PMONITOR->wantsACK = false; PMONITOR->wantsReload = false; PMONITOR->initialized = false; PMONITOR->readyForLS = true; } } void CHyprpaper::ensureMonitorHasActiveWallpaper(SMonitor* pMonitor) { if (!pMonitor->readyForLS || !pMonitor->hasATarget) return; auto it = m_mMonitorActiveWallpaperTargets.find(pMonitor); if (it == m_mMonitorActiveWallpaperTargets.end()) { m_mMonitorActiveWallpaperTargets[pMonitor] = nullptr; it = m_mMonitorActiveWallpaperTargets.find(pMonitor); } if (it->second) return; // has // get the target for (auto& [mon, path1] : m_mMonitorActiveWallpapers) { if (mon.find("desc:") != 0) continue; if (pMonitor->description.find(mon.substr(5)) == 0) { for (auto& [path2, target] : m_mWallpaperTargets) { if (path1 == path2) { it->second = ⌖ break; } } break; } } if (!it->second) { for (auto& [mon, path1] : m_mMonitorActiveWallpapers) { if (mon == pMonitor->name) { for (auto& [path2, target] : m_mWallpaperTargets) { if (path1 == path2) { it->second = ⌖ break; } } break; } } } if (!it->second) { // try to find a wildcard for (auto& [mon, path1] : m_mMonitorActiveWallpapers) { if (mon.empty()) { for (auto& [path2, target] : m_mWallpaperTargets) { if (path1 == path2) { it->second = ⌖ break; } } break; } } } if (!it->second) { pMonitor->hasATarget = false; Debug::log(WARN, "Monitor {} does not have a target! A wallpaper will not be created.", pMonitor->name); return; } // create it for thy if it doesnt have if (!pMonitor->pCurrentLayerSurface) createLSForMonitor(pMonitor); else pMonitor->wantsReload = true; } void CHyprpaper::createLSForMonitor(SMonitor* pMonitor) { pMonitor->pCurrentLayerSurface = pMonitor->layerSurfaces.emplace_back(std::make_unique(pMonitor)).get(); } bool CHyprpaper::setCloexec(const int& FD) { long flags = fcntl(FD, F_GETFD); if (flags == -1) { return false; } if (fcntl(FD, F_SETFD, flags | FD_CLOEXEC) == -1) { return false; } return true; } int CHyprpaper::createPoolFile(size_t size, std::string& name) { const auto XDGRUNTIMEDIR = getenv("XDG_RUNTIME_DIR"); if (!XDGRUNTIMEDIR) { Debug::log(CRIT, "XDG_RUNTIME_DIR not set!"); exit(1); } name = std::string(XDGRUNTIMEDIR) + "/.hyprpaper_XXXXXX"; const auto FD = mkstemp((char*)name.c_str()); if (FD < 0) { Debug::log(CRIT, "createPoolFile: fd < 0"); exit(1); } if (!setCloexec(FD)) { close(FD); Debug::log(CRIT, "createPoolFile: !setCloexec"); exit(1); } if (ftruncate(FD, size) < 0) { close(FD); Debug::log(CRIT, "createPoolFile: ftruncate < 0"); exit(1); } return FD; } void CHyprpaper::createBuffer(SPoolBuffer* pBuffer, int32_t w, int32_t h, uint32_t format) { const size_t STRIDE = w * 4; const size_t SIZE = STRIDE * h; std::string name; const auto FD = createPoolFile(SIZE, name); if (FD == -1) { Debug::log(CRIT, "Unable to create pool file!"); exit(1); } const auto DATA = mmap(nullptr, SIZE, PROT_READ | PROT_WRITE, MAP_SHARED, FD, 0); auto POOL = makeShared(g_pHyprpaper->m_pSHM->sendCreatePool(FD, SIZE)); pBuffer->buffer = makeShared(POOL->sendCreateBuffer(0, w, h, STRIDE, format)); POOL.reset(); close(FD); pBuffer->size = SIZE; pBuffer->data = DATA; pBuffer->surface = cairo_image_surface_create_for_data((unsigned char*)DATA, CAIRO_FORMAT_ARGB32, w, h, STRIDE); pBuffer->cairo = cairo_create(pBuffer->surface); pBuffer->pixelSize = Vector2D(w, h); pBuffer->name = name; } void CHyprpaper::destroyBuffer(SPoolBuffer* pBuffer) { pBuffer->buffer.reset(); cairo_destroy(pBuffer->cairo); cairo_surface_destroy(pBuffer->surface); munmap(pBuffer->data, pBuffer->size); pBuffer->buffer = nullptr; } SPoolBuffer* CHyprpaper::getPoolBuffer(SMonitor* pMonitor, CWallpaperTarget* pWallpaperTarget) { const auto IT = std::find_if(m_vBuffers.begin(), m_vBuffers.end(), [&](const std::unique_ptr& el) { auto scale = std::round((pMonitor->pCurrentLayerSurface && pMonitor->pCurrentLayerSurface->pFractionalScaleInfo ? pMonitor->pCurrentLayerSurface->fScale : pMonitor->scale) * 120.0) / 120.0; return el->target == pWallpaperTarget->m_szPath && vectorDeltaLessThan(el->pixelSize, pMonitor->size * scale, 1); }); if (IT == m_vBuffers.end()) return nullptr; return IT->get(); } void CHyprpaper::renderWallpaperForMonitor(SMonitor* pMonitor) { static auto PRENDERSPLASH = Hyprlang::CSimpleConfigValue(g_pConfigManager->config.get(), "splash"); static auto PSPLASHOFFSET = Hyprlang::CSimpleConfigValue(g_pConfigManager->config.get(), "splash_offset"); if (!m_mMonitorActiveWallpaperTargets[pMonitor]) recheckMonitor(pMonitor); const auto PWALLPAPERTARGET = m_mMonitorActiveWallpaperTargets[pMonitor]; const auto CONTAIN = m_mMonitorWallpaperRenderData[pMonitor->name].contain; const auto TILE = m_mMonitorWallpaperRenderData[pMonitor->name].tile; if (!PWALLPAPERTARGET) { Debug::log(CRIT, "wallpaper target null in render??"); exit(1); } auto* PBUFFER = getPoolBuffer(pMonitor, PWALLPAPERTARGET); if (!PBUFFER) { Debug::log(LOG, "Pool buffer missing for available target??"); ensurePoolBuffersPresent(); PBUFFER = getPoolBuffer(pMonitor, PWALLPAPERTARGET); if (!PBUFFER) { Debug::log(LOG, "Pool buffer failed #2. Ignoring WP."); return; } } const double SURFACESCALE = pMonitor->pCurrentLayerSurface && pMonitor->pCurrentLayerSurface->pFractionalScaleInfo ? pMonitor->pCurrentLayerSurface->fScale : pMonitor->scale; const Vector2D DIMENSIONS = Vector2D{std::round(pMonitor->size.x * SURFACESCALE), std::round(pMonitor->size.y * SURFACESCALE)}; const auto PCAIRO = PBUFFER->cairo; cairo_save(PCAIRO); cairo_set_operator(PCAIRO, CAIRO_OPERATOR_CLEAR); cairo_paint(PCAIRO); cairo_restore(PCAIRO); // always draw a black background behind the wallpaper cairo_set_source_rgb(PCAIRO, 0, 0, 0); cairo_rectangle(PCAIRO, 0, 0, DIMENSIONS.x, DIMENSIONS.y); cairo_fill(PCAIRO); cairo_surface_flush(PBUFFER->surface); // get scale // we always do cover double scale; Vector2D origin; const bool LOWASPECTRATIO = pMonitor->size.x / pMonitor->size.y > PWALLPAPERTARGET->m_vSize.x / PWALLPAPERTARGET->m_vSize.y; if ((CONTAIN && !LOWASPECTRATIO) || (!CONTAIN && LOWASPECTRATIO)) { scale = DIMENSIONS.x / PWALLPAPERTARGET->m_vSize.x; origin.y = -(PWALLPAPERTARGET->m_vSize.y * scale - DIMENSIONS.y) / 2.0 / scale; } else { scale = DIMENSIONS.y / PWALLPAPERTARGET->m_vSize.y; origin.x = -(PWALLPAPERTARGET->m_vSize.x * scale - DIMENSIONS.x) / 2.0 / scale; } Debug::log(LOG, "Image data for {}: {} at [{:.2f}, {:.2f}], scale: {:.2f} (original image size: [{}, {}])", pMonitor->name, PWALLPAPERTARGET->m_szPath, origin.x, origin.y, scale, (int)PWALLPAPERTARGET->m_vSize.x, (int)PWALLPAPERTARGET->m_vSize.y); if (TILE) { cairo_pattern_t* pattern = cairo_pattern_create_for_surface(PWALLPAPERTARGET->m_pCairoSurface->cairo()); cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT); cairo_set_source(PCAIRO, pattern); } else { cairo_scale(PCAIRO, scale, scale); cairo_set_source_surface(PCAIRO, PWALLPAPERTARGET->m_pCairoSurface->cairo(), origin.x, origin.y); } cairo_paint(PCAIRO); if (*PRENDERSPLASH && getenv("HYPRLAND_INSTANCE_SIGNATURE")) { auto SPLASH = execAndGet("hyprctl splash"); if (!SPLASH.empty()) SPLASH.pop_back(); Debug::log(LOG, "Rendering splash: {}", SPLASH); cairo_select_font_face(PCAIRO, "Sans", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); const auto FONTSIZE = (int)(DIMENSIONS.y / 76.0 / scale); cairo_set_font_size(PCAIRO, FONTSIZE); static auto PSPLASHCOLOR = Hyprlang::CSimpleConfigValue(g_pConfigManager->config.get(), "splash_color"); Debug::log(LOG, "Splash color: {:x}", *PSPLASHCOLOR); cairo_set_source_rgba(PCAIRO, ((*PSPLASHCOLOR >> 16) & 0xFF) / 255.0, ((*PSPLASHCOLOR >> 8) & 0xFF) / 255.0, (*PSPLASHCOLOR & 0xFF) / 255.0, ((*PSPLASHCOLOR >> 24) & 0xFF) / 255.0); cairo_text_extents_t textExtents; cairo_text_extents(PCAIRO, SPLASH.c_str(), &textExtents); cairo_move_to(PCAIRO, ((DIMENSIONS.x - textExtents.width * scale) / 2.0) / scale, ((DIMENSIONS.y * (100 - *PSPLASHOFFSET)) / 100 - textExtents.height * scale) / scale); Debug::log(LOG, "Splash font size: {}, pos: {:.2f}, {:.2f}", FONTSIZE, (DIMENSIONS.x - textExtents.width) / 2.0 / scale, ((DIMENSIONS.y * (100 - *PSPLASHOFFSET)) / 100 - textExtents.height * scale) / scale); cairo_show_text(PCAIRO, SPLASH.c_str()); cairo_surface_flush(PWALLPAPERTARGET->m_pCairoSurface->cairo()); } cairo_restore(PCAIRO); if (pMonitor->pCurrentLayerSurface) { pMonitor->pCurrentLayerSurface->pSurface->sendAttach(PBUFFER->buffer.get(), 0, 0); pMonitor->pCurrentLayerSurface->pSurface->sendSetBufferScale(pMonitor->pCurrentLayerSurface->pFractionalScaleInfo ? 1 : pMonitor->scale); pMonitor->pCurrentLayerSurface->pSurface->sendDamageBuffer(0, 0, 0xFFFF, 0xFFFF); // our wps are always opaque auto opaqueRegion = makeShared(g_pHyprpaper->m_pCompositor->sendCreateRegion()); opaqueRegion->sendAdd(0, 0, PBUFFER->pixelSize.x, PBUFFER->pixelSize.y); pMonitor->pCurrentLayerSurface->pSurface->sendSetOpaqueRegion(opaqueRegion.get()); if (pMonitor->pCurrentLayerSurface->pFractionalScaleInfo) { Debug::log(LOG, "Submitting viewport dest size {}x{} for {:x}", static_cast(std::round(pMonitor->size.x)), static_cast(std::round(pMonitor->size.y)), (uintptr_t)pMonitor->pCurrentLayerSurface); pMonitor->pCurrentLayerSurface->pViewport->sendSetDestination(static_cast(std::round(pMonitor->size.x)), static_cast(std::round(pMonitor->size.y))); } pMonitor->pCurrentLayerSurface->pSurface->sendCommit(); } // check if we dont need to remove a wallpaper if (pMonitor->layerSurfaces.size() > 1) { for (auto it = pMonitor->layerSurfaces.begin(); it != pMonitor->layerSurfaces.end(); it++) { if (pMonitor->pCurrentLayerSurface != it->get()) { pMonitor->layerSurfaces.erase(it); break; } } } } bool CHyprpaper::lockSingleInstance() { const std::string XDG_RUNTIME_DIR = getenv("XDG_RUNTIME_DIR"); const auto LOCKFILE = XDG_RUNTIME_DIR + "/hyprpaper.lock"; if (std::filesystem::exists(LOCKFILE)) { std::ifstream ifs(LOCKFILE); std::string content((std::istreambuf_iterator(ifs)), (std::istreambuf_iterator())); try { kill(std::stoull(content), 0); if (errno != ESRCH) return false; } catch (std::exception& e) { ; } } // create lockfile std::ofstream ofs(LOCKFILE, std::ios::trunc); ofs << std::to_string(getpid()); ofs.close(); return true; } void CHyprpaper::unlockSingleInstance() { const std::string XDG_RUNTIME_DIR = getenv("XDG_RUNTIME_DIR"); const auto LOCKFILE = XDG_RUNTIME_DIR + "/hyprpaper.lock"; unlink(LOCKFILE.c_str()); } hyprpaper-0.7.6/src/Hyprpaper.hpp000066400000000000000000000100441507224720000170060ustar00rootroot00000000000000#pragma once #include "config/ConfigManager.hpp" #include "defines.hpp" #include "helpers/MiscFunctions.hpp" #include "helpers/Monitor.hpp" #include "helpers/PoolBuffer.hpp" #include "ipc/Socket.hpp" #include "render/WallpaperTarget.hpp" #include #include "protocols/cursor-shape-v1.hpp" #include "protocols/fractional-scale-v1.hpp" #include "protocols/linux-dmabuf-v1.hpp" #include "protocols/viewporter.hpp" #include "protocols/wayland.hpp" #include "protocols/wlr-layer-shell-unstable-v1.hpp" struct SWallpaperRenderData { bool contain = false; bool tile = false; }; class CHyprpaper { public: // important wl_display* m_sDisplay = nullptr; SP m_pCompositor; SP m_pSHM; SP m_pLayerShell; SP m_pFractionalScale; SP m_pViewporter; SP m_pSeat; SP m_pSeatPointer; SP m_pSeatCursorShapeDevice; SP m_pCursorShape; // init the utility CHyprpaper(); void init(); void tick(bool force); std::unordered_map m_mWallpaperTargets; std::unordered_map m_mMonitorActiveWallpapers; std::unordered_map m_mMonitorWallpaperRenderData; std::unordered_map m_mMonitorActiveWallpaperTargets; std::vector> m_vBuffers; std::vector> m_vMonitors; std::string m_szExplicitConfigPath; bool m_bNoFractionalScale = false; void removeOldHyprpaperImages(); void preloadAllWallpapersFromConfig(); void recheckAllMonitors(); void ensureMonitorHasActiveWallpaper(SMonitor*); void createLSForMonitor(SMonitor*); void renderWallpaperForMonitor(SMonitor*); void createBuffer(SPoolBuffer*, int32_t, int32_t, uint32_t); void destroyBuffer(SPoolBuffer*); int createPoolFile(size_t, std::string&); bool setCloexec(const int&); void clearWallpaperFromMonitor(const std::string&); SMonitor* getMonitorFromName(const std::string&); bool isPreloaded(const std::string&); void recheckMonitor(SMonitor*); void ensurePoolBuffersPresent(); SPoolBuffer* getPoolBuffer(SMonitor*, CWallpaperTarget*); void unloadWallpaper(const std::string&); void createSeat(SP); bool lockSingleInstance(); // fails on multi-instance void unlockSingleInstance(); std::mutex m_mtTickMutex; SMonitor* m_pLastMonitor = nullptr; private: bool m_bShouldExit = false; }; inline std::unique_ptr g_pHyprpaper; hyprpaper-0.7.6/src/config/000077500000000000000000000000001507224720000155715ustar00rootroot00000000000000hyprpaper-0.7.6/src/config/ConfigManager.cpp000066400000000000000000000206001507224720000207730ustar00rootroot00000000000000#include "ConfigManager.hpp" #include "../Hyprpaper.hpp" #include #include static Hyprlang::CParseResult handleWallpaper(const char* C, const char* V) { const std::string COMMAND = C; const std::string VALUE = V; Hyprlang::CParseResult result; if (VALUE.find_first_of(',') == std::string::npos) { result.setError("wallpaper failed (syntax)"); return result; } auto MONITOR = VALUE.substr(0, VALUE.find_first_of(',')); auto WALLPAPER = g_pConfigManager->trimPath(VALUE.substr(VALUE.find_first_of(',') + 1)); bool contain = false; if (WALLPAPER.find("contain:") == 0) { WALLPAPER = WALLPAPER.substr(8); contain = true; } bool tile = false; if (WALLPAPER.find("tile:") == 0) { WALLPAPER = WALLPAPER.substr(5); tile = true; } if (WALLPAPER[0] == '~') { static const char* const ENVHOME = getenv("HOME"); WALLPAPER = std::string(ENVHOME) + WALLPAPER.substr(1); } std::error_code ec; if (!std::filesystem::exists(WALLPAPER, ec)) { result.setError((std::string{"wallpaper failed ("} + (ec ? ec.message() : std::string{"no such file"}) + std::string{": "} + WALLPAPER + std::string{")"}).c_str()); return result; } if (std::find(g_pConfigManager->m_dRequestedPreloads.begin(), g_pConfigManager->m_dRequestedPreloads.end(), WALLPAPER) == g_pConfigManager->m_dRequestedPreloads.end() && !g_pHyprpaper->isPreloaded(WALLPAPER)) { result.setError("wallpaper failed (not preloaded)"); return result; } g_pHyprpaper->clearWallpaperFromMonitor(MONITOR); g_pHyprpaper->m_mMonitorActiveWallpapers[MONITOR] = WALLPAPER; g_pHyprpaper->m_mMonitorWallpaperRenderData[MONITOR].contain = contain; g_pHyprpaper->m_mMonitorWallpaperRenderData[MONITOR].tile = tile; if (MONITOR.empty()) { for (auto& m : g_pHyprpaper->m_vMonitors) { if (!m->hasATarget || m->wildcard) { g_pHyprpaper->clearWallpaperFromMonitor(m->name); g_pHyprpaper->m_mMonitorActiveWallpapers[m->name] = WALLPAPER; g_pHyprpaper->m_mMonitorWallpaperRenderData[m->name].contain = contain; g_pHyprpaper->m_mMonitorWallpaperRenderData[m->name].tile = tile; } } } else { const auto PMON = g_pHyprpaper->getMonitorFromName(MONITOR); if (PMON) PMON->wildcard = false; } return result; } static Hyprlang::CParseResult handlePreload(const char* C, const char* V) { const std::string COMMAND = C; const std::string VALUE = V; auto WALLPAPER = VALUE; if (WALLPAPER[0] == '~') { static const char* const ENVHOME = getenv("HOME"); WALLPAPER = std::string(ENVHOME) + WALLPAPER.substr(1); } std::error_code ec; if (!std::filesystem::exists(WALLPAPER, ec)) { Hyprlang::CParseResult result; result.setError(((ec ? ec.message() : std::string{"no such file"}) + std::string{": "} + WALLPAPER).c_str()); return result; } g_pConfigManager->m_dRequestedPreloads.emplace_back(WALLPAPER); return Hyprlang::CParseResult{}; } static Hyprlang::CParseResult handleUnloadAll(const char* C, const char* V) { const std::string COMMAND = C; const std::string VALUE = V; std::vector toUnload; for (auto& [name, target] : g_pHyprpaper->m_mWallpaperTargets) { if (VALUE == "unused") { bool exists = false; for (auto& [mon, target2] : g_pHyprpaper->m_mMonitorActiveWallpaperTargets) { if (&target == target2) { exists = true; break; } } if (exists) continue; } toUnload.emplace_back(name); } for (auto& tu : toUnload) g_pHyprpaper->unloadWallpaper(tu); return Hyprlang::CParseResult{}; } static Hyprlang::CParseResult handleUnload(const char* C, const char* V) { const std::string COMMAND = C; const std::string VALUE = V; auto WALLPAPER = VALUE; if (VALUE == "all" || VALUE == "unused") return handleUnloadAll(C, V); if (WALLPAPER[0] == '~') { static const char* const ENVHOME = getenv("HOME"); WALLPAPER = std::string(ENVHOME) + WALLPAPER.substr(1); } g_pHyprpaper->unloadWallpaper(WALLPAPER); return Hyprlang::CParseResult{}; } static Hyprlang::CParseResult handleReload(const char* C, const char* V) { const std::string COMMAND = C; const std::string VALUE = V; auto WALLPAPER = g_pConfigManager->trimPath(VALUE.substr(VALUE.find_first_of(',') + 1)); if (WALLPAPER.find("contain:") == 0) { WALLPAPER = WALLPAPER.substr(8); } if (WALLPAPER.find("tile:") == 0) WALLPAPER = WALLPAPER.substr(5); auto preloadResult = handlePreload(C, WALLPAPER.c_str()); if (preloadResult.error) return preloadResult; auto MONITOR = VALUE.substr(0, VALUE.find_first_of(',')); if (MONITOR.empty()) { for (auto& m : g_pHyprpaper->m_vMonitors) { auto OLD_WALLPAPER = g_pHyprpaper->m_mMonitorActiveWallpapers[m->name]; g_pHyprpaper->unloadWallpaper(OLD_WALLPAPER); } } else { auto OLD_WALLPAPER = g_pHyprpaper->m_mMonitorActiveWallpapers[MONITOR]; g_pHyprpaper->unloadWallpaper(OLD_WALLPAPER); } auto wallpaperResult = handleWallpaper(C, V); if (wallpaperResult.error) return wallpaperResult; return Hyprlang::CParseResult{}; } static Hyprlang::CParseResult handleSource(const char* C, const char* V) { Hyprlang::CParseResult result; const std::string path = g_pConfigManager->absolutePath(V); std::error_code ec; if (!std::filesystem::exists(path, ec)) { result.setError((ec ? ec.message() : "no such file").c_str()); return result; } g_pConfigManager->config->parseFile(path.c_str()); return result; } CConfigManager::CConfigManager() { // Initialize the configuration // Read file from default location // or from an explicit location given by user std::string configPath = getMainConfigPath(); config = std::make_unique(configPath.c_str(), Hyprlang::SConfigOptions{.allowMissingConfig = true}); config->addConfigValue("ipc", Hyprlang::INT{1L}); config->addConfigValue("splash", Hyprlang::INT{0L}); config->addConfigValue("splash_offset", Hyprlang::FLOAT{2.F}); config->addConfigValue("splash_color", Hyprlang::INT{0x55ffffff}); config->registerHandler(&handleWallpaper, "wallpaper", {.allowFlags = false}); config->registerHandler(&handleUnload, "unload", {.allowFlags = false}); config->registerHandler(&handlePreload, "preload", {.allowFlags = false}); config->registerHandler(&handleUnloadAll, "unloadAll", {.allowFlags = false}); config->registerHandler(&handleReload, "reload", {.allowFlags = false}); config->registerHandler(&handleSource, "source", {.allowFlags = false}); config->commence(); } void CConfigManager::parse() { const auto ERROR = config->parse(); if (ERROR.error) std::cout << "Error in config: \n" << ERROR.getError() << "\n"; } std::string CConfigManager::getMainConfigPath() { if (!g_pHyprpaper->m_szExplicitConfigPath.empty()) return g_pHyprpaper->m_szExplicitConfigPath; static const auto paths = Hyprutils::Path::findConfig("hyprpaper"); if (paths.first.has_value()) return paths.first.value(); else return ""; } // trim from both ends std::string CConfigManager::trimPath(std::string path) { if (path.empty()) return ""; // trims whitespaces, tabs and new line feeds size_t pathStartIndex = path.find_first_not_of(" \t\r\n"); size_t pathEndIndex = path.find_last_not_of(" \t\r\n"); return path.substr(pathStartIndex, pathEndIndex - pathStartIndex + 1); } std::string CConfigManager::absolutePath(const std::string& path) { if (path.empty()) return ""; std::string result = path; if (result[0] == '~') { const char* home = getenv("HOME"); if (home) result = std::string(home) + result.substr(1); } return std::filesystem::absolute(result).string(); } hyprpaper-0.7.6/src/config/ConfigManager.hpp000066400000000000000000000012041507224720000207770ustar00rootroot00000000000000#pragma once #include "../defines.hpp" #include class CIPCSocket; class CConfigManager { public: // gets all the data from the config CConfigManager(); void parse(); std::deque m_dRequestedPreloads; std::string getMainConfigPath(); std::string trimPath(std::string path); std::string absolutePath(const std::string& path); std::unique_ptr config; private: friend class CIPCSocket; }; inline std::unique_ptr g_pConfigManager; hyprpaper-0.7.6/src/debug/000077500000000000000000000000001507224720000154125ustar00rootroot00000000000000hyprpaper-0.7.6/src/debug/Log.hpp000066400000000000000000000042171507224720000166500ustar00rootroot00000000000000#pragma once #include #include #include enum eLogLevel { TRACE = 0, INFO, LOG, WARN, ERR, CRIT, NONE }; #define RASSERT(expr, reason, ...) \ if (!(expr)) { \ Debug::log(CRIT, "\n==========================================================================================\nASSERTION FAILED! \n\n{}\n\nat: line {} in {}", \ std::format(reason, ##__VA_ARGS__), __LINE__, \ ([]() constexpr -> std::string { return std::string(__FILE__).substr(std::string(__FILE__).find_last_of('/') + 1); })().c_str()); \ std::abort(); \ } #define ASSERT(expr) RASSERT(expr, "?") namespace Debug { inline bool quiet = false; inline bool verbose = false; template void log(eLogLevel level, const std::string& fmt, Args&&... args) { if (!verbose && level == TRACE) return; if (quiet) return; if (level != NONE) { std::cout << '['; switch (level) { case TRACE: std::cout << "TRACE"; break; case INFO: std::cout << "INFO"; break; case LOG: std::cout << "LOG"; break; case WARN: std::cout << "WARN"; break; case ERR: std::cout << "ERR"; break; case CRIT: std::cout << "CRITICAL"; break; default: break; } std::cout << "] "; } std::cout << std::vformat(fmt, std::make_format_args(args...)) << std::endl; } };hyprpaper-0.7.6/src/defines.hpp000066400000000000000000000010261507224720000164510ustar00rootroot00000000000000#pragma once #include "includes.hpp" #include "debug/Log.hpp" // git stuff #ifndef GIT_COMMIT_HASH #define GIT_COMMIT_HASH "?" #endif #ifndef GIT_BRANCH #define GIT_BRANCH "?" #endif #ifndef GIT_COMMIT_MESSAGE #define GIT_COMMIT_MESSAGE "?" #endif #ifndef GIT_DIRTY #define GIT_DIRTY "?" #endif #include using namespace Hyprutils::Math; #include using namespace Hyprutils::Memory; #define SP Hyprutils::Memory::CSharedPointer #define WP Hyprutils::Memory::CWeakPointer hyprpaper-0.7.6/src/helpers/000077500000000000000000000000001507224720000157665ustar00rootroot00000000000000hyprpaper-0.7.6/src/helpers/MiscFunctions.cpp000066400000000000000000000012051507224720000212540ustar00rootroot00000000000000#include "MiscFunctions.hpp" #include #include "../debug/Log.hpp" #include #include using namespace Hyprutils::OS; bool vectorDeltaLessThan(const Vector2D& a, const Vector2D& b, const float& delta) { return std::abs(a.x - b.x) < delta && std::abs(a.y - b.y) < delta; } bool vectorDeltaLessThan(const Vector2D& a, const Vector2D& b, const Vector2D& delta) { return std::abs(a.x - b.x) < delta.x && std::abs(a.y - b.y) < delta.y; } std::string execAndGet(const char* cmd) { CProcess proc("/bin/bash", {"-c", cmd}); if (!proc.runSync()) return ""; return proc.stdOut(); } hyprpaper-0.7.6/src/helpers/MiscFunctions.hpp000066400000000000000000000004271507224720000212660ustar00rootroot00000000000000#pragma once #include #include "../defines.hpp" bool vectorDeltaLessThan(const Vector2D& a, const Vector2D& b, const float& delta); bool vectorDeltaLessThan(const Vector2D& a, const Vector2D& b, const Vector2D& delta); std::string execAndGet(const char*);hyprpaper-0.7.6/src/helpers/Monitor.cpp000066400000000000000000000031111507224720000201150ustar00rootroot00000000000000#include "Monitor.hpp" #include "../Hyprpaper.hpp" #include "MiscFunctions.hpp" void SMonitor::registerListeners() { output->setMode([this](CCWlOutput* r, uint32_t flags, int32_t width, int32_t height, int32_t refresh) { size = Vector2D(width, height); //ensures any transforms are also taken care of when setting the mode if (transform & 1) std::swap(size.x, size.y); }); output->setDone([this](CCWlOutput* r) { readyForLS = true; std::lock_guard lg(g_pHyprpaper->m_mtTickMutex); if (g_pConfigManager) // don't tick if this is the first roundtrip g_pHyprpaper->tick(true); }); output->setScale([this](CCWlOutput* r, int32_t scale_) { scale = scale_; }); output->setName([this](CCWlOutput* r, const char* name_) { name = name_; }); output->setDescription([this](CCWlOutput* r, const char* desc_) { std::string desc = desc_; std::erase(desc, ','); description = desc; }); output->setGeometry([this](CCWlOutput* r, int32_t x, int32_t y, int32_t width_mm, int32_t height_mm, int32_t subpixel, const char* make, const char* model, int32_t transform_) { // /* see https://wayland.freedesktop.org/docs/html/apa.html#protocol-spec-wl_output-enum-transform If there is a difference in parity of the old vs new transforms, the size needs to be swapped. */ if ((transform ^ transform_) & 1) std::swap(size.x, size.y); transform = (wl_output_transform)transform_; }); } hyprpaper-0.7.6/src/helpers/Monitor.hpp000066400000000000000000000025171507224720000201330ustar00rootroot00000000000000#pragma once #include "../defines.hpp" #include "../render/LayerSurface.hpp" #include "PoolBuffer.hpp" #include "protocols/wayland.hpp" struct SMonitor { std::string name = ""; std::string description = ""; SP output; uint32_t wayland_name = 0; Vector2D size; int scale; wl_output_transform transform = WL_OUTPUT_TRANSFORM_NORMAL; bool readyForLS = false; bool hasATarget = true; bool wildcard = true; uint32_t configureSerial = 0; SPoolBuffer buffer; bool wantsReload = false; bool wantsACK = false; bool initialized = false; std::vector> layerSurfaces; CLayerSurface* pCurrentLayerSurface = nullptr; void registerListeners(); };hyprpaper-0.7.6/src/helpers/PoolBuffer.hpp000066400000000000000000000006421507224720000205440ustar00rootroot00000000000000#pragma once #include "../defines.hpp" #include "protocols/wayland.hpp" class CWallpaperTarget; struct SPoolBuffer { SP buffer = nullptr; cairo_surface_t* surface = nullptr; cairo_t* cairo = nullptr; void* data = nullptr; size_t size = 0; std::string name = ""; std::string target = ""; Vector2D pixelSize; };hyprpaper-0.7.6/src/includes.hpp000066400000000000000000000006461507224720000166510ustar00rootroot00000000000000#pragma once #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include hyprpaper-0.7.6/src/ipc/000077500000000000000000000000001507224720000150775ustar00rootroot00000000000000hyprpaper-0.7.6/src/ipc/Socket.cpp000066400000000000000000000124701507224720000170370ustar00rootroot00000000000000#include "Socket.hpp" #include "../Hyprpaper.hpp" #include #include #include #include #include #include #include #include #include #include #include #include void CIPCSocket::initialize() { std::thread([&]() { const auto SOCKET = socket(AF_UNIX, SOCK_STREAM, 0); if (SOCKET < 0) { Debug::log(ERR, "Couldn't start the hyprpaper Socket. (1) IPC will not work."); return; } sockaddr_un SERVERADDRESS = {.sun_family = AF_UNIX}; const auto HISenv = getenv("HYPRLAND_INSTANCE_SIGNATURE"); const auto RUNTIMEdir = getenv("XDG_RUNTIME_DIR"); const std::string USERID = std::to_string(getpwuid(getuid())->pw_uid); const auto USERDIR = RUNTIMEdir ? RUNTIMEdir + std::string{"/hypr/"} : "/run/user/" + USERID + "/hypr/"; std::string socketPath = HISenv ? USERDIR + std::string(HISenv) + "/.hyprpaper.sock" : USERDIR + ".hyprpaper.sock"; if (!HISenv) mkdir(USERDIR.c_str(), S_IRWXU); unlink(socketPath.c_str()); strcpy(SERVERADDRESS.sun_path, socketPath.c_str()); bind(SOCKET, (sockaddr*)&SERVERADDRESS, SUN_LEN(&SERVERADDRESS)); // 10 max queued. listen(SOCKET, 10); sockaddr_in clientAddress = {}; socklen_t clientSize = sizeof(clientAddress); char readBuffer[1024] = {0}; Debug::log(LOG, "hyprpaper socket started at {} (fd: {})", socketPath, SOCKET); while (1) { const auto ACCEPTEDCONNECTION = accept(SOCKET, (sockaddr*)&clientAddress, &clientSize); if (ACCEPTEDCONNECTION < 0) { Debug::log(ERR, "Couldn't listen on the hyprpaper Socket. (3) IPC will not work."); break; } else { do { Debug::log(LOG, "Accepted incoming socket connection request on fd {}", ACCEPTEDCONNECTION); std::lock_guard lg(g_pHyprpaper->m_mtTickMutex); auto messageSize = read(ACCEPTEDCONNECTION, readBuffer, 1024); readBuffer[messageSize == 1024 ? 1023 : messageSize] = '\0'; if (messageSize == 0) break; std::string request(readBuffer); m_szRequest = request; m_bRequestReady = true; g_pHyprpaper->tick(true); while (!m_bReplyReady) { // wait for Hyprpaper to finish processing the request std::this_thread::sleep_for(std::chrono::milliseconds(1)); } write(ACCEPTEDCONNECTION, m_szReply.c_str(), m_szReply.length()); m_bReplyReady = false; m_szReply = ""; } while (1); Debug::log(LOG, "Closing Accepted Connection"); close(ACCEPTEDCONNECTION); } } close(SOCKET); }).detach(); } bool CIPCSocket::mainThreadParseRequest() { if (!m_bRequestReady) return false; std::string copy = m_szRequest; if (copy == "") return false; // now we can work on the copy Debug::log(LOG, "Received a request: {}", copy); // set default reply m_szReply = "ok"; m_bReplyReady = true; m_bRequestReady = false; // config commands if (copy.find("wallpaper") == 0 || copy.find("preload") == 0 || copy.find("unload") == 0 || copy.find("reload") == 0) { const auto RESULT = g_pConfigManager->config->parseDynamic(copy.substr(0, copy.find_first_of(' ')).c_str(), copy.substr(copy.find_first_of(' ') + 1).c_str()); if (RESULT.error) { m_szReply = RESULT.getError(); return false; } return true; } if (copy.find("listloaded") == 0) { const auto numWallpapersLoaded = g_pHyprpaper->m_mWallpaperTargets.size(); Debug::log(LOG, "numWallpapersLoaded: {}", numWallpapersLoaded); if (numWallpapersLoaded == 0) { m_szReply = "no wallpapers loaded"; return false; } m_szReply = ""; long unsigned int i = 0; for (auto& [name, target] : g_pHyprpaper->m_mWallpaperTargets) { m_szReply += name; i++; if (i < numWallpapersLoaded) m_szReply += '\n'; // dont add newline on last entry } return true; } if (copy.find("listactive") == 0) { const auto numWallpapersActive = g_pHyprpaper->m_mMonitorActiveWallpapers.size(); Debug::log(LOG, "numWallpapersActive: {}", numWallpapersActive); if (numWallpapersActive == 0) { m_szReply = "no wallpapers active"; return false; } m_szReply = ""; long unsigned int i = 0; for (auto& [mon, path1] : g_pHyprpaper->m_mMonitorActiveWallpapers) { m_szReply += mon + " = " + path1; i++; if (i < numWallpapersActive) m_szReply += '\n'; // dont add newline on last entry } return true; } m_szReply = "invalid command"; return false; } hyprpaper-0.7.6/src/ipc/Socket.hpp000066400000000000000000000006131507224720000170400ustar00rootroot00000000000000#pragma once #include "../defines.hpp" #include class CIPCSocket { public: void initialize(); bool mainThreadParseRequest(); private: std::mutex m_mtRequestMutex; std::string m_szRequest = ""; std::string m_szReply = ""; bool m_bRequestReady = false; bool m_bReplyReady = false; }; inline std::unique_ptr g_pIPCSocket;hyprpaper-0.7.6/src/main.cpp000066400000000000000000000025271507224720000157620ustar00rootroot00000000000000#include #include "defines.hpp" #include "Hyprpaper.hpp" int main(int argc, char** argv, char** envp) { Debug::log(LOG, "Welcome to hyprpaper!\nbuilt from commit {} ({})", GIT_COMMIT_HASH, GIT_COMMIT_MESSAGE); // parse some args std::string configPath; bool noFractional = false; for (int i = 1; i < argc; ++i) { if ((!strcmp(argv[i], "-c") || !strcmp(argv[i], "--config")) && argc >= i + 2) { configPath = std::string(argv[++i]); Debug::log(LOG, "Using config location {}.", configPath); } else if (!strcmp(argv[i], "--no-fractional") || !strcmp(argv[i], "-n")) { noFractional = true; Debug::log(LOG, "Disabling fractional scaling support!"); } else { std::cout << "Hyprpaper usage: hyprpaper [arg [...]].\n\nArguments:\n" << "--help -h | Show this help message\n" << "--config -c | Specify config file to use\n" << "--no-fractional -n | Disable fractional scaling support\n"; return 1; } } // starts g_pHyprpaper = std::make_unique(); g_pHyprpaper->m_szExplicitConfigPath = configPath; g_pHyprpaper->m_bNoFractionalScale = noFractional; g_pHyprpaper->init(); return 0; } hyprpaper-0.7.6/src/render/000077500000000000000000000000001507224720000156035ustar00rootroot00000000000000hyprpaper-0.7.6/src/render/LayerSurface.cpp000066400000000000000000000072671507224720000207100ustar00rootroot00000000000000#include "LayerSurface.hpp" #include "../Hyprpaper.hpp" CLayerSurface::CLayerSurface(SMonitor* pMonitor) { m_pMonitor = pMonitor; pSurface = makeShared(g_pHyprpaper->m_pCompositor->sendCreateSurface()); if (!pSurface) { Debug::log(CRIT, "The compositor did not allow hyprpaper a surface!"); exit(1); } const auto PINPUTREGION = makeShared(g_pHyprpaper->m_pCompositor->sendCreateRegion()); if (!PINPUTREGION) { Debug::log(CRIT, "The compositor did not allow hyprpaper a region!"); exit(1); } pSurface->sendSetInputRegion(PINPUTREGION.get()); pLayerSurface = makeShared( g_pHyprpaper->m_pLayerShell->sendGetLayerSurface(pSurface->resource(), pMonitor->output->resource(), ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND, "hyprpaper")); if (!pLayerSurface) { Debug::log(CRIT, "The compositor did not allow hyprpaper a layersurface!"); exit(1); } pLayerSurface->sendSetSize(0, 0); pLayerSurface->sendSetAnchor((zwlrLayerSurfaceV1Anchor)(ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP | ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT | ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM | ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT)); pLayerSurface->sendSetExclusiveZone(-1); pLayerSurface->setConfigure([this](CCZwlrLayerSurfaceV1* r, uint32_t serial, uint32_t x, uint32_t y) { m_pMonitor->size = Vector2D((double)x, (double)y); m_pMonitor->wantsReload = true; m_pMonitor->configureSerial = serial; m_pMonitor->wantsACK = true; m_pMonitor->initialized = true; Debug::log(LOG, "configure for {}", m_pMonitor->name); }); pLayerSurface->setClosed([this](CCZwlrLayerSurfaceV1* r) { for (auto& m : g_pHyprpaper->m_vMonitors) { std::erase_if(m->layerSurfaces, [&](const auto& other) { return other.get() == this; }); if (m->pCurrentLayerSurface == this) { if (m->layerSurfaces.empty()) { m->pCurrentLayerSurface = nullptr; } else { m->pCurrentLayerSurface = m->layerSurfaces.begin()->get(); g_pHyprpaper->recheckMonitor(m.get()); } } } }); pSurface->sendCommit(); // fractional scale, if supported by the compositor if (g_pHyprpaper->m_pFractionalScale && g_pHyprpaper->m_pViewporter) { pFractionalScaleInfo = makeShared(g_pHyprpaper->m_pFractionalScale->sendGetFractionalScale(pSurface->resource())); pFractionalScaleInfo->setPreferredScale([this](CCWpFractionalScaleV1* r, uint32_t sc120) { const double SCALE = sc120 / 120.0; Debug::log(LOG, "handlePreferredScale: {:.2f} for {:x}", SCALE, (uintptr_t)this); if (fScale != SCALE) { fScale = SCALE; std::lock_guard lg(g_pHyprpaper->m_mtTickMutex); m_pMonitor->wantsReload = true; g_pHyprpaper->tick(true); } }); pViewport = makeShared(g_pHyprpaper->m_pViewporter->sendGetViewport(pSurface->resource())); pSurface->sendCommit(); } else Debug::log(ERR, "No fractional-scale-v1 / wp-viewporter support from the compositor! fractional scaling will not work."); wl_display_flush(g_pHyprpaper->m_sDisplay); } CLayerSurface::~CLayerSurface() { // hyprwayland-scanner will send the destructors automatically. Neat. pLayerSurface.reset(); pFractionalScaleInfo.reset(); pViewport.reset(); pSurface.reset(); wl_display_flush(g_pHyprpaper->m_sDisplay); } hyprpaper-0.7.6/src/render/LayerSurface.hpp000066400000000000000000000012521507224720000207010ustar00rootroot00000000000000#pragma once #include "../defines.hpp" #include "protocols/fractional-scale-v1.hpp" #include "protocols/viewporter.hpp" #include "protocols/wayland.hpp" #include "protocols/wlr-layer-shell-unstable-v1.hpp" struct SMonitor; class CLayerSurface { public: explicit CLayerSurface(SMonitor*); ~CLayerSurface(); SMonitor* m_pMonitor = nullptr; SP pLayerSurface = nullptr; SP pSurface = nullptr; SP pFractionalScaleInfo = nullptr; SP pViewport = nullptr; double fScale = 1.0; }; hyprpaper-0.7.6/src/render/WallpaperTarget.cpp000066400000000000000000000015351507224720000214110ustar00rootroot00000000000000#include "WallpaperTarget.hpp" #include #include using namespace Hyprgraphics; CWallpaperTarget::~CWallpaperTarget() { ; } void CWallpaperTarget::create(const std::string& path) { m_szPath = path; const auto BEGINLOAD = std::chrono::system_clock::now(); auto loadedImage = CImage(path); if (!loadedImage.success()) { Debug::log(CRIT, "Cannot load image {}: {}", path, loadedImage.getError()); exit(1); } m_vSize = loadedImage.cairoSurface()->size(); const auto MS = std::chrono::duration_cast(std::chrono::system_clock::now() - BEGINLOAD).count() / 1000.f; Debug::log(LOG, "Preloaded target {} in {:.2f}ms -> Pixel size: [{}, {}]", path, MS, (int)m_vSize.x, (int)m_vSize.y); m_pCairoSurface = loadedImage.cairoSurface(); } hyprpaper-0.7.6/src/render/WallpaperTarget.hpp000066400000000000000000000006511507224720000214140ustar00rootroot00000000000000#pragma once #include "../defines.hpp" #include class CWallpaperTarget { public: ~CWallpaperTarget(); void create(const std::string& path); std::string m_szPath; Vector2D m_vSize; bool m_bHasAlpha = true; SP m_pCairoSurface; }; hyprpaper-0.7.6/systemd/000077500000000000000000000000001507224720000152255ustar00rootroot00000000000000hyprpaper-0.7.6/systemd/hyprpaper.service.in000066400000000000000000000006521507224720000212310ustar00rootroot00000000000000[Unit] Description=Fast, IPC-controlled wallpaper utility for Hyprland. Documentation=https://wiki.hyprland.org/Hypr-Ecosystem/hyprpaper/ PartOf=graphical-session.target Requires=graphical-session.target After=graphical-session.target ConditionEnvironment=WAYLAND_DISPLAY [Service] Type=simple ExecStart=@CMAKE_INSTALL_PREFIX@/bin/hyprpaper Slice=session.slice Restart=on-failure [Install] WantedBy=graphical-session.target